14aea3d0cSYoshinori Sato /* 24aea3d0cSYoshinori Sato * Renesas RX Disassembler 34aea3d0cSYoshinori Sato * 44aea3d0cSYoshinori Sato * Copyright (c) 2019 Yoshinori Sato <ysato@users.sourceforge.jp> 54aea3d0cSYoshinori Sato * 64aea3d0cSYoshinori Sato * This program is free software; you can redistribute it and/or modify it 74aea3d0cSYoshinori Sato * under the terms and conditions of the GNU General Public License, 84aea3d0cSYoshinori Sato * version 2 or later, as published by the Free Software Foundation. 94aea3d0cSYoshinori Sato * 104aea3d0cSYoshinori Sato * This program is distributed in the hope it will be useful, but WITHOUT 114aea3d0cSYoshinori Sato * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 124aea3d0cSYoshinori Sato * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 134aea3d0cSYoshinori Sato * more details. 144aea3d0cSYoshinori Sato * 154aea3d0cSYoshinori Sato * You should have received a copy of the GNU General Public License along with 164aea3d0cSYoshinori Sato * this program. If not, see <http://www.gnu.org/licenses/>. 174aea3d0cSYoshinori Sato */ 184aea3d0cSYoshinori Sato 194aea3d0cSYoshinori Sato #include "qemu/osdep.h" 204aea3d0cSYoshinori Sato #include "disas/dis-asm.h" 214aea3d0cSYoshinori Sato #include "qemu/bitops.h" 224aea3d0cSYoshinori Sato #include "cpu.h" 234aea3d0cSYoshinori Sato 244aea3d0cSYoshinori Sato typedef struct DisasContext { 254aea3d0cSYoshinori Sato disassemble_info *dis; 264aea3d0cSYoshinori Sato uint32_t addr; 274aea3d0cSYoshinori Sato uint32_t pc; 28*05a8599fSRichard Henderson uint8_t len; 29*05a8599fSRichard Henderson uint8_t bytes[8]; 304aea3d0cSYoshinori Sato } DisasContext; 314aea3d0cSYoshinori Sato 324aea3d0cSYoshinori Sato 334aea3d0cSYoshinori Sato static uint32_t decode_load_bytes(DisasContext *ctx, uint32_t insn, 344aea3d0cSYoshinori Sato int i, int n) 354aea3d0cSYoshinori Sato { 36*05a8599fSRichard Henderson uint32_t addr = ctx->addr; 37*05a8599fSRichard Henderson 38*05a8599fSRichard Henderson g_assert(ctx->len == i); 39*05a8599fSRichard Henderson g_assert(n <= ARRAY_SIZE(ctx->bytes)); 40*05a8599fSRichard Henderson 414aea3d0cSYoshinori Sato while (++i <= n) { 42*05a8599fSRichard Henderson ctx->dis->read_memory_func(addr++, &ctx->bytes[i - 1], 1, ctx->dis); 43*05a8599fSRichard Henderson insn |= ctx->bytes[i - 1] << (32 - i * 8); 444aea3d0cSYoshinori Sato } 45*05a8599fSRichard Henderson ctx->addr = addr; 46*05a8599fSRichard Henderson ctx->len = n; 47*05a8599fSRichard Henderson 484aea3d0cSYoshinori Sato return insn; 494aea3d0cSYoshinori Sato } 504aea3d0cSYoshinori Sato 514aea3d0cSYoshinori Sato static int32_t li(DisasContext *ctx, int sz) 524aea3d0cSYoshinori Sato { 53*05a8599fSRichard Henderson uint32_t addr = ctx->addr; 54*05a8599fSRichard Henderson uintptr_t len = ctx->len; 554aea3d0cSYoshinori Sato 564aea3d0cSYoshinori Sato switch (sz) { 574aea3d0cSYoshinori Sato case 1: 58*05a8599fSRichard Henderson g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes)); 594aea3d0cSYoshinori Sato ctx->addr += 1; 60*05a8599fSRichard Henderson ctx->len += 1; 61*05a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis); 62*05a8599fSRichard Henderson return (int8_t)ctx->bytes[len]; 634aea3d0cSYoshinori Sato case 2: 64*05a8599fSRichard Henderson g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes)); 654aea3d0cSYoshinori Sato ctx->addr += 2; 66*05a8599fSRichard Henderson ctx->len += 2; 67*05a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis); 68*05a8599fSRichard Henderson return ldsw_le_p(ctx->bytes + len); 694aea3d0cSYoshinori Sato case 3: 70*05a8599fSRichard Henderson g_assert(len + 3 <= ARRAY_SIZE(ctx->bytes)); 714aea3d0cSYoshinori Sato ctx->addr += 3; 72*05a8599fSRichard Henderson ctx->len += 3; 73*05a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 3, ctx->dis); 74*05a8599fSRichard Henderson return (int8_t)ctx->bytes[len + 2] << 16 | lduw_le_p(ctx->bytes + len); 754aea3d0cSYoshinori Sato case 0: 76*05a8599fSRichard Henderson g_assert(len + 4 <= ARRAY_SIZE(ctx->bytes)); 774aea3d0cSYoshinori Sato ctx->addr += 4; 78*05a8599fSRichard Henderson ctx->len += 4; 79*05a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 4, ctx->dis); 80*05a8599fSRichard Henderson return ldl_le_p(ctx->bytes + len); 814aea3d0cSYoshinori Sato default: 824aea3d0cSYoshinori Sato g_assert_not_reached(); 834aea3d0cSYoshinori Sato } 844aea3d0cSYoshinori Sato } 854aea3d0cSYoshinori Sato 864aea3d0cSYoshinori Sato static int bdsp_s(DisasContext *ctx, int d) 874aea3d0cSYoshinori Sato { 884aea3d0cSYoshinori Sato /* 894aea3d0cSYoshinori Sato * 0 -> 8 904aea3d0cSYoshinori Sato * 1 -> 9 914aea3d0cSYoshinori Sato * 2 -> 10 924aea3d0cSYoshinori Sato * 3 -> 3 934aea3d0cSYoshinori Sato * : 944aea3d0cSYoshinori Sato * 7 -> 7 954aea3d0cSYoshinori Sato */ 964aea3d0cSYoshinori Sato if (d < 3) { 974aea3d0cSYoshinori Sato d += 8; 984aea3d0cSYoshinori Sato } 994aea3d0cSYoshinori Sato return d; 1004aea3d0cSYoshinori Sato } 1014aea3d0cSYoshinori Sato 1024aea3d0cSYoshinori Sato /* Include the auto-generated decoder. */ 1034aea3d0cSYoshinori Sato #include "decode.inc.c" 1044aea3d0cSYoshinori Sato 1054aea3d0cSYoshinori Sato #define prt(...) (ctx->dis->fprintf_func)((ctx->dis->stream), __VA_ARGS__) 1064aea3d0cSYoshinori Sato 1074aea3d0cSYoshinori Sato #define RX_MEMORY_BYTE 0 1084aea3d0cSYoshinori Sato #define RX_MEMORY_WORD 1 1094aea3d0cSYoshinori Sato #define RX_MEMORY_LONG 2 1104aea3d0cSYoshinori Sato 1114aea3d0cSYoshinori Sato #define RX_IM_BYTE 0 1124aea3d0cSYoshinori Sato #define RX_IM_WORD 1 1134aea3d0cSYoshinori Sato #define RX_IM_LONG 2 1144aea3d0cSYoshinori Sato #define RX_IM_UWORD 3 1154aea3d0cSYoshinori Sato 1164aea3d0cSYoshinori Sato static const char size[] = {'b', 'w', 'l'}; 1174aea3d0cSYoshinori Sato static const char cond[][4] = { 1184aea3d0cSYoshinori Sato "eq", "ne", "c", "nc", "gtu", "leu", "pz", "n", 1194aea3d0cSYoshinori Sato "ge", "lt", "gt", "le", "o", "no", "ra", "f" 1204aea3d0cSYoshinori Sato }; 1214aea3d0cSYoshinori Sato static const char psw[] = { 1224aea3d0cSYoshinori Sato 'c', 'z', 's', 'o', 0, 0, 0, 0, 1234aea3d0cSYoshinori Sato 'i', 'u', 0, 0, 0, 0, 0, 0, 1244aea3d0cSYoshinori Sato }; 1254aea3d0cSYoshinori Sato 126fa6289e2SRichard Henderson static void rx_index_addr(DisasContext *ctx, char out[8], int ld, int mi) 1274aea3d0cSYoshinori Sato { 128fa6289e2SRichard Henderson uint32_t addr = ctx->addr; 129*05a8599fSRichard Henderson uintptr_t len = ctx->len; 130fa6289e2SRichard Henderson uint16_t dsp; 131fa6289e2SRichard Henderson 1324aea3d0cSYoshinori Sato switch (ld) { 1334aea3d0cSYoshinori Sato case 0: 134fa6289e2SRichard Henderson /* No index; return empty string. */ 135fa6289e2SRichard Henderson out[0] = '\0'; 136fa6289e2SRichard Henderson return; 1374aea3d0cSYoshinori Sato case 1: 138*05a8599fSRichard Henderson g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes)); 1394aea3d0cSYoshinori Sato ctx->addr += 1; 140*05a8599fSRichard Henderson ctx->len += 1; 141*05a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis); 142*05a8599fSRichard Henderson dsp = ctx->bytes[len]; 143fa6289e2SRichard Henderson break; 1444aea3d0cSYoshinori Sato case 2: 145*05a8599fSRichard Henderson g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes)); 1464aea3d0cSYoshinori Sato ctx->addr += 2; 147*05a8599fSRichard Henderson ctx->len += 2; 148*05a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis); 149*05a8599fSRichard Henderson dsp = lduw_le_p(ctx->bytes + len); 150fa6289e2SRichard Henderson break; 151fa6289e2SRichard Henderson default: 1524aea3d0cSYoshinori Sato g_assert_not_reached(); 1534aea3d0cSYoshinori Sato } 1544aea3d0cSYoshinori Sato 155fa6289e2SRichard Henderson sprintf(out, "%u", dsp << (mi < 3 ? mi : 4 - mi)); 156fa6289e2SRichard Henderson } 157fa6289e2SRichard Henderson 158e283adeaSRichard Henderson static void prt_ldmi(DisasContext *ctx, const char *insn, 159e283adeaSRichard Henderson int ld, int mi, int rs, int rd) 1604aea3d0cSYoshinori Sato { 1614aea3d0cSYoshinori Sato static const char sizes[][4] = {".b", ".w", ".l", ".uw", ".ub"}; 162fa6289e2SRichard Henderson char dsp[8]; 163fa6289e2SRichard Henderson 1644aea3d0cSYoshinori Sato if (ld < 3) { 165fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, ld, mi); 166e283adeaSRichard Henderson prt("%s\t%s[r%d]%s, r%d", insn, dsp, rs, sizes[mi], rd); 1674aea3d0cSYoshinori Sato } else { 168e283adeaSRichard Henderson prt("%s\tr%d, r%d", insn, rs, rd); 1694aea3d0cSYoshinori Sato } 1704aea3d0cSYoshinori Sato } 1714aea3d0cSYoshinori Sato 1724aea3d0cSYoshinori Sato static void prt_ir(DisasContext *ctx, const char *insn, int imm, int rd) 1734aea3d0cSYoshinori Sato { 1744aea3d0cSYoshinori Sato if (imm < 0x100) { 1754aea3d0cSYoshinori Sato prt("%s\t#%d, r%d", insn, imm, rd); 1764aea3d0cSYoshinori Sato } else { 1774aea3d0cSYoshinori Sato prt("%s\t#0x%08x, r%d", insn, imm, rd); 1784aea3d0cSYoshinori Sato } 1794aea3d0cSYoshinori Sato } 1804aea3d0cSYoshinori Sato 1814aea3d0cSYoshinori Sato /* mov.[bwl] rs,dsp:[rd] */ 1824aea3d0cSYoshinori Sato static bool trans_MOV_rm(DisasContext *ctx, arg_MOV_rm *a) 1834aea3d0cSYoshinori Sato { 1844aea3d0cSYoshinori Sato if (a->dsp > 0) { 1854aea3d0cSYoshinori Sato prt("mov.%c\tr%d,%d[r%d]", 1864aea3d0cSYoshinori Sato size[a->sz], a->rs, a->dsp << a->sz, a->rd); 1874aea3d0cSYoshinori Sato } else { 1884aea3d0cSYoshinori Sato prt("mov.%c\tr%d,[r%d]", 1894aea3d0cSYoshinori Sato size[a->sz], a->rs, a->rd); 1904aea3d0cSYoshinori Sato } 1914aea3d0cSYoshinori Sato return true; 1924aea3d0cSYoshinori Sato } 1934aea3d0cSYoshinori Sato 1944aea3d0cSYoshinori Sato /* mov.[bwl] dsp:[rs],rd */ 1954aea3d0cSYoshinori Sato static bool trans_MOV_mr(DisasContext *ctx, arg_MOV_mr *a) 1964aea3d0cSYoshinori Sato { 1974aea3d0cSYoshinori Sato if (a->dsp > 0) { 1984aea3d0cSYoshinori Sato prt("mov.%c\t%d[r%d], r%d", 1994aea3d0cSYoshinori Sato size[a->sz], a->dsp << a->sz, a->rs, a->rd); 2004aea3d0cSYoshinori Sato } else { 2014aea3d0cSYoshinori Sato prt("mov.%c\t[r%d], r%d", 2024aea3d0cSYoshinori Sato size[a->sz], a->rs, a->rd); 2034aea3d0cSYoshinori Sato } 2044aea3d0cSYoshinori Sato return true; 2054aea3d0cSYoshinori Sato } 2064aea3d0cSYoshinori Sato 2074aea3d0cSYoshinori Sato /* mov.l #uimm4,rd */ 2084aea3d0cSYoshinori Sato /* mov.l #uimm8,rd */ 2094aea3d0cSYoshinori Sato /* mov.l #imm,rd */ 2104aea3d0cSYoshinori Sato static bool trans_MOV_ir(DisasContext *ctx, arg_MOV_ir *a) 2114aea3d0cSYoshinori Sato { 2124aea3d0cSYoshinori Sato prt_ir(ctx, "mov.l", a->imm, a->rd); 2134aea3d0cSYoshinori Sato return true; 2144aea3d0cSYoshinori Sato } 2154aea3d0cSYoshinori Sato 2164aea3d0cSYoshinori Sato /* mov.[bwl] #uimm8,dsp:[rd] */ 2174aea3d0cSYoshinori Sato /* mov #imm, dsp:[rd] */ 2184aea3d0cSYoshinori Sato static bool trans_MOV_im(DisasContext *ctx, arg_MOV_im *a) 2194aea3d0cSYoshinori Sato { 2204aea3d0cSYoshinori Sato if (a->dsp > 0) { 2214aea3d0cSYoshinori Sato prt("mov.%c\t#%d,%d[r%d]", 2224aea3d0cSYoshinori Sato size[a->sz], a->imm, a->dsp << a->sz, a->rd); 2234aea3d0cSYoshinori Sato } else { 2244aea3d0cSYoshinori Sato prt("mov.%c\t#%d,[r%d]", 2254aea3d0cSYoshinori Sato size[a->sz], a->imm, a->rd); 2264aea3d0cSYoshinori Sato } 2274aea3d0cSYoshinori Sato return true; 2284aea3d0cSYoshinori Sato } 2294aea3d0cSYoshinori Sato 2304aea3d0cSYoshinori Sato /* mov.[bwl] [ri,rb],rd */ 2314aea3d0cSYoshinori Sato static bool trans_MOV_ar(DisasContext *ctx, arg_MOV_ar *a) 2324aea3d0cSYoshinori Sato { 2334aea3d0cSYoshinori Sato prt("mov.%c\t[r%d,r%d], r%d", size[a->sz], a->ri, a->rb, a->rd); 2344aea3d0cSYoshinori Sato return true; 2354aea3d0cSYoshinori Sato } 2364aea3d0cSYoshinori Sato 2374aea3d0cSYoshinori Sato /* mov.[bwl] rd,[ri,rb] */ 2384aea3d0cSYoshinori Sato static bool trans_MOV_ra(DisasContext *ctx, arg_MOV_ra *a) 2394aea3d0cSYoshinori Sato { 2404aea3d0cSYoshinori Sato prt("mov.%c\tr%d, [r%d, r%d]", size[a->sz], a->rs, a->ri, a->rb); 2414aea3d0cSYoshinori Sato return true; 2424aea3d0cSYoshinori Sato } 2434aea3d0cSYoshinori Sato 2444aea3d0cSYoshinori Sato 2454aea3d0cSYoshinori Sato /* mov.[bwl] dsp:[rs],dsp:[rd] */ 2464aea3d0cSYoshinori Sato /* mov.[bwl] rs,dsp:[rd] */ 2474aea3d0cSYoshinori Sato /* mov.[bwl] dsp:[rs],rd */ 2484aea3d0cSYoshinori Sato /* mov.[bwl] rs,rd */ 2494aea3d0cSYoshinori Sato static bool trans_MOV_mm(DisasContext *ctx, arg_MOV_mm *a) 2504aea3d0cSYoshinori Sato { 25167eb12d8SRichard Henderson char dspd[8], dsps[8], szc = size[a->sz]; 2524aea3d0cSYoshinori Sato 2534aea3d0cSYoshinori Sato if (a->lds == 3 && a->ldd == 3) { 2544aea3d0cSYoshinori Sato /* mov.[bwl] rs,rd */ 25567eb12d8SRichard Henderson prt("mov.%c\tr%d, r%d", szc, a->rs, a->rd); 25667eb12d8SRichard Henderson } else if (a->lds == 3) { 257fa6289e2SRichard Henderson rx_index_addr(ctx, dspd, a->ldd, a->sz); 25867eb12d8SRichard Henderson prt("mov.%c\tr%d, %s[r%d]", szc, a->rs, dspd, a->rd); 2594aea3d0cSYoshinori Sato } else if (a->ldd == 3) { 260fa6289e2SRichard Henderson rx_index_addr(ctx, dsps, a->lds, a->sz); 26167eb12d8SRichard Henderson prt("mov.%c\t%s[r%d], r%d", szc, dsps, a->rs, a->rd); 2624aea3d0cSYoshinori Sato } else { 263fa6289e2SRichard Henderson rx_index_addr(ctx, dsps, a->lds, a->sz); 264fa6289e2SRichard Henderson rx_index_addr(ctx, dspd, a->ldd, a->sz); 26567eb12d8SRichard Henderson prt("mov.%c\t%s[r%d], %s[r%d]", szc, dsps, a->rs, dspd, a->rd); 2664aea3d0cSYoshinori Sato } 2674aea3d0cSYoshinori Sato return true; 2684aea3d0cSYoshinori Sato } 2694aea3d0cSYoshinori Sato 2704aea3d0cSYoshinori Sato /* mov.[bwl] rs,[rd+] */ 2714aea3d0cSYoshinori Sato /* mov.[bwl] rs,[-rd] */ 2724aea3d0cSYoshinori Sato static bool trans_MOV_rp(DisasContext *ctx, arg_MOV_rp *a) 2734aea3d0cSYoshinori Sato { 27467eb12d8SRichard Henderson if (a->ad) { 27567eb12d8SRichard Henderson prt("mov.%c\tr%d, [-r%d]", size[a->sz], a->rs, a->rd); 27667eb12d8SRichard Henderson } else { 27767eb12d8SRichard Henderson prt("mov.%c\tr%d, [r%d+]", size[a->sz], a->rs, a->rd); 27867eb12d8SRichard Henderson } 2794aea3d0cSYoshinori Sato return true; 2804aea3d0cSYoshinori Sato } 2814aea3d0cSYoshinori Sato 2824aea3d0cSYoshinori Sato /* mov.[bwl] [rd+],rs */ 2834aea3d0cSYoshinori Sato /* mov.[bwl] [-rd],rs */ 2844aea3d0cSYoshinori Sato static bool trans_MOV_pr(DisasContext *ctx, arg_MOV_pr *a) 2854aea3d0cSYoshinori Sato { 28667eb12d8SRichard Henderson if (a->ad) { 28767eb12d8SRichard Henderson prt("mov.%c\t[-r%d], r%d", size[a->sz], a->rd, a->rs); 28867eb12d8SRichard Henderson } else { 28967eb12d8SRichard Henderson prt("mov.%c\t[r%d+], r%d", size[a->sz], a->rd, a->rs); 29067eb12d8SRichard Henderson } 2914aea3d0cSYoshinori Sato return true; 2924aea3d0cSYoshinori Sato } 2934aea3d0cSYoshinori Sato 2944aea3d0cSYoshinori Sato /* movu.[bw] dsp5:[rs],rd */ 2954aea3d0cSYoshinori Sato static bool trans_MOVU_mr(DisasContext *ctx, arg_MOVU_mr *a) 2964aea3d0cSYoshinori Sato { 2974aea3d0cSYoshinori Sato if (a->dsp > 0) { 2984aea3d0cSYoshinori Sato prt("movu.%c\t%d[r%d], r%d", size[a->sz], 2994aea3d0cSYoshinori Sato a->dsp << a->sz, a->rs, a->rd); 3004aea3d0cSYoshinori Sato } else { 3014aea3d0cSYoshinori Sato prt("movu.%c\t[r%d], r%d", size[a->sz], a->rs, a->rd); 3024aea3d0cSYoshinori Sato } 3034aea3d0cSYoshinori Sato return true; 3044aea3d0cSYoshinori Sato } 3054aea3d0cSYoshinori Sato 3064aea3d0cSYoshinori Sato /* movu.[bw] rs,rd */ 3074aea3d0cSYoshinori Sato static bool trans_MOVU_rr(DisasContext *ctx, arg_MOVU_rr *a) 3084aea3d0cSYoshinori Sato { 3094aea3d0cSYoshinori Sato prt("movu.%c\tr%d, r%d", size[a->sz], a->rs, a->rd); 3104aea3d0cSYoshinori Sato return true; 3114aea3d0cSYoshinori Sato } 3124aea3d0cSYoshinori Sato 3134aea3d0cSYoshinori Sato /* movu.[bw] [ri,rb],rd */ 3144aea3d0cSYoshinori Sato static bool trans_MOVU_ar(DisasContext *ctx, arg_MOVU_ar *a) 3154aea3d0cSYoshinori Sato { 3164aea3d0cSYoshinori Sato prt("mov.%c\t[r%d,r%d], r%d", size[a->sz], a->ri, a->rb, a->rd); 3174aea3d0cSYoshinori Sato return true; 3184aea3d0cSYoshinori Sato } 3194aea3d0cSYoshinori Sato 3204aea3d0cSYoshinori Sato /* movu.[bw] [rs+],rd */ 3214aea3d0cSYoshinori Sato /* movu.[bw] [-rs],rd */ 3224aea3d0cSYoshinori Sato static bool trans_MOVU_pr(DisasContext *ctx, arg_MOVU_pr *a) 3234aea3d0cSYoshinori Sato { 32467eb12d8SRichard Henderson if (a->ad) { 32567eb12d8SRichard Henderson prt("movu.%c\t[-r%d], r%d", size[a->sz], a->rd, a->rs); 32667eb12d8SRichard Henderson } else { 32767eb12d8SRichard Henderson prt("movu.%c\t[r%d+], r%d", size[a->sz], a->rd, a->rs); 32867eb12d8SRichard Henderson } 3294aea3d0cSYoshinori Sato return true; 3304aea3d0cSYoshinori Sato } 3314aea3d0cSYoshinori Sato 3324aea3d0cSYoshinori Sato /* pop rd */ 3334aea3d0cSYoshinori Sato static bool trans_POP(DisasContext *ctx, arg_POP *a) 3344aea3d0cSYoshinori Sato { 3354aea3d0cSYoshinori Sato prt("pop\tr%d", a->rd); 3364aea3d0cSYoshinori Sato return true; 3374aea3d0cSYoshinori Sato } 3384aea3d0cSYoshinori Sato 3394aea3d0cSYoshinori Sato /* popc rx */ 3404aea3d0cSYoshinori Sato static bool trans_POPC(DisasContext *ctx, arg_POPC *a) 3414aea3d0cSYoshinori Sato { 3424aea3d0cSYoshinori Sato prt("pop\tr%s", rx_crname(a->cr)); 3434aea3d0cSYoshinori Sato return true; 3444aea3d0cSYoshinori Sato } 3454aea3d0cSYoshinori Sato 3464aea3d0cSYoshinori Sato /* popm rd-rd2 */ 3474aea3d0cSYoshinori Sato static bool trans_POPM(DisasContext *ctx, arg_POPM *a) 3484aea3d0cSYoshinori Sato { 3494aea3d0cSYoshinori Sato prt("popm\tr%d-r%d", a->rd, a->rd2); 3504aea3d0cSYoshinori Sato return true; 3514aea3d0cSYoshinori Sato } 3524aea3d0cSYoshinori Sato 3534aea3d0cSYoshinori Sato /* push rs */ 3544aea3d0cSYoshinori Sato static bool trans_PUSH_r(DisasContext *ctx, arg_PUSH_r *a) 3554aea3d0cSYoshinori Sato { 3564aea3d0cSYoshinori Sato prt("push\tr%d", a->rs); 3574aea3d0cSYoshinori Sato return true; 3584aea3d0cSYoshinori Sato } 3594aea3d0cSYoshinori Sato 3604aea3d0cSYoshinori Sato /* push dsp[rs] */ 3614aea3d0cSYoshinori Sato static bool trans_PUSH_m(DisasContext *ctx, arg_PUSH_m *a) 3624aea3d0cSYoshinori Sato { 363fa6289e2SRichard Henderson char dsp[8]; 364fa6289e2SRichard Henderson 365fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, a->sz); 366fa6289e2SRichard Henderson prt("push\t%s[r%d]", dsp, a->rs); 3674aea3d0cSYoshinori Sato return true; 3684aea3d0cSYoshinori Sato } 3694aea3d0cSYoshinori Sato 3704aea3d0cSYoshinori Sato /* pushc rx */ 3714aea3d0cSYoshinori Sato static bool trans_PUSHC(DisasContext *ctx, arg_PUSHC *a) 3724aea3d0cSYoshinori Sato { 3734aea3d0cSYoshinori Sato prt("push\t%s", rx_crname(a->cr)); 3744aea3d0cSYoshinori Sato return true; 3754aea3d0cSYoshinori Sato } 3764aea3d0cSYoshinori Sato 3774aea3d0cSYoshinori Sato /* pushm rs-rs2*/ 3784aea3d0cSYoshinori Sato static bool trans_PUSHM(DisasContext *ctx, arg_PUSHM *a) 3794aea3d0cSYoshinori Sato { 3804aea3d0cSYoshinori Sato prt("pushm\tr%d-r%d", a->rs, a->rs2); 3814aea3d0cSYoshinori Sato return true; 3824aea3d0cSYoshinori Sato } 3834aea3d0cSYoshinori Sato 3844aea3d0cSYoshinori Sato /* xchg rs,rd */ 3854aea3d0cSYoshinori Sato static bool trans_XCHG_rr(DisasContext *ctx, arg_XCHG_rr *a) 3864aea3d0cSYoshinori Sato { 3874aea3d0cSYoshinori Sato prt("xchg\tr%d, r%d", a->rs, a->rd); 3884aea3d0cSYoshinori Sato return true; 3894aea3d0cSYoshinori Sato } 3904aea3d0cSYoshinori Sato /* xchg dsp[rs].<mi>,rd */ 3914aea3d0cSYoshinori Sato static bool trans_XCHG_mr(DisasContext *ctx, arg_XCHG_mr *a) 3924aea3d0cSYoshinori Sato { 3935cf7c960SRichard Henderson prt_ldmi(ctx, "xchg", a->ld, a->mi, a->rs, a->rd); 3944aea3d0cSYoshinori Sato return true; 3954aea3d0cSYoshinori Sato } 3964aea3d0cSYoshinori Sato 3974aea3d0cSYoshinori Sato /* stz #imm,rd */ 3984aea3d0cSYoshinori Sato static bool trans_STZ(DisasContext *ctx, arg_STZ *a) 3994aea3d0cSYoshinori Sato { 4004aea3d0cSYoshinori Sato prt_ir(ctx, "stz", a->imm, a->rd); 4014aea3d0cSYoshinori Sato return true; 4024aea3d0cSYoshinori Sato } 4034aea3d0cSYoshinori Sato 4044aea3d0cSYoshinori Sato /* stnz #imm,rd */ 4054aea3d0cSYoshinori Sato static bool trans_STNZ(DisasContext *ctx, arg_STNZ *a) 4064aea3d0cSYoshinori Sato { 4074aea3d0cSYoshinori Sato prt_ir(ctx, "stnz", a->imm, a->rd); 4084aea3d0cSYoshinori Sato return true; 4094aea3d0cSYoshinori Sato } 4104aea3d0cSYoshinori Sato 4114aea3d0cSYoshinori Sato /* rtsd #imm */ 4124aea3d0cSYoshinori Sato static bool trans_RTSD_i(DisasContext *ctx, arg_RTSD_i *a) 4134aea3d0cSYoshinori Sato { 4144aea3d0cSYoshinori Sato prt("rtsd\t#%d", a->imm << 2); 4154aea3d0cSYoshinori Sato return true; 4164aea3d0cSYoshinori Sato } 4174aea3d0cSYoshinori Sato 4184aea3d0cSYoshinori Sato /* rtsd #imm, rd-rd2 */ 4194aea3d0cSYoshinori Sato static bool trans_RTSD_irr(DisasContext *ctx, arg_RTSD_irr *a) 4204aea3d0cSYoshinori Sato { 4214aea3d0cSYoshinori Sato prt("rtsd\t#%d, r%d - r%d", a->imm << 2, a->rd, a->rd2); 4224aea3d0cSYoshinori Sato return true; 4234aea3d0cSYoshinori Sato } 4244aea3d0cSYoshinori Sato 4254aea3d0cSYoshinori Sato /* and #uimm:4, rd */ 4264aea3d0cSYoshinori Sato /* and #imm, rd */ 4274aea3d0cSYoshinori Sato static bool trans_AND_ir(DisasContext *ctx, arg_AND_ir *a) 4284aea3d0cSYoshinori Sato { 4294aea3d0cSYoshinori Sato prt_ir(ctx, "and", a->imm, a->rd); 4304aea3d0cSYoshinori Sato return true; 4314aea3d0cSYoshinori Sato } 4324aea3d0cSYoshinori Sato 4334aea3d0cSYoshinori Sato /* and dsp[rs], rd */ 4344aea3d0cSYoshinori Sato /* and rs,rd */ 4354aea3d0cSYoshinori Sato static bool trans_AND_mr(DisasContext *ctx, arg_AND_mr *a) 4364aea3d0cSYoshinori Sato { 437e283adeaSRichard Henderson prt_ldmi(ctx, "and", a->ld, a->mi, a->rs, a->rd); 4384aea3d0cSYoshinori Sato return true; 4394aea3d0cSYoshinori Sato } 4404aea3d0cSYoshinori Sato 4414aea3d0cSYoshinori Sato /* and rs,rs2,rd */ 4424aea3d0cSYoshinori Sato static bool trans_AND_rrr(DisasContext *ctx, arg_AND_rrr *a) 4434aea3d0cSYoshinori Sato { 4444aea3d0cSYoshinori Sato prt("and\tr%d,r%d, r%d", a->rs, a->rs2, a->rd); 4454aea3d0cSYoshinori Sato return true; 4464aea3d0cSYoshinori Sato } 4474aea3d0cSYoshinori Sato 4484aea3d0cSYoshinori Sato /* or #uimm:4, rd */ 4494aea3d0cSYoshinori Sato /* or #imm, rd */ 4504aea3d0cSYoshinori Sato static bool trans_OR_ir(DisasContext *ctx, arg_OR_ir *a) 4514aea3d0cSYoshinori Sato { 4524aea3d0cSYoshinori Sato prt_ir(ctx, "or", a->imm, a->rd); 4534aea3d0cSYoshinori Sato return true; 4544aea3d0cSYoshinori Sato } 4554aea3d0cSYoshinori Sato 4564aea3d0cSYoshinori Sato /* or dsp[rs], rd */ 4574aea3d0cSYoshinori Sato /* or rs,rd */ 4584aea3d0cSYoshinori Sato static bool trans_OR_mr(DisasContext *ctx, arg_OR_mr *a) 4594aea3d0cSYoshinori Sato { 460e283adeaSRichard Henderson prt_ldmi(ctx, "or", a->ld, a->mi, a->rs, a->rd); 4614aea3d0cSYoshinori Sato return true; 4624aea3d0cSYoshinori Sato } 4634aea3d0cSYoshinori Sato 4644aea3d0cSYoshinori Sato /* or rs,rs2,rd */ 4654aea3d0cSYoshinori Sato static bool trans_OR_rrr(DisasContext *ctx, arg_OR_rrr *a) 4664aea3d0cSYoshinori Sato { 4674aea3d0cSYoshinori Sato prt("or\tr%d, r%d, r%d", a->rs, a->rs2, a->rd); 4684aea3d0cSYoshinori Sato return true; 4694aea3d0cSYoshinori Sato } 4704aea3d0cSYoshinori Sato 4714aea3d0cSYoshinori Sato /* xor #imm, rd */ 4724aea3d0cSYoshinori Sato static bool trans_XOR_ir(DisasContext *ctx, arg_XOR_ir *a) 4734aea3d0cSYoshinori Sato { 4744aea3d0cSYoshinori Sato prt_ir(ctx, "xor", a->imm, a->rd); 4754aea3d0cSYoshinori Sato return true; 4764aea3d0cSYoshinori Sato } 4774aea3d0cSYoshinori Sato 4784aea3d0cSYoshinori Sato /* xor dsp[rs], rd */ 4794aea3d0cSYoshinori Sato /* xor rs,rd */ 4804aea3d0cSYoshinori Sato static bool trans_XOR_mr(DisasContext *ctx, arg_XOR_mr *a) 4814aea3d0cSYoshinori Sato { 482e283adeaSRichard Henderson prt_ldmi(ctx, "xor", a->ld, a->mi, a->rs, a->rd); 4834aea3d0cSYoshinori Sato return true; 4844aea3d0cSYoshinori Sato } 4854aea3d0cSYoshinori Sato 4864aea3d0cSYoshinori Sato /* tst #imm, rd */ 4874aea3d0cSYoshinori Sato static bool trans_TST_ir(DisasContext *ctx, arg_TST_ir *a) 4884aea3d0cSYoshinori Sato { 4894aea3d0cSYoshinori Sato prt_ir(ctx, "tst", a->imm, a->rd); 4904aea3d0cSYoshinori Sato return true; 4914aea3d0cSYoshinori Sato } 4924aea3d0cSYoshinori Sato 4934aea3d0cSYoshinori Sato /* tst dsp[rs], rd */ 4944aea3d0cSYoshinori Sato /* tst rs, rd */ 4954aea3d0cSYoshinori Sato static bool trans_TST_mr(DisasContext *ctx, arg_TST_mr *a) 4964aea3d0cSYoshinori Sato { 497e283adeaSRichard Henderson prt_ldmi(ctx, "tst", a->ld, a->mi, a->rs, a->rd); 4984aea3d0cSYoshinori Sato return true; 4994aea3d0cSYoshinori Sato } 5004aea3d0cSYoshinori Sato 5014aea3d0cSYoshinori Sato /* not rd */ 5024aea3d0cSYoshinori Sato /* not rs, rd */ 5034aea3d0cSYoshinori Sato static bool trans_NOT_rr(DisasContext *ctx, arg_NOT_rr *a) 5044aea3d0cSYoshinori Sato { 5054aea3d0cSYoshinori Sato if (a->rs != a->rd) { 50667eb12d8SRichard Henderson prt("not\tr%d, r%d", a->rs, a->rd); 50767eb12d8SRichard Henderson } else { 50867eb12d8SRichard Henderson prt("not\tr%d", a->rs); 5094aea3d0cSYoshinori Sato } 5104aea3d0cSYoshinori Sato return true; 5114aea3d0cSYoshinori Sato } 5124aea3d0cSYoshinori Sato 5134aea3d0cSYoshinori Sato /* neg rd */ 5144aea3d0cSYoshinori Sato /* neg rs, rd */ 5154aea3d0cSYoshinori Sato static bool trans_NEG_rr(DisasContext *ctx, arg_NEG_rr *a) 5164aea3d0cSYoshinori Sato { 5174aea3d0cSYoshinori Sato if (a->rs != a->rd) { 51867eb12d8SRichard Henderson prt("neg\tr%d, r%d", a->rs, a->rd); 51967eb12d8SRichard Henderson } else { 52067eb12d8SRichard Henderson prt("neg\tr%d", a->rs); 5214aea3d0cSYoshinori Sato } 5224aea3d0cSYoshinori Sato return true; 5234aea3d0cSYoshinori Sato } 5244aea3d0cSYoshinori Sato 5254aea3d0cSYoshinori Sato /* adc #imm, rd */ 5264aea3d0cSYoshinori Sato static bool trans_ADC_ir(DisasContext *ctx, arg_ADC_ir *a) 5274aea3d0cSYoshinori Sato { 5284aea3d0cSYoshinori Sato prt_ir(ctx, "adc", a->imm, a->rd); 5294aea3d0cSYoshinori Sato return true; 5304aea3d0cSYoshinori Sato } 5314aea3d0cSYoshinori Sato 5324aea3d0cSYoshinori Sato /* adc rs, rd */ 5334aea3d0cSYoshinori Sato static bool trans_ADC_rr(DisasContext *ctx, arg_ADC_rr *a) 5344aea3d0cSYoshinori Sato { 5354aea3d0cSYoshinori Sato prt("adc\tr%d, r%d", a->rs, a->rd); 5364aea3d0cSYoshinori Sato return true; 5374aea3d0cSYoshinori Sato } 5384aea3d0cSYoshinori Sato 5394aea3d0cSYoshinori Sato /* adc dsp[rs], rd */ 5404aea3d0cSYoshinori Sato static bool trans_ADC_mr(DisasContext *ctx, arg_ADC_mr *a) 5414aea3d0cSYoshinori Sato { 542fa6289e2SRichard Henderson char dsp[8]; 543fa6289e2SRichard Henderson 544fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, 2); 545fa6289e2SRichard Henderson prt("adc\t%s[r%d], r%d", dsp, a->rs, a->rd); 5464aea3d0cSYoshinori Sato return true; 5474aea3d0cSYoshinori Sato } 5484aea3d0cSYoshinori Sato 5494aea3d0cSYoshinori Sato /* add #uimm4, rd */ 5504aea3d0cSYoshinori Sato /* add #imm, rs, rd */ 5514aea3d0cSYoshinori Sato static bool trans_ADD_irr(DisasContext *ctx, arg_ADD_irr *a) 5524aea3d0cSYoshinori Sato { 5534aea3d0cSYoshinori Sato if (a->imm < 0x10 && a->rs2 == a->rd) { 5544aea3d0cSYoshinori Sato prt("add\t#%d, r%d", a->imm, a->rd); 5554aea3d0cSYoshinori Sato } else { 5564aea3d0cSYoshinori Sato prt("add\t#0x%08x, r%d, r%d", a->imm, a->rs2, a->rd); 5574aea3d0cSYoshinori Sato } 5584aea3d0cSYoshinori Sato return true; 5594aea3d0cSYoshinori Sato } 5604aea3d0cSYoshinori Sato 5614aea3d0cSYoshinori Sato /* add rs, rd */ 5624aea3d0cSYoshinori Sato /* add dsp[rs], rd */ 5634aea3d0cSYoshinori Sato static bool trans_ADD_mr(DisasContext *ctx, arg_ADD_mr *a) 5644aea3d0cSYoshinori Sato { 565e283adeaSRichard Henderson prt_ldmi(ctx, "add", a->ld, a->mi, a->rs, a->rd); 5664aea3d0cSYoshinori Sato return true; 5674aea3d0cSYoshinori Sato } 5684aea3d0cSYoshinori Sato 5694aea3d0cSYoshinori Sato /* add rs, rs2, rd */ 5704aea3d0cSYoshinori Sato static bool trans_ADD_rrr(DisasContext *ctx, arg_ADD_rrr *a) 5714aea3d0cSYoshinori Sato { 5724aea3d0cSYoshinori Sato prt("add\tr%d, r%d, r%d", a->rs, a->rs2, a->rd); 5734aea3d0cSYoshinori Sato return true; 5744aea3d0cSYoshinori Sato } 5754aea3d0cSYoshinori Sato 5764aea3d0cSYoshinori Sato /* cmp #imm4, rd */ 5774aea3d0cSYoshinori Sato /* cmp #imm8, rd */ 5784aea3d0cSYoshinori Sato /* cmp #imm, rs2 */ 5794aea3d0cSYoshinori Sato static bool trans_CMP_ir(DisasContext *ctx, arg_CMP_ir *a) 5804aea3d0cSYoshinori Sato { 5814aea3d0cSYoshinori Sato prt_ir(ctx, "cmp", a->imm, a->rs2); 5824aea3d0cSYoshinori Sato return true; 5834aea3d0cSYoshinori Sato } 5844aea3d0cSYoshinori Sato 5854aea3d0cSYoshinori Sato /* cmp rs, rs2 */ 5864aea3d0cSYoshinori Sato /* cmp dsp[rs], rs2 */ 5874aea3d0cSYoshinori Sato static bool trans_CMP_mr(DisasContext *ctx, arg_CMP_mr *a) 5884aea3d0cSYoshinori Sato { 589e283adeaSRichard Henderson prt_ldmi(ctx, "cmp", a->ld, a->mi, a->rs, a->rd); 5904aea3d0cSYoshinori Sato return true; 5914aea3d0cSYoshinori Sato } 5924aea3d0cSYoshinori Sato 5934aea3d0cSYoshinori Sato /* sub #imm4, rd */ 5944aea3d0cSYoshinori Sato static bool trans_SUB_ir(DisasContext *ctx, arg_SUB_ir *a) 5954aea3d0cSYoshinori Sato { 5964aea3d0cSYoshinori Sato prt("sub\t#%d, r%d", a->imm, a->rd); 5974aea3d0cSYoshinori Sato return true; 5984aea3d0cSYoshinori Sato } 5994aea3d0cSYoshinori Sato 6004aea3d0cSYoshinori Sato /* sub rs, rd */ 6014aea3d0cSYoshinori Sato /* sub dsp[rs], rd */ 6024aea3d0cSYoshinori Sato static bool trans_SUB_mr(DisasContext *ctx, arg_SUB_mr *a) 6034aea3d0cSYoshinori Sato { 604e283adeaSRichard Henderson prt_ldmi(ctx, "sub", a->ld, a->mi, a->rs, a->rd); 6054aea3d0cSYoshinori Sato return true; 6064aea3d0cSYoshinori Sato } 6074aea3d0cSYoshinori Sato 6084aea3d0cSYoshinori Sato /* sub rs, rs2, rd */ 6094aea3d0cSYoshinori Sato static bool trans_SUB_rrr(DisasContext *ctx, arg_SUB_rrr *a) 6104aea3d0cSYoshinori Sato { 6114aea3d0cSYoshinori Sato prt("sub\tr%d, r%d, r%d", a->rs, a->rs2, a->rd); 6124aea3d0cSYoshinori Sato return true; 6134aea3d0cSYoshinori Sato } 6144aea3d0cSYoshinori Sato 6154aea3d0cSYoshinori Sato /* sbb rs, rd */ 6164aea3d0cSYoshinori Sato static bool trans_SBB_rr(DisasContext *ctx, arg_SBB_rr *a) 6174aea3d0cSYoshinori Sato { 6184aea3d0cSYoshinori Sato prt("sbb\tr%d, r%d", a->rs, a->rd); 6194aea3d0cSYoshinori Sato return true; 6204aea3d0cSYoshinori Sato } 6214aea3d0cSYoshinori Sato 6224aea3d0cSYoshinori Sato /* sbb dsp[rs], rd */ 6234aea3d0cSYoshinori Sato static bool trans_SBB_mr(DisasContext *ctx, arg_SBB_mr *a) 6244aea3d0cSYoshinori Sato { 625e283adeaSRichard Henderson prt_ldmi(ctx, "sbb", a->ld, RX_IM_LONG, a->rs, a->rd); 6264aea3d0cSYoshinori Sato return true; 6274aea3d0cSYoshinori Sato } 6284aea3d0cSYoshinori Sato 6294aea3d0cSYoshinori Sato /* abs rd */ 6304aea3d0cSYoshinori Sato /* abs rs, rd */ 6314aea3d0cSYoshinori Sato static bool trans_ABS_rr(DisasContext *ctx, arg_ABS_rr *a) 6324aea3d0cSYoshinori Sato { 63367eb12d8SRichard Henderson if (a->rs != a->rd) { 63467eb12d8SRichard Henderson prt("abs\tr%d, r%d", a->rs, a->rd); 6354aea3d0cSYoshinori Sato } else { 63667eb12d8SRichard Henderson prt("abs\tr%d", a->rs); 6374aea3d0cSYoshinori Sato } 6384aea3d0cSYoshinori Sato return true; 6394aea3d0cSYoshinori Sato } 6404aea3d0cSYoshinori Sato 6414aea3d0cSYoshinori Sato /* max #imm, rd */ 6424aea3d0cSYoshinori Sato static bool trans_MAX_ir(DisasContext *ctx, arg_MAX_ir *a) 6434aea3d0cSYoshinori Sato { 6444aea3d0cSYoshinori Sato prt_ir(ctx, "max", a->imm, a->rd); 6454aea3d0cSYoshinori Sato return true; 6464aea3d0cSYoshinori Sato } 6474aea3d0cSYoshinori Sato 6484aea3d0cSYoshinori Sato /* max rs, rd */ 6494aea3d0cSYoshinori Sato /* max dsp[rs], rd */ 6504aea3d0cSYoshinori Sato static bool trans_MAX_mr(DisasContext *ctx, arg_MAX_mr *a) 6514aea3d0cSYoshinori Sato { 652e283adeaSRichard Henderson prt_ldmi(ctx, "max", a->ld, a->mi, a->rs, a->rd); 6534aea3d0cSYoshinori Sato return true; 6544aea3d0cSYoshinori Sato } 6554aea3d0cSYoshinori Sato 6564aea3d0cSYoshinori Sato /* min #imm, rd */ 6574aea3d0cSYoshinori Sato static bool trans_MIN_ir(DisasContext *ctx, arg_MIN_ir *a) 6584aea3d0cSYoshinori Sato { 6594aea3d0cSYoshinori Sato prt_ir(ctx, "min", a->imm, a->rd); 6604aea3d0cSYoshinori Sato return true; 6614aea3d0cSYoshinori Sato } 6624aea3d0cSYoshinori Sato 6634aea3d0cSYoshinori Sato /* min rs, rd */ 6644aea3d0cSYoshinori Sato /* min dsp[rs], rd */ 6654aea3d0cSYoshinori Sato static bool trans_MIN_mr(DisasContext *ctx, arg_MIN_mr *a) 6664aea3d0cSYoshinori Sato { 667e283adeaSRichard Henderson prt_ldmi(ctx, "min", a->ld, a->mi, a->rs, a->rd); 6684aea3d0cSYoshinori Sato return true; 6694aea3d0cSYoshinori Sato } 6704aea3d0cSYoshinori Sato 6714aea3d0cSYoshinori Sato /* mul #uimm4, rd */ 6724aea3d0cSYoshinori Sato /* mul #imm, rd */ 6734aea3d0cSYoshinori Sato static bool trans_MUL_ir(DisasContext *ctx, arg_MUL_ir *a) 6744aea3d0cSYoshinori Sato { 6754aea3d0cSYoshinori Sato prt_ir(ctx, "mul", a->imm, a->rd); 6764aea3d0cSYoshinori Sato return true; 6774aea3d0cSYoshinori Sato } 6784aea3d0cSYoshinori Sato 6794aea3d0cSYoshinori Sato /* mul rs, rd */ 6804aea3d0cSYoshinori Sato /* mul dsp[rs], rd */ 6814aea3d0cSYoshinori Sato static bool trans_MUL_mr(DisasContext *ctx, arg_MUL_mr *a) 6824aea3d0cSYoshinori Sato { 683e283adeaSRichard Henderson prt_ldmi(ctx, "mul", a->ld, a->mi, a->rs, a->rd); 6844aea3d0cSYoshinori Sato return true; 6854aea3d0cSYoshinori Sato } 6864aea3d0cSYoshinori Sato 6874aea3d0cSYoshinori Sato /* mul rs, rs2, rd */ 6884aea3d0cSYoshinori Sato static bool trans_MUL_rrr(DisasContext *ctx, arg_MUL_rrr *a) 6894aea3d0cSYoshinori Sato { 6904aea3d0cSYoshinori Sato prt("mul\tr%d,r%d,r%d", a->rs, a->rs2, a->rd); 6914aea3d0cSYoshinori Sato return true; 6924aea3d0cSYoshinori Sato } 6934aea3d0cSYoshinori Sato 6944aea3d0cSYoshinori Sato /* emul #imm, rd */ 6954aea3d0cSYoshinori Sato static bool trans_EMUL_ir(DisasContext *ctx, arg_EMUL_ir *a) 6964aea3d0cSYoshinori Sato { 6974aea3d0cSYoshinori Sato prt_ir(ctx, "emul", a->imm, a->rd); 6984aea3d0cSYoshinori Sato return true; 6994aea3d0cSYoshinori Sato } 7004aea3d0cSYoshinori Sato 7014aea3d0cSYoshinori Sato /* emul rs, rd */ 7024aea3d0cSYoshinori Sato /* emul dsp[rs], rd */ 7034aea3d0cSYoshinori Sato static bool trans_EMUL_mr(DisasContext *ctx, arg_EMUL_mr *a) 7044aea3d0cSYoshinori Sato { 705e283adeaSRichard Henderson prt_ldmi(ctx, "emul", a->ld, a->mi, a->rs, a->rd); 7064aea3d0cSYoshinori Sato return true; 7074aea3d0cSYoshinori Sato } 7084aea3d0cSYoshinori Sato 7094aea3d0cSYoshinori Sato /* emulu #imm, rd */ 7104aea3d0cSYoshinori Sato static bool trans_EMULU_ir(DisasContext *ctx, arg_EMULU_ir *a) 7114aea3d0cSYoshinori Sato { 7124aea3d0cSYoshinori Sato prt_ir(ctx, "emulu", a->imm, a->rd); 7134aea3d0cSYoshinori Sato return true; 7144aea3d0cSYoshinori Sato } 7154aea3d0cSYoshinori Sato 7164aea3d0cSYoshinori Sato /* emulu rs, rd */ 7174aea3d0cSYoshinori Sato /* emulu dsp[rs], rd */ 7184aea3d0cSYoshinori Sato static bool trans_EMULU_mr(DisasContext *ctx, arg_EMULU_mr *a) 7194aea3d0cSYoshinori Sato { 720e283adeaSRichard Henderson prt_ldmi(ctx, "emulu", a->ld, a->mi, a->rs, a->rd); 7214aea3d0cSYoshinori Sato return true; 7224aea3d0cSYoshinori Sato } 7234aea3d0cSYoshinori Sato 7244aea3d0cSYoshinori Sato /* div #imm, rd */ 7254aea3d0cSYoshinori Sato static bool trans_DIV_ir(DisasContext *ctx, arg_DIV_ir *a) 7264aea3d0cSYoshinori Sato { 7274aea3d0cSYoshinori Sato prt_ir(ctx, "div", a->imm, a->rd); 7284aea3d0cSYoshinori Sato return true; 7294aea3d0cSYoshinori Sato } 7304aea3d0cSYoshinori Sato 7314aea3d0cSYoshinori Sato /* div rs, rd */ 7324aea3d0cSYoshinori Sato /* div dsp[rs], rd */ 7334aea3d0cSYoshinori Sato static bool trans_DIV_mr(DisasContext *ctx, arg_DIV_mr *a) 7344aea3d0cSYoshinori Sato { 735e283adeaSRichard Henderson prt_ldmi(ctx, "div", a->ld, a->mi, a->rs, a->rd); 7364aea3d0cSYoshinori Sato return true; 7374aea3d0cSYoshinori Sato } 7384aea3d0cSYoshinori Sato 7394aea3d0cSYoshinori Sato /* divu #imm, rd */ 7404aea3d0cSYoshinori Sato static bool trans_DIVU_ir(DisasContext *ctx, arg_DIVU_ir *a) 7414aea3d0cSYoshinori Sato { 7424aea3d0cSYoshinori Sato prt_ir(ctx, "divu", a->imm, a->rd); 7434aea3d0cSYoshinori Sato return true; 7444aea3d0cSYoshinori Sato } 7454aea3d0cSYoshinori Sato 7464aea3d0cSYoshinori Sato /* divu rs, rd */ 7474aea3d0cSYoshinori Sato /* divu dsp[rs], rd */ 7484aea3d0cSYoshinori Sato static bool trans_DIVU_mr(DisasContext *ctx, arg_DIVU_mr *a) 7494aea3d0cSYoshinori Sato { 750e283adeaSRichard Henderson prt_ldmi(ctx, "divu", a->ld, a->mi, a->rs, a->rd); 7514aea3d0cSYoshinori Sato return true; 7524aea3d0cSYoshinori Sato } 7534aea3d0cSYoshinori Sato 7544aea3d0cSYoshinori Sato 7554aea3d0cSYoshinori Sato /* shll #imm:5, rd */ 7564aea3d0cSYoshinori Sato /* shll #imm:5, rs, rd */ 7574aea3d0cSYoshinori Sato static bool trans_SHLL_irr(DisasContext *ctx, arg_SHLL_irr *a) 7584aea3d0cSYoshinori Sato { 7594aea3d0cSYoshinori Sato if (a->rs2 != a->rd) { 76067eb12d8SRichard Henderson prt("shll\t#%d, r%d, r%d", a->imm, a->rs2, a->rd); 76167eb12d8SRichard Henderson } else { 76267eb12d8SRichard Henderson prt("shll\t#%d, r%d", a->imm, a->rd); 7634aea3d0cSYoshinori Sato } 7644aea3d0cSYoshinori Sato return true; 7654aea3d0cSYoshinori Sato } 7664aea3d0cSYoshinori Sato 7674aea3d0cSYoshinori Sato /* shll rs, rd */ 7684aea3d0cSYoshinori Sato static bool trans_SHLL_rr(DisasContext *ctx, arg_SHLL_rr *a) 7694aea3d0cSYoshinori Sato { 7704aea3d0cSYoshinori Sato prt("shll\tr%d, r%d", a->rs, a->rd); 7714aea3d0cSYoshinori Sato return true; 7724aea3d0cSYoshinori Sato } 7734aea3d0cSYoshinori Sato 7744aea3d0cSYoshinori Sato /* shar #imm:5, rd */ 7754aea3d0cSYoshinori Sato /* shar #imm:5, rs, rd */ 7764aea3d0cSYoshinori Sato static bool trans_SHAR_irr(DisasContext *ctx, arg_SHAR_irr *a) 7774aea3d0cSYoshinori Sato { 7784aea3d0cSYoshinori Sato if (a->rs2 != a->rd) { 77967eb12d8SRichard Henderson prt("shar\t#%d, r%d, r%d", a->imm, a->rs2, a->rd); 78067eb12d8SRichard Henderson } else { 78167eb12d8SRichard Henderson prt("shar\t#%d, r%d", a->imm, a->rd); 7824aea3d0cSYoshinori Sato } 7834aea3d0cSYoshinori Sato return true; 7844aea3d0cSYoshinori Sato } 7854aea3d0cSYoshinori Sato 7864aea3d0cSYoshinori Sato /* shar rs, rd */ 7874aea3d0cSYoshinori Sato static bool trans_SHAR_rr(DisasContext *ctx, arg_SHAR_rr *a) 7884aea3d0cSYoshinori Sato { 7894aea3d0cSYoshinori Sato prt("shar\tr%d, r%d", a->rs, a->rd); 7904aea3d0cSYoshinori Sato return true; 7914aea3d0cSYoshinori Sato } 7924aea3d0cSYoshinori Sato 7934aea3d0cSYoshinori Sato /* shlr #imm:5, rd */ 7944aea3d0cSYoshinori Sato /* shlr #imm:5, rs, rd */ 7954aea3d0cSYoshinori Sato static bool trans_SHLR_irr(DisasContext *ctx, arg_SHLR_irr *a) 7964aea3d0cSYoshinori Sato { 7974aea3d0cSYoshinori Sato if (a->rs2 != a->rd) { 79867eb12d8SRichard Henderson prt("shlr\t#%d, r%d, r%d", a->imm, a->rs2, a->rd); 79967eb12d8SRichard Henderson } else { 80067eb12d8SRichard Henderson prt("shlr\t#%d, r%d", a->imm, a->rd); 8014aea3d0cSYoshinori Sato } 8024aea3d0cSYoshinori Sato return true; 8034aea3d0cSYoshinori Sato } 8044aea3d0cSYoshinori Sato 8054aea3d0cSYoshinori Sato /* shlr rs, rd */ 8064aea3d0cSYoshinori Sato static bool trans_SHLR_rr(DisasContext *ctx, arg_SHLR_rr *a) 8074aea3d0cSYoshinori Sato { 8084aea3d0cSYoshinori Sato prt("shlr\tr%d, r%d", a->rs, a->rd); 8094aea3d0cSYoshinori Sato return true; 8104aea3d0cSYoshinori Sato } 8114aea3d0cSYoshinori Sato 8124aea3d0cSYoshinori Sato /* rolc rd */ 8134aea3d0cSYoshinori Sato static bool trans_ROLC(DisasContext *ctx, arg_ROLC *a) 8144aea3d0cSYoshinori Sato { 8154aea3d0cSYoshinori Sato prt("rorc\tr%d", a->rd); 8164aea3d0cSYoshinori Sato return true; 8174aea3d0cSYoshinori Sato } 8184aea3d0cSYoshinori Sato 8194aea3d0cSYoshinori Sato /* rorc rd */ 8204aea3d0cSYoshinori Sato static bool trans_RORC(DisasContext *ctx, arg_RORC *a) 8214aea3d0cSYoshinori Sato { 8224aea3d0cSYoshinori Sato prt("rorc\tr%d", a->rd); 8234aea3d0cSYoshinori Sato return true; 8244aea3d0cSYoshinori Sato } 8254aea3d0cSYoshinori Sato 8264aea3d0cSYoshinori Sato /* rotl #imm, rd */ 8274aea3d0cSYoshinori Sato static bool trans_ROTL_ir(DisasContext *ctx, arg_ROTL_ir *a) 8284aea3d0cSYoshinori Sato { 8294aea3d0cSYoshinori Sato prt("rotl\t#%d, r%d", a->imm, a->rd); 8304aea3d0cSYoshinori Sato return true; 8314aea3d0cSYoshinori Sato } 8324aea3d0cSYoshinori Sato 8334aea3d0cSYoshinori Sato /* rotl rs, rd */ 8344aea3d0cSYoshinori Sato static bool trans_ROTL_rr(DisasContext *ctx, arg_ROTL_rr *a) 8354aea3d0cSYoshinori Sato { 8364aea3d0cSYoshinori Sato prt("rotl\tr%d, r%d", a->rs, a->rd); 8374aea3d0cSYoshinori Sato return true; 8384aea3d0cSYoshinori Sato } 8394aea3d0cSYoshinori Sato 8404aea3d0cSYoshinori Sato /* rotr #imm, rd */ 8414aea3d0cSYoshinori Sato static bool trans_ROTR_ir(DisasContext *ctx, arg_ROTR_ir *a) 8424aea3d0cSYoshinori Sato { 8434aea3d0cSYoshinori Sato prt("rotr\t#%d, r%d", a->imm, a->rd); 8444aea3d0cSYoshinori Sato return true; 8454aea3d0cSYoshinori Sato } 8464aea3d0cSYoshinori Sato 8474aea3d0cSYoshinori Sato /* rotr rs, rd */ 8484aea3d0cSYoshinori Sato static bool trans_ROTR_rr(DisasContext *ctx, arg_ROTR_rr *a) 8494aea3d0cSYoshinori Sato { 8504aea3d0cSYoshinori Sato prt("rotr\tr%d, r%d", a->rs, a->rd); 8514aea3d0cSYoshinori Sato return true; 8524aea3d0cSYoshinori Sato } 8534aea3d0cSYoshinori Sato 8544aea3d0cSYoshinori Sato /* revl rs, rd */ 8554aea3d0cSYoshinori Sato static bool trans_REVL(DisasContext *ctx, arg_REVL *a) 8564aea3d0cSYoshinori Sato { 8574aea3d0cSYoshinori Sato prt("revl\tr%d, r%d", a->rs, a->rd); 8584aea3d0cSYoshinori Sato return true; 8594aea3d0cSYoshinori Sato } 8604aea3d0cSYoshinori Sato 8614aea3d0cSYoshinori Sato /* revw rs, rd */ 8624aea3d0cSYoshinori Sato static bool trans_REVW(DisasContext *ctx, arg_REVW *a) 8634aea3d0cSYoshinori Sato { 8644aea3d0cSYoshinori Sato prt("revw\tr%d, r%d", a->rs, a->rd); 8654aea3d0cSYoshinori Sato return true; 8664aea3d0cSYoshinori Sato } 8674aea3d0cSYoshinori Sato 8684aea3d0cSYoshinori Sato /* conditional branch helper */ 8694aea3d0cSYoshinori Sato static void rx_bcnd_main(DisasContext *ctx, int cd, int len, int dst) 8704aea3d0cSYoshinori Sato { 8714aea3d0cSYoshinori Sato static const char sz[] = {'s', 'b', 'w', 'a'}; 8724aea3d0cSYoshinori Sato prt("b%s.%c\t%08x", cond[cd], sz[len - 1], ctx->pc + dst); 8734aea3d0cSYoshinori Sato } 8744aea3d0cSYoshinori Sato 8754aea3d0cSYoshinori Sato /* beq dsp:3 / bne dsp:3 */ 8764aea3d0cSYoshinori Sato /* beq dsp:8 / bne dsp:8 */ 8774aea3d0cSYoshinori Sato /* bc dsp:8 / bnc dsp:8 */ 8784aea3d0cSYoshinori Sato /* bgtu dsp:8 / bleu dsp:8 */ 8794aea3d0cSYoshinori Sato /* bpz dsp:8 / bn dsp:8 */ 8804aea3d0cSYoshinori Sato /* bge dsp:8 / blt dsp:8 */ 8814aea3d0cSYoshinori Sato /* bgt dsp:8 / ble dsp:8 */ 8824aea3d0cSYoshinori Sato /* bo dsp:8 / bno dsp:8 */ 8834aea3d0cSYoshinori Sato /* beq dsp:16 / bne dsp:16 */ 8844aea3d0cSYoshinori Sato static bool trans_BCnd(DisasContext *ctx, arg_BCnd *a) 8854aea3d0cSYoshinori Sato { 8864aea3d0cSYoshinori Sato rx_bcnd_main(ctx, a->cd, a->sz, a->dsp); 8874aea3d0cSYoshinori Sato return true; 8884aea3d0cSYoshinori Sato } 8894aea3d0cSYoshinori Sato 8904aea3d0cSYoshinori Sato /* bra dsp:3 */ 8914aea3d0cSYoshinori Sato /* bra dsp:8 */ 8924aea3d0cSYoshinori Sato /* bra dsp:16 */ 8934aea3d0cSYoshinori Sato /* bra dsp:24 */ 8944aea3d0cSYoshinori Sato static bool trans_BRA(DisasContext *ctx, arg_BRA *a) 8954aea3d0cSYoshinori Sato { 8964aea3d0cSYoshinori Sato rx_bcnd_main(ctx, 14, a->sz, a->dsp); 8974aea3d0cSYoshinori Sato return true; 8984aea3d0cSYoshinori Sato } 8994aea3d0cSYoshinori Sato 9004aea3d0cSYoshinori Sato /* bra rs */ 9014aea3d0cSYoshinori Sato static bool trans_BRA_l(DisasContext *ctx, arg_BRA_l *a) 9024aea3d0cSYoshinori Sato { 9034aea3d0cSYoshinori Sato prt("bra.l\tr%d", a->rd); 9044aea3d0cSYoshinori Sato return true; 9054aea3d0cSYoshinori Sato } 9064aea3d0cSYoshinori Sato 9074aea3d0cSYoshinori Sato /* jmp rs */ 9084aea3d0cSYoshinori Sato static bool trans_JMP(DisasContext *ctx, arg_JMP *a) 9094aea3d0cSYoshinori Sato { 9104aea3d0cSYoshinori Sato prt("jmp\tr%d", a->rs); 9114aea3d0cSYoshinori Sato return true; 9124aea3d0cSYoshinori Sato } 9134aea3d0cSYoshinori Sato 9144aea3d0cSYoshinori Sato /* jsr rs */ 9154aea3d0cSYoshinori Sato static bool trans_JSR(DisasContext *ctx, arg_JSR *a) 9164aea3d0cSYoshinori Sato { 9174aea3d0cSYoshinori Sato prt("jsr\tr%d", a->rs); 9184aea3d0cSYoshinori Sato return true; 9194aea3d0cSYoshinori Sato } 9204aea3d0cSYoshinori Sato 9214aea3d0cSYoshinori Sato /* bsr dsp:16 */ 9224aea3d0cSYoshinori Sato /* bsr dsp:24 */ 9234aea3d0cSYoshinori Sato static bool trans_BSR(DisasContext *ctx, arg_BSR *a) 9244aea3d0cSYoshinori Sato { 9254aea3d0cSYoshinori Sato static const char sz[] = {'w', 'a'}; 9264aea3d0cSYoshinori Sato prt("bsr.%c\t%08x", sz[a->sz - 3], ctx->pc + a->dsp); 9274aea3d0cSYoshinori Sato return true; 9284aea3d0cSYoshinori Sato } 9294aea3d0cSYoshinori Sato 9304aea3d0cSYoshinori Sato /* bsr rs */ 9314aea3d0cSYoshinori Sato static bool trans_BSR_l(DisasContext *ctx, arg_BSR_l *a) 9324aea3d0cSYoshinori Sato { 9334aea3d0cSYoshinori Sato prt("bsr.l\tr%d", a->rd); 9344aea3d0cSYoshinori Sato return true; 9354aea3d0cSYoshinori Sato } 9364aea3d0cSYoshinori Sato 9374aea3d0cSYoshinori Sato /* rts */ 9384aea3d0cSYoshinori Sato static bool trans_RTS(DisasContext *ctx, arg_RTS *a) 9394aea3d0cSYoshinori Sato { 9404aea3d0cSYoshinori Sato prt("rts"); 9414aea3d0cSYoshinori Sato return true; 9424aea3d0cSYoshinori Sato } 9434aea3d0cSYoshinori Sato 9444aea3d0cSYoshinori Sato /* nop */ 9454aea3d0cSYoshinori Sato static bool trans_NOP(DisasContext *ctx, arg_NOP *a) 9464aea3d0cSYoshinori Sato { 9474aea3d0cSYoshinori Sato prt("nop"); 9484aea3d0cSYoshinori Sato return true; 9494aea3d0cSYoshinori Sato } 9504aea3d0cSYoshinori Sato 9514aea3d0cSYoshinori Sato /* scmpu */ 9524aea3d0cSYoshinori Sato static bool trans_SCMPU(DisasContext *ctx, arg_SCMPU *a) 9534aea3d0cSYoshinori Sato { 9544aea3d0cSYoshinori Sato prt("scmpu"); 9554aea3d0cSYoshinori Sato return true; 9564aea3d0cSYoshinori Sato } 9574aea3d0cSYoshinori Sato 9584aea3d0cSYoshinori Sato /* smovu */ 9594aea3d0cSYoshinori Sato static bool trans_SMOVU(DisasContext *ctx, arg_SMOVU *a) 9604aea3d0cSYoshinori Sato { 9614aea3d0cSYoshinori Sato prt("smovu"); 9624aea3d0cSYoshinori Sato return true; 9634aea3d0cSYoshinori Sato } 9644aea3d0cSYoshinori Sato 9654aea3d0cSYoshinori Sato /* smovf */ 9664aea3d0cSYoshinori Sato static bool trans_SMOVF(DisasContext *ctx, arg_SMOVF *a) 9674aea3d0cSYoshinori Sato { 9684aea3d0cSYoshinori Sato prt("smovf"); 9694aea3d0cSYoshinori Sato return true; 9704aea3d0cSYoshinori Sato } 9714aea3d0cSYoshinori Sato 9724aea3d0cSYoshinori Sato /* smovb */ 9734aea3d0cSYoshinori Sato static bool trans_SMOVB(DisasContext *ctx, arg_SMOVB *a) 9744aea3d0cSYoshinori Sato { 9754aea3d0cSYoshinori Sato prt("smovb"); 9764aea3d0cSYoshinori Sato return true; 9774aea3d0cSYoshinori Sato } 9784aea3d0cSYoshinori Sato 9794aea3d0cSYoshinori Sato /* suntile */ 9804aea3d0cSYoshinori Sato static bool trans_SUNTIL(DisasContext *ctx, arg_SUNTIL *a) 9814aea3d0cSYoshinori Sato { 9824aea3d0cSYoshinori Sato prt("suntil.%c", size[a->sz]); 9834aea3d0cSYoshinori Sato return true; 9844aea3d0cSYoshinori Sato } 9854aea3d0cSYoshinori Sato 9864aea3d0cSYoshinori Sato /* swhile */ 9874aea3d0cSYoshinori Sato static bool trans_SWHILE(DisasContext *ctx, arg_SWHILE *a) 9884aea3d0cSYoshinori Sato { 9894aea3d0cSYoshinori Sato prt("swhile.%c", size[a->sz]); 9904aea3d0cSYoshinori Sato return true; 9914aea3d0cSYoshinori Sato } 9924aea3d0cSYoshinori Sato /* sstr */ 9934aea3d0cSYoshinori Sato static bool trans_SSTR(DisasContext *ctx, arg_SSTR *a) 9944aea3d0cSYoshinori Sato { 9954aea3d0cSYoshinori Sato prt("sstr.%c", size[a->sz]); 9964aea3d0cSYoshinori Sato return true; 9974aea3d0cSYoshinori Sato } 9984aea3d0cSYoshinori Sato 9994aea3d0cSYoshinori Sato /* rmpa */ 10004aea3d0cSYoshinori Sato static bool trans_RMPA(DisasContext *ctx, arg_RMPA *a) 10014aea3d0cSYoshinori Sato { 10024aea3d0cSYoshinori Sato prt("rmpa.%c", size[a->sz]); 10034aea3d0cSYoshinori Sato return true; 10044aea3d0cSYoshinori Sato } 10054aea3d0cSYoshinori Sato 10064aea3d0cSYoshinori Sato /* mulhi rs,rs2 */ 10074aea3d0cSYoshinori Sato static bool trans_MULHI(DisasContext *ctx, arg_MULHI *a) 10084aea3d0cSYoshinori Sato { 10094aea3d0cSYoshinori Sato prt("mulhi\tr%d,r%d", a->rs, a->rs2); 10104aea3d0cSYoshinori Sato return true; 10114aea3d0cSYoshinori Sato } 10124aea3d0cSYoshinori Sato 10134aea3d0cSYoshinori Sato /* mullo rs,rs2 */ 10144aea3d0cSYoshinori Sato static bool trans_MULLO(DisasContext *ctx, arg_MULLO *a) 10154aea3d0cSYoshinori Sato { 10164aea3d0cSYoshinori Sato prt("mullo\tr%d, r%d", a->rs, a->rs2); 10174aea3d0cSYoshinori Sato return true; 10184aea3d0cSYoshinori Sato } 10194aea3d0cSYoshinori Sato 10204aea3d0cSYoshinori Sato /* machi rs,rs2 */ 10214aea3d0cSYoshinori Sato static bool trans_MACHI(DisasContext *ctx, arg_MACHI *a) 10224aea3d0cSYoshinori Sato { 10234aea3d0cSYoshinori Sato prt("machi\tr%d, r%d", a->rs, a->rs2); 10244aea3d0cSYoshinori Sato return true; 10254aea3d0cSYoshinori Sato } 10264aea3d0cSYoshinori Sato 10274aea3d0cSYoshinori Sato /* maclo rs,rs2 */ 10284aea3d0cSYoshinori Sato static bool trans_MACLO(DisasContext *ctx, arg_MACLO *a) 10294aea3d0cSYoshinori Sato { 10304aea3d0cSYoshinori Sato prt("maclo\tr%d, r%d", a->rs, a->rs2); 10314aea3d0cSYoshinori Sato return true; 10324aea3d0cSYoshinori Sato } 10334aea3d0cSYoshinori Sato 10344aea3d0cSYoshinori Sato /* mvfachi rd */ 10354aea3d0cSYoshinori Sato static bool trans_MVFACHI(DisasContext *ctx, arg_MVFACHI *a) 10364aea3d0cSYoshinori Sato { 10374aea3d0cSYoshinori Sato prt("mvfachi\tr%d", a->rd); 10384aea3d0cSYoshinori Sato return true; 10394aea3d0cSYoshinori Sato } 10404aea3d0cSYoshinori Sato 10414aea3d0cSYoshinori Sato /* mvfacmi rd */ 10424aea3d0cSYoshinori Sato static bool trans_MVFACMI(DisasContext *ctx, arg_MVFACMI *a) 10434aea3d0cSYoshinori Sato { 10444aea3d0cSYoshinori Sato prt("mvfacmi\tr%d", a->rd); 10454aea3d0cSYoshinori Sato return true; 10464aea3d0cSYoshinori Sato } 10474aea3d0cSYoshinori Sato 10484aea3d0cSYoshinori Sato /* mvtachi rs */ 10494aea3d0cSYoshinori Sato static bool trans_MVTACHI(DisasContext *ctx, arg_MVTACHI *a) 10504aea3d0cSYoshinori Sato { 10514aea3d0cSYoshinori Sato prt("mvtachi\tr%d", a->rs); 10524aea3d0cSYoshinori Sato return true; 10534aea3d0cSYoshinori Sato } 10544aea3d0cSYoshinori Sato 10554aea3d0cSYoshinori Sato /* mvtaclo rs */ 10564aea3d0cSYoshinori Sato static bool trans_MVTACLO(DisasContext *ctx, arg_MVTACLO *a) 10574aea3d0cSYoshinori Sato { 10584aea3d0cSYoshinori Sato prt("mvtaclo\tr%d", a->rs); 10594aea3d0cSYoshinori Sato return true; 10604aea3d0cSYoshinori Sato } 10614aea3d0cSYoshinori Sato 10624aea3d0cSYoshinori Sato /* racw #imm */ 10634aea3d0cSYoshinori Sato static bool trans_RACW(DisasContext *ctx, arg_RACW *a) 10644aea3d0cSYoshinori Sato { 10654aea3d0cSYoshinori Sato prt("racw\t#%d", a->imm + 1); 10664aea3d0cSYoshinori Sato return true; 10674aea3d0cSYoshinori Sato } 10684aea3d0cSYoshinori Sato 10694aea3d0cSYoshinori Sato /* sat rd */ 10704aea3d0cSYoshinori Sato static bool trans_SAT(DisasContext *ctx, arg_SAT *a) 10714aea3d0cSYoshinori Sato { 10724aea3d0cSYoshinori Sato prt("sat\tr%d", a->rd); 10734aea3d0cSYoshinori Sato return true; 10744aea3d0cSYoshinori Sato } 10754aea3d0cSYoshinori Sato 10764aea3d0cSYoshinori Sato /* satr */ 10774aea3d0cSYoshinori Sato static bool trans_SATR(DisasContext *ctx, arg_SATR *a) 10784aea3d0cSYoshinori Sato { 10794aea3d0cSYoshinori Sato prt("satr"); 10804aea3d0cSYoshinori Sato return true; 10814aea3d0cSYoshinori Sato } 10824aea3d0cSYoshinori Sato 10834aea3d0cSYoshinori Sato /* fadd #imm, rd */ 10844aea3d0cSYoshinori Sato static bool trans_FADD_ir(DisasContext *ctx, arg_FADD_ir *a) 10854aea3d0cSYoshinori Sato { 10864aea3d0cSYoshinori Sato prt("fadd\t#%d,r%d", li(ctx, 0), a->rd); 10874aea3d0cSYoshinori Sato return true; 10884aea3d0cSYoshinori Sato } 10894aea3d0cSYoshinori Sato 10904aea3d0cSYoshinori Sato /* fadd dsp[rs], rd */ 10914aea3d0cSYoshinori Sato /* fadd rs, rd */ 10924aea3d0cSYoshinori Sato static bool trans_FADD_mr(DisasContext *ctx, arg_FADD_mr *a) 10934aea3d0cSYoshinori Sato { 1094e283adeaSRichard Henderson prt_ldmi(ctx, "fadd", a->ld, RX_IM_LONG, a->rs, a->rd); 10954aea3d0cSYoshinori Sato return true; 10964aea3d0cSYoshinori Sato } 10974aea3d0cSYoshinori Sato 10984aea3d0cSYoshinori Sato /* fcmp #imm, rd */ 10994aea3d0cSYoshinori Sato static bool trans_FCMP_ir(DisasContext *ctx, arg_FCMP_ir *a) 11004aea3d0cSYoshinori Sato { 11014aea3d0cSYoshinori Sato prt("fadd\t#%d,r%d", li(ctx, 0), a->rd); 11024aea3d0cSYoshinori Sato return true; 11034aea3d0cSYoshinori Sato } 11044aea3d0cSYoshinori Sato 11054aea3d0cSYoshinori Sato /* fcmp dsp[rs], rd */ 11064aea3d0cSYoshinori Sato /* fcmp rs, rd */ 11074aea3d0cSYoshinori Sato static bool trans_FCMP_mr(DisasContext *ctx, arg_FCMP_mr *a) 11084aea3d0cSYoshinori Sato { 1109e283adeaSRichard Henderson prt_ldmi(ctx, "fcmp", a->ld, RX_IM_LONG, a->rs, a->rd); 11104aea3d0cSYoshinori Sato return true; 11114aea3d0cSYoshinori Sato } 11124aea3d0cSYoshinori Sato 11134aea3d0cSYoshinori Sato /* fsub #imm, rd */ 11144aea3d0cSYoshinori Sato static bool trans_FSUB_ir(DisasContext *ctx, arg_FSUB_ir *a) 11154aea3d0cSYoshinori Sato { 11164aea3d0cSYoshinori Sato prt("fsub\t#%d,r%d", li(ctx, 0), a->rd); 11174aea3d0cSYoshinori Sato return true; 11184aea3d0cSYoshinori Sato } 11194aea3d0cSYoshinori Sato 11204aea3d0cSYoshinori Sato /* fsub dsp[rs], rd */ 11214aea3d0cSYoshinori Sato /* fsub rs, rd */ 11224aea3d0cSYoshinori Sato static bool trans_FSUB_mr(DisasContext *ctx, arg_FSUB_mr *a) 11234aea3d0cSYoshinori Sato { 1124e283adeaSRichard Henderson prt_ldmi(ctx, "fsub", a->ld, RX_IM_LONG, a->rs, a->rd); 11254aea3d0cSYoshinori Sato return true; 11264aea3d0cSYoshinori Sato } 11274aea3d0cSYoshinori Sato 11284aea3d0cSYoshinori Sato /* ftoi dsp[rs], rd */ 11294aea3d0cSYoshinori Sato /* ftoi rs, rd */ 11304aea3d0cSYoshinori Sato static bool trans_FTOI(DisasContext *ctx, arg_FTOI *a) 11314aea3d0cSYoshinori Sato { 1132e283adeaSRichard Henderson prt_ldmi(ctx, "ftoi", a->ld, RX_IM_LONG, a->rs, a->rd); 11334aea3d0cSYoshinori Sato return true; 11344aea3d0cSYoshinori Sato } 11354aea3d0cSYoshinori Sato 11364aea3d0cSYoshinori Sato /* fmul #imm, rd */ 11374aea3d0cSYoshinori Sato static bool trans_FMUL_ir(DisasContext *ctx, arg_FMUL_ir *a) 11384aea3d0cSYoshinori Sato { 11394aea3d0cSYoshinori Sato prt("fmul\t#%d,r%d", li(ctx, 0), a->rd); 11404aea3d0cSYoshinori Sato return true; 11414aea3d0cSYoshinori Sato } 11424aea3d0cSYoshinori Sato 11434aea3d0cSYoshinori Sato /* fmul dsp[rs], rd */ 11444aea3d0cSYoshinori Sato /* fmul rs, rd */ 11454aea3d0cSYoshinori Sato static bool trans_FMUL_mr(DisasContext *ctx, arg_FMUL_mr *a) 11464aea3d0cSYoshinori Sato { 1147e283adeaSRichard Henderson prt_ldmi(ctx, "fmul", a->ld, RX_IM_LONG, a->rs, a->rd); 11484aea3d0cSYoshinori Sato return true; 11494aea3d0cSYoshinori Sato } 11504aea3d0cSYoshinori Sato 11514aea3d0cSYoshinori Sato /* fdiv #imm, rd */ 11524aea3d0cSYoshinori Sato static bool trans_FDIV_ir(DisasContext *ctx, arg_FDIV_ir *a) 11534aea3d0cSYoshinori Sato { 11544aea3d0cSYoshinori Sato prt("fdiv\t#%d,r%d", li(ctx, 0), a->rd); 11554aea3d0cSYoshinori Sato return true; 11564aea3d0cSYoshinori Sato } 11574aea3d0cSYoshinori Sato 11584aea3d0cSYoshinori Sato /* fdiv dsp[rs], rd */ 11594aea3d0cSYoshinori Sato /* fdiv rs, rd */ 11604aea3d0cSYoshinori Sato static bool trans_FDIV_mr(DisasContext *ctx, arg_FDIV_mr *a) 11614aea3d0cSYoshinori Sato { 1162e283adeaSRichard Henderson prt_ldmi(ctx, "fdiv", a->ld, RX_IM_LONG, a->rs, a->rd); 11634aea3d0cSYoshinori Sato return true; 11644aea3d0cSYoshinori Sato } 11654aea3d0cSYoshinori Sato 11664aea3d0cSYoshinori Sato /* round dsp[rs], rd */ 11674aea3d0cSYoshinori Sato /* round rs, rd */ 11684aea3d0cSYoshinori Sato static bool trans_ROUND(DisasContext *ctx, arg_ROUND *a) 11694aea3d0cSYoshinori Sato { 1170e283adeaSRichard Henderson prt_ldmi(ctx, "round", a->ld, RX_IM_LONG, a->rs, a->rd); 11714aea3d0cSYoshinori Sato return true; 11724aea3d0cSYoshinori Sato } 11734aea3d0cSYoshinori Sato 11744aea3d0cSYoshinori Sato /* itof rs, rd */ 11754aea3d0cSYoshinori Sato /* itof dsp[rs], rd */ 11764aea3d0cSYoshinori Sato static bool trans_ITOF(DisasContext *ctx, arg_ITOF *a) 11774aea3d0cSYoshinori Sato { 1178e283adeaSRichard Henderson prt_ldmi(ctx, "itof", a->ld, RX_IM_LONG, a->rs, a->rd); 11794aea3d0cSYoshinori Sato return true; 11804aea3d0cSYoshinori Sato } 11814aea3d0cSYoshinori Sato 11824aea3d0cSYoshinori Sato #define BOP_IM(name, reg) \ 11834aea3d0cSYoshinori Sato do { \ 1184fa6289e2SRichard Henderson char dsp[8]; \ 1185fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE); \ 1186fa6289e2SRichard Henderson prt("b%s\t#%d, %s[r%d]", #name, a->imm, dsp, reg); \ 11874aea3d0cSYoshinori Sato return true; \ 11884aea3d0cSYoshinori Sato } while (0) 11894aea3d0cSYoshinori Sato 11904aea3d0cSYoshinori Sato #define BOP_RM(name) \ 11914aea3d0cSYoshinori Sato do { \ 1192fa6289e2SRichard Henderson char dsp[8]; \ 1193fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE); \ 1194fa6289e2SRichard Henderson prt("b%s\tr%d, %s[r%d]", #name, a->rd, dsp, a->rs); \ 11954aea3d0cSYoshinori Sato return true; \ 11964aea3d0cSYoshinori Sato } while (0) 11974aea3d0cSYoshinori Sato 11984aea3d0cSYoshinori Sato /* bset #imm, dsp[rd] */ 11994aea3d0cSYoshinori Sato static bool trans_BSET_im(DisasContext *ctx, arg_BSET_im *a) 12004aea3d0cSYoshinori Sato { 12014aea3d0cSYoshinori Sato BOP_IM(bset, a->rs); 12024aea3d0cSYoshinori Sato } 12034aea3d0cSYoshinori Sato 12044aea3d0cSYoshinori Sato /* bset rs, dsp[rd] */ 12054aea3d0cSYoshinori Sato static bool trans_BSET_rm(DisasContext *ctx, arg_BSET_rm *a) 12064aea3d0cSYoshinori Sato { 12074aea3d0cSYoshinori Sato BOP_RM(set); 12084aea3d0cSYoshinori Sato } 12094aea3d0cSYoshinori Sato 12104aea3d0cSYoshinori Sato /* bset rs, rd */ 12114aea3d0cSYoshinori Sato static bool trans_BSET_rr(DisasContext *ctx, arg_BSET_rr *a) 12124aea3d0cSYoshinori Sato { 12134aea3d0cSYoshinori Sato prt("bset\tr%d,r%d", a->rs, a->rd); 12144aea3d0cSYoshinori Sato return true; 12154aea3d0cSYoshinori Sato } 12164aea3d0cSYoshinori Sato 12174aea3d0cSYoshinori Sato /* bset #imm, rd */ 12184aea3d0cSYoshinori Sato static bool trans_BSET_ir(DisasContext *ctx, arg_BSET_ir *a) 12194aea3d0cSYoshinori Sato { 12204aea3d0cSYoshinori Sato prt("bset\t#%d, r%d", a->imm, a->rd); 12214aea3d0cSYoshinori Sato return true; 12224aea3d0cSYoshinori Sato } 12234aea3d0cSYoshinori Sato 12244aea3d0cSYoshinori Sato /* bclr #imm, dsp[rd] */ 12254aea3d0cSYoshinori Sato static bool trans_BCLR_im(DisasContext *ctx, arg_BCLR_im *a) 12264aea3d0cSYoshinori Sato { 12274aea3d0cSYoshinori Sato BOP_IM(clr, a->rs); 12284aea3d0cSYoshinori Sato } 12294aea3d0cSYoshinori Sato 12304aea3d0cSYoshinori Sato /* bclr rs, dsp[rd] */ 12314aea3d0cSYoshinori Sato static bool trans_BCLR_rm(DisasContext *ctx, arg_BCLR_rm *a) 12324aea3d0cSYoshinori Sato { 12334aea3d0cSYoshinori Sato BOP_RM(clr); 12344aea3d0cSYoshinori Sato } 12354aea3d0cSYoshinori Sato 12364aea3d0cSYoshinori Sato /* bclr rs, rd */ 12374aea3d0cSYoshinori Sato static bool trans_BCLR_rr(DisasContext *ctx, arg_BCLR_rr *a) 12384aea3d0cSYoshinori Sato { 12394aea3d0cSYoshinori Sato prt("bclr\tr%d, r%d", a->rs, a->rd); 12404aea3d0cSYoshinori Sato return true; 12414aea3d0cSYoshinori Sato } 12424aea3d0cSYoshinori Sato 12434aea3d0cSYoshinori Sato /* bclr #imm, rd */ 12444aea3d0cSYoshinori Sato static bool trans_BCLR_ir(DisasContext *ctx, arg_BCLR_ir *a) 12454aea3d0cSYoshinori Sato { 12464aea3d0cSYoshinori Sato prt("bclr\t#%d,r%d", a->imm, a->rd); 12474aea3d0cSYoshinori Sato return true; 12484aea3d0cSYoshinori Sato } 12494aea3d0cSYoshinori Sato 12504aea3d0cSYoshinori Sato /* btst #imm, dsp[rd] */ 12514aea3d0cSYoshinori Sato static bool trans_BTST_im(DisasContext *ctx, arg_BTST_im *a) 12524aea3d0cSYoshinori Sato { 12534aea3d0cSYoshinori Sato BOP_IM(tst, a->rs); 12544aea3d0cSYoshinori Sato } 12554aea3d0cSYoshinori Sato 12564aea3d0cSYoshinori Sato /* btst rs, dsp[rd] */ 12574aea3d0cSYoshinori Sato static bool trans_BTST_rm(DisasContext *ctx, arg_BTST_rm *a) 12584aea3d0cSYoshinori Sato { 12594aea3d0cSYoshinori Sato BOP_RM(tst); 12604aea3d0cSYoshinori Sato } 12614aea3d0cSYoshinori Sato 12624aea3d0cSYoshinori Sato /* btst rs, rd */ 12634aea3d0cSYoshinori Sato static bool trans_BTST_rr(DisasContext *ctx, arg_BTST_rr *a) 12644aea3d0cSYoshinori Sato { 12654aea3d0cSYoshinori Sato prt("btst\tr%d, r%d", a->rs, a->rd); 12664aea3d0cSYoshinori Sato return true; 12674aea3d0cSYoshinori Sato } 12684aea3d0cSYoshinori Sato 12694aea3d0cSYoshinori Sato /* btst #imm, rd */ 12704aea3d0cSYoshinori Sato static bool trans_BTST_ir(DisasContext *ctx, arg_BTST_ir *a) 12714aea3d0cSYoshinori Sato { 12724aea3d0cSYoshinori Sato prt("btst\t#%d, r%d", a->imm, a->rd); 12734aea3d0cSYoshinori Sato return true; 12744aea3d0cSYoshinori Sato } 12754aea3d0cSYoshinori Sato 12764aea3d0cSYoshinori Sato /* bnot rs, dsp[rd] */ 12774aea3d0cSYoshinori Sato static bool trans_BNOT_rm(DisasContext *ctx, arg_BNOT_rm *a) 12784aea3d0cSYoshinori Sato { 12794aea3d0cSYoshinori Sato BOP_RM(not); 12804aea3d0cSYoshinori Sato } 12814aea3d0cSYoshinori Sato 12824aea3d0cSYoshinori Sato /* bnot rs, rd */ 12834aea3d0cSYoshinori Sato static bool trans_BNOT_rr(DisasContext *ctx, arg_BNOT_rr *a) 12844aea3d0cSYoshinori Sato { 12854aea3d0cSYoshinori Sato prt("bnot\tr%d, r%d", a->rs, a->rd); 12864aea3d0cSYoshinori Sato return true; 12874aea3d0cSYoshinori Sato } 12884aea3d0cSYoshinori Sato 12894aea3d0cSYoshinori Sato /* bnot #imm, dsp[rd] */ 12904aea3d0cSYoshinori Sato static bool trans_BNOT_im(DisasContext *ctx, arg_BNOT_im *a) 12914aea3d0cSYoshinori Sato { 12924aea3d0cSYoshinori Sato BOP_IM(not, a->rs); 12934aea3d0cSYoshinori Sato } 12944aea3d0cSYoshinori Sato 12954aea3d0cSYoshinori Sato /* bnot #imm, rd */ 12964aea3d0cSYoshinori Sato static bool trans_BNOT_ir(DisasContext *ctx, arg_BNOT_ir *a) 12974aea3d0cSYoshinori Sato { 12984aea3d0cSYoshinori Sato prt("bnot\t#%d, r%d", a->imm, a->rd); 12994aea3d0cSYoshinori Sato return true; 13004aea3d0cSYoshinori Sato } 13014aea3d0cSYoshinori Sato 13024aea3d0cSYoshinori Sato /* bmcond #imm, dsp[rd] */ 13034aea3d0cSYoshinori Sato static bool trans_BMCnd_im(DisasContext *ctx, arg_BMCnd_im *a) 13044aea3d0cSYoshinori Sato { 1305fa6289e2SRichard Henderson char dsp[8]; 1306fa6289e2SRichard Henderson 1307fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE); 1308fa6289e2SRichard Henderson prt("bm%s\t#%d, %s[r%d]", cond[a->cd], a->imm, dsp, a->rd); 13094aea3d0cSYoshinori Sato return true; 13104aea3d0cSYoshinori Sato } 13114aea3d0cSYoshinori Sato 13124aea3d0cSYoshinori Sato /* bmcond #imm, rd */ 13134aea3d0cSYoshinori Sato static bool trans_BMCnd_ir(DisasContext *ctx, arg_BMCnd_ir *a) 13144aea3d0cSYoshinori Sato { 13154aea3d0cSYoshinori Sato prt("bm%s\t#%d, r%d", cond[a->cd], a->imm, a->rd); 13164aea3d0cSYoshinori Sato return true; 13174aea3d0cSYoshinori Sato } 13184aea3d0cSYoshinori Sato 13194aea3d0cSYoshinori Sato /* clrpsw psw */ 13204aea3d0cSYoshinori Sato static bool trans_CLRPSW(DisasContext *ctx, arg_CLRPSW *a) 13214aea3d0cSYoshinori Sato { 13224aea3d0cSYoshinori Sato prt("clrpsw\t%c", psw[a->cb]); 13234aea3d0cSYoshinori Sato return true; 13244aea3d0cSYoshinori Sato } 13254aea3d0cSYoshinori Sato 13264aea3d0cSYoshinori Sato /* setpsw psw */ 13274aea3d0cSYoshinori Sato static bool trans_SETPSW(DisasContext *ctx, arg_SETPSW *a) 13284aea3d0cSYoshinori Sato { 13294aea3d0cSYoshinori Sato prt("setpsw\t%c", psw[a->cb]); 13304aea3d0cSYoshinori Sato return true; 13314aea3d0cSYoshinori Sato } 13324aea3d0cSYoshinori Sato 13334aea3d0cSYoshinori Sato /* mvtipl #imm */ 13344aea3d0cSYoshinori Sato static bool trans_MVTIPL(DisasContext *ctx, arg_MVTIPL *a) 13354aea3d0cSYoshinori Sato { 13364aea3d0cSYoshinori Sato prt("movtipl\t#%d", a->imm); 13374aea3d0cSYoshinori Sato return true; 13384aea3d0cSYoshinori Sato } 13394aea3d0cSYoshinori Sato 13404aea3d0cSYoshinori Sato /* mvtc #imm, rd */ 13414aea3d0cSYoshinori Sato static bool trans_MVTC_i(DisasContext *ctx, arg_MVTC_i *a) 13424aea3d0cSYoshinori Sato { 13434aea3d0cSYoshinori Sato prt("mvtc\t#0x%08x, %s", a->imm, rx_crname(a->cr)); 13444aea3d0cSYoshinori Sato return true; 13454aea3d0cSYoshinori Sato } 13464aea3d0cSYoshinori Sato 13474aea3d0cSYoshinori Sato /* mvtc rs, rd */ 13484aea3d0cSYoshinori Sato static bool trans_MVTC_r(DisasContext *ctx, arg_MVTC_r *a) 13494aea3d0cSYoshinori Sato { 13504aea3d0cSYoshinori Sato prt("mvtc\tr%d, %s", a->rs, rx_crname(a->cr)); 13514aea3d0cSYoshinori Sato return true; 13524aea3d0cSYoshinori Sato } 13534aea3d0cSYoshinori Sato 13544aea3d0cSYoshinori Sato /* mvfc rs, rd */ 13554aea3d0cSYoshinori Sato static bool trans_MVFC(DisasContext *ctx, arg_MVFC *a) 13564aea3d0cSYoshinori Sato { 13574aea3d0cSYoshinori Sato prt("mvfc\t%s, r%d", rx_crname(a->cr), a->rd); 13584aea3d0cSYoshinori Sato return true; 13594aea3d0cSYoshinori Sato } 13604aea3d0cSYoshinori Sato 13614aea3d0cSYoshinori Sato /* rtfi */ 13624aea3d0cSYoshinori Sato static bool trans_RTFI(DisasContext *ctx, arg_RTFI *a) 13634aea3d0cSYoshinori Sato { 13644aea3d0cSYoshinori Sato prt("rtfi"); 13654aea3d0cSYoshinori Sato return true; 13664aea3d0cSYoshinori Sato } 13674aea3d0cSYoshinori Sato 13684aea3d0cSYoshinori Sato /* rte */ 13694aea3d0cSYoshinori Sato static bool trans_RTE(DisasContext *ctx, arg_RTE *a) 13704aea3d0cSYoshinori Sato { 13714aea3d0cSYoshinori Sato prt("rte"); 13724aea3d0cSYoshinori Sato return true; 13734aea3d0cSYoshinori Sato } 13744aea3d0cSYoshinori Sato 13754aea3d0cSYoshinori Sato /* brk */ 13764aea3d0cSYoshinori Sato static bool trans_BRK(DisasContext *ctx, arg_BRK *a) 13774aea3d0cSYoshinori Sato { 13784aea3d0cSYoshinori Sato prt("brk"); 13794aea3d0cSYoshinori Sato return true; 13804aea3d0cSYoshinori Sato } 13814aea3d0cSYoshinori Sato 13824aea3d0cSYoshinori Sato /* int #imm */ 13834aea3d0cSYoshinori Sato static bool trans_INT(DisasContext *ctx, arg_INT *a) 13844aea3d0cSYoshinori Sato { 13854aea3d0cSYoshinori Sato prt("int\t#%d", a->imm); 13864aea3d0cSYoshinori Sato return true; 13874aea3d0cSYoshinori Sato } 13884aea3d0cSYoshinori Sato 13894aea3d0cSYoshinori Sato /* wait */ 13904aea3d0cSYoshinori Sato static bool trans_WAIT(DisasContext *ctx, arg_WAIT *a) 13914aea3d0cSYoshinori Sato { 13924aea3d0cSYoshinori Sato prt("wait"); 13934aea3d0cSYoshinori Sato return true; 13944aea3d0cSYoshinori Sato } 13954aea3d0cSYoshinori Sato 13964aea3d0cSYoshinori Sato /* sccnd.[bwl] rd */ 13974aea3d0cSYoshinori Sato /* sccnd.[bwl] dsp:[rd] */ 13984aea3d0cSYoshinori Sato static bool trans_SCCnd(DisasContext *ctx, arg_SCCnd *a) 13994aea3d0cSYoshinori Sato { 14004aea3d0cSYoshinori Sato if (a->ld < 3) { 1401fa6289e2SRichard Henderson char dsp[8]; 1402fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->sz, a->ld); 1403fa6289e2SRichard Henderson prt("sc%s.%c\t%s[r%d]", cond[a->cd], size[a->sz], dsp, a->rd); 14044aea3d0cSYoshinori Sato } else { 1405fa6289e2SRichard Henderson prt("sc%s.%c\tr%d", cond[a->cd], size[a->sz], a->rd); 14064aea3d0cSYoshinori Sato } 14074aea3d0cSYoshinori Sato return true; 14084aea3d0cSYoshinori Sato } 14094aea3d0cSYoshinori Sato 14104aea3d0cSYoshinori Sato int print_insn_rx(bfd_vma addr, disassemble_info *dis) 14114aea3d0cSYoshinori Sato { 14124aea3d0cSYoshinori Sato DisasContext ctx; 14134aea3d0cSYoshinori Sato uint32_t insn; 14144aea3d0cSYoshinori Sato int i; 1415*05a8599fSRichard Henderson 14164aea3d0cSYoshinori Sato ctx.dis = dis; 14174aea3d0cSYoshinori Sato ctx.pc = ctx.addr = addr; 1418*05a8599fSRichard Henderson ctx.len = 0; 14194aea3d0cSYoshinori Sato 14204aea3d0cSYoshinori Sato insn = decode_load(&ctx); 14214aea3d0cSYoshinori Sato if (!decode(&ctx, insn)) { 14224aea3d0cSYoshinori Sato ctx.dis->fprintf_func(ctx.dis->stream, ".byte\t"); 14234aea3d0cSYoshinori Sato for (i = 0; i < ctx.addr - addr; i++) { 14244aea3d0cSYoshinori Sato if (i > 0) { 14254aea3d0cSYoshinori Sato ctx.dis->fprintf_func(ctx.dis->stream, ","); 14264aea3d0cSYoshinori Sato } 14274aea3d0cSYoshinori Sato ctx.dis->fprintf_func(ctx.dis->stream, "0x%02x", insn >> 24); 14284aea3d0cSYoshinori Sato insn <<= 8; 14294aea3d0cSYoshinori Sato } 14304aea3d0cSYoshinori Sato } 14314aea3d0cSYoshinori Sato return ctx.addr - addr; 14324aea3d0cSYoshinori Sato } 1433