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; 2805a8599fSRichard Henderson uint8_t len; 2905a8599fSRichard 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 { 3605a8599fSRichard Henderson uint32_t addr = ctx->addr; 3705a8599fSRichard Henderson 3805a8599fSRichard Henderson g_assert(ctx->len == i); 3905a8599fSRichard Henderson g_assert(n <= ARRAY_SIZE(ctx->bytes)); 4005a8599fSRichard Henderson 414aea3d0cSYoshinori Sato while (++i <= n) { 4205a8599fSRichard Henderson ctx->dis->read_memory_func(addr++, &ctx->bytes[i - 1], 1, ctx->dis); 4305a8599fSRichard Henderson insn |= ctx->bytes[i - 1] << (32 - i * 8); 444aea3d0cSYoshinori Sato } 4505a8599fSRichard Henderson ctx->addr = addr; 4605a8599fSRichard Henderson ctx->len = n; 4705a8599fSRichard Henderson 484aea3d0cSYoshinori Sato return insn; 494aea3d0cSYoshinori Sato } 504aea3d0cSYoshinori Sato 514aea3d0cSYoshinori Sato static int32_t li(DisasContext *ctx, int sz) 524aea3d0cSYoshinori Sato { 5305a8599fSRichard Henderson uint32_t addr = ctx->addr; 5405a8599fSRichard Henderson uintptr_t len = ctx->len; 554aea3d0cSYoshinori Sato 564aea3d0cSYoshinori Sato switch (sz) { 574aea3d0cSYoshinori Sato case 1: 5805a8599fSRichard Henderson g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes)); 594aea3d0cSYoshinori Sato ctx->addr += 1; 6005a8599fSRichard Henderson ctx->len += 1; 6105a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis); 6205a8599fSRichard Henderson return (int8_t)ctx->bytes[len]; 634aea3d0cSYoshinori Sato case 2: 6405a8599fSRichard Henderson g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes)); 654aea3d0cSYoshinori Sato ctx->addr += 2; 6605a8599fSRichard Henderson ctx->len += 2; 6705a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis); 6805a8599fSRichard Henderson return ldsw_le_p(ctx->bytes + len); 694aea3d0cSYoshinori Sato case 3: 7005a8599fSRichard Henderson g_assert(len + 3 <= ARRAY_SIZE(ctx->bytes)); 714aea3d0cSYoshinori Sato ctx->addr += 3; 7205a8599fSRichard Henderson ctx->len += 3; 7305a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 3, ctx->dis); 7405a8599fSRichard Henderson return (int8_t)ctx->bytes[len + 2] << 16 | lduw_le_p(ctx->bytes + len); 754aea3d0cSYoshinori Sato case 0: 7605a8599fSRichard Henderson g_assert(len + 4 <= ARRAY_SIZE(ctx->bytes)); 774aea3d0cSYoshinori Sato ctx->addr += 4; 7805a8599fSRichard Henderson ctx->len += 4; 7905a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 4, ctx->dis); 8005a8599fSRichard 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 105*e43917ccSRichard Henderson static void dump_bytes(DisasContext *ctx) 106*e43917ccSRichard Henderson { 107*e43917ccSRichard Henderson int i, len = ctx->len; 108*e43917ccSRichard Henderson 109*e43917ccSRichard Henderson for (i = 0; i < len; ++i) { 110*e43917ccSRichard Henderson ctx->dis->fprintf_func(ctx->dis->stream, "%02x ", ctx->bytes[i]); 111*e43917ccSRichard Henderson } 112*e43917ccSRichard Henderson ctx->dis->fprintf_func(ctx->dis->stream, "%*c", (8 - i) * 3, '\t'); 113*e43917ccSRichard Henderson } 114*e43917ccSRichard Henderson 115*e43917ccSRichard Henderson #define prt(...) \ 116*e43917ccSRichard Henderson do { \ 117*e43917ccSRichard Henderson dump_bytes(ctx); \ 118*e43917ccSRichard Henderson ctx->dis->fprintf_func(ctx->dis->stream, __VA_ARGS__); \ 119*e43917ccSRichard Henderson } while (0) 1204aea3d0cSYoshinori Sato 1214aea3d0cSYoshinori Sato #define RX_MEMORY_BYTE 0 1224aea3d0cSYoshinori Sato #define RX_MEMORY_WORD 1 1234aea3d0cSYoshinori Sato #define RX_MEMORY_LONG 2 1244aea3d0cSYoshinori Sato 1254aea3d0cSYoshinori Sato #define RX_IM_BYTE 0 1264aea3d0cSYoshinori Sato #define RX_IM_WORD 1 1274aea3d0cSYoshinori Sato #define RX_IM_LONG 2 1284aea3d0cSYoshinori Sato #define RX_IM_UWORD 3 1294aea3d0cSYoshinori Sato 1304aea3d0cSYoshinori Sato static const char size[] = {'b', 'w', 'l'}; 1314aea3d0cSYoshinori Sato static const char cond[][4] = { 1324aea3d0cSYoshinori Sato "eq", "ne", "c", "nc", "gtu", "leu", "pz", "n", 1334aea3d0cSYoshinori Sato "ge", "lt", "gt", "le", "o", "no", "ra", "f" 1344aea3d0cSYoshinori Sato }; 1354aea3d0cSYoshinori Sato static const char psw[] = { 1364aea3d0cSYoshinori Sato 'c', 'z', 's', 'o', 0, 0, 0, 0, 1374aea3d0cSYoshinori Sato 'i', 'u', 0, 0, 0, 0, 0, 0, 1384aea3d0cSYoshinori Sato }; 1394aea3d0cSYoshinori Sato 140fa6289e2SRichard Henderson static void rx_index_addr(DisasContext *ctx, char out[8], int ld, int mi) 1414aea3d0cSYoshinori Sato { 142fa6289e2SRichard Henderson uint32_t addr = ctx->addr; 14305a8599fSRichard Henderson uintptr_t len = ctx->len; 144fa6289e2SRichard Henderson uint16_t dsp; 145fa6289e2SRichard Henderson 1464aea3d0cSYoshinori Sato switch (ld) { 1474aea3d0cSYoshinori Sato case 0: 148fa6289e2SRichard Henderson /* No index; return empty string. */ 149fa6289e2SRichard Henderson out[0] = '\0'; 150fa6289e2SRichard Henderson return; 1514aea3d0cSYoshinori Sato case 1: 15205a8599fSRichard Henderson g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes)); 1534aea3d0cSYoshinori Sato ctx->addr += 1; 15405a8599fSRichard Henderson ctx->len += 1; 15505a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis); 15605a8599fSRichard Henderson dsp = ctx->bytes[len]; 157fa6289e2SRichard Henderson break; 1584aea3d0cSYoshinori Sato case 2: 15905a8599fSRichard Henderson g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes)); 1604aea3d0cSYoshinori Sato ctx->addr += 2; 16105a8599fSRichard Henderson ctx->len += 2; 16205a8599fSRichard Henderson ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis); 16305a8599fSRichard Henderson dsp = lduw_le_p(ctx->bytes + len); 164fa6289e2SRichard Henderson break; 165fa6289e2SRichard Henderson default: 1664aea3d0cSYoshinori Sato g_assert_not_reached(); 1674aea3d0cSYoshinori Sato } 1684aea3d0cSYoshinori Sato 169fa6289e2SRichard Henderson sprintf(out, "%u", dsp << (mi < 3 ? mi : 4 - mi)); 170fa6289e2SRichard Henderson } 171fa6289e2SRichard Henderson 172e283adeaSRichard Henderson static void prt_ldmi(DisasContext *ctx, const char *insn, 173e283adeaSRichard Henderson int ld, int mi, int rs, int rd) 1744aea3d0cSYoshinori Sato { 1754aea3d0cSYoshinori Sato static const char sizes[][4] = {".b", ".w", ".l", ".uw", ".ub"}; 176fa6289e2SRichard Henderson char dsp[8]; 177fa6289e2SRichard Henderson 1784aea3d0cSYoshinori Sato if (ld < 3) { 179fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, ld, mi); 180e283adeaSRichard Henderson prt("%s\t%s[r%d]%s, r%d", insn, dsp, rs, sizes[mi], rd); 1814aea3d0cSYoshinori Sato } else { 182e283adeaSRichard Henderson prt("%s\tr%d, r%d", insn, rs, rd); 1834aea3d0cSYoshinori Sato } 1844aea3d0cSYoshinori Sato } 1854aea3d0cSYoshinori Sato 1864aea3d0cSYoshinori Sato static void prt_ir(DisasContext *ctx, const char *insn, int imm, int rd) 1874aea3d0cSYoshinori Sato { 1884aea3d0cSYoshinori Sato if (imm < 0x100) { 1894aea3d0cSYoshinori Sato prt("%s\t#%d, r%d", insn, imm, rd); 1904aea3d0cSYoshinori Sato } else { 1914aea3d0cSYoshinori Sato prt("%s\t#0x%08x, r%d", insn, imm, rd); 1924aea3d0cSYoshinori Sato } 1934aea3d0cSYoshinori Sato } 1944aea3d0cSYoshinori Sato 1954aea3d0cSYoshinori Sato /* mov.[bwl] rs,dsp:[rd] */ 1964aea3d0cSYoshinori Sato static bool trans_MOV_rm(DisasContext *ctx, arg_MOV_rm *a) 1974aea3d0cSYoshinori Sato { 1984aea3d0cSYoshinori Sato if (a->dsp > 0) { 1994aea3d0cSYoshinori Sato prt("mov.%c\tr%d,%d[r%d]", 2004aea3d0cSYoshinori Sato size[a->sz], a->rs, a->dsp << a->sz, a->rd); 2014aea3d0cSYoshinori Sato } else { 2024aea3d0cSYoshinori Sato prt("mov.%c\tr%d,[r%d]", 2034aea3d0cSYoshinori Sato size[a->sz], a->rs, a->rd); 2044aea3d0cSYoshinori Sato } 2054aea3d0cSYoshinori Sato return true; 2064aea3d0cSYoshinori Sato } 2074aea3d0cSYoshinori Sato 2084aea3d0cSYoshinori Sato /* mov.[bwl] dsp:[rs],rd */ 2094aea3d0cSYoshinori Sato static bool trans_MOV_mr(DisasContext *ctx, arg_MOV_mr *a) 2104aea3d0cSYoshinori Sato { 2114aea3d0cSYoshinori Sato if (a->dsp > 0) { 2124aea3d0cSYoshinori Sato prt("mov.%c\t%d[r%d], r%d", 2134aea3d0cSYoshinori Sato size[a->sz], a->dsp << a->sz, a->rs, a->rd); 2144aea3d0cSYoshinori Sato } else { 2154aea3d0cSYoshinori Sato prt("mov.%c\t[r%d], r%d", 2164aea3d0cSYoshinori Sato size[a->sz], a->rs, a->rd); 2174aea3d0cSYoshinori Sato } 2184aea3d0cSYoshinori Sato return true; 2194aea3d0cSYoshinori Sato } 2204aea3d0cSYoshinori Sato 2214aea3d0cSYoshinori Sato /* mov.l #uimm4,rd */ 2224aea3d0cSYoshinori Sato /* mov.l #uimm8,rd */ 2234aea3d0cSYoshinori Sato /* mov.l #imm,rd */ 2244aea3d0cSYoshinori Sato static bool trans_MOV_ir(DisasContext *ctx, arg_MOV_ir *a) 2254aea3d0cSYoshinori Sato { 2264aea3d0cSYoshinori Sato prt_ir(ctx, "mov.l", a->imm, a->rd); 2274aea3d0cSYoshinori Sato return true; 2284aea3d0cSYoshinori Sato } 2294aea3d0cSYoshinori Sato 2304aea3d0cSYoshinori Sato /* mov.[bwl] #uimm8,dsp:[rd] */ 2314aea3d0cSYoshinori Sato /* mov #imm, dsp:[rd] */ 2324aea3d0cSYoshinori Sato static bool trans_MOV_im(DisasContext *ctx, arg_MOV_im *a) 2334aea3d0cSYoshinori Sato { 2344aea3d0cSYoshinori Sato if (a->dsp > 0) { 2354aea3d0cSYoshinori Sato prt("mov.%c\t#%d,%d[r%d]", 2364aea3d0cSYoshinori Sato size[a->sz], a->imm, a->dsp << a->sz, a->rd); 2374aea3d0cSYoshinori Sato } else { 2384aea3d0cSYoshinori Sato prt("mov.%c\t#%d,[r%d]", 2394aea3d0cSYoshinori Sato size[a->sz], a->imm, a->rd); 2404aea3d0cSYoshinori Sato } 2414aea3d0cSYoshinori Sato return true; 2424aea3d0cSYoshinori Sato } 2434aea3d0cSYoshinori Sato 2444aea3d0cSYoshinori Sato /* mov.[bwl] [ri,rb],rd */ 2454aea3d0cSYoshinori Sato static bool trans_MOV_ar(DisasContext *ctx, arg_MOV_ar *a) 2464aea3d0cSYoshinori Sato { 2474aea3d0cSYoshinori Sato prt("mov.%c\t[r%d,r%d], r%d", size[a->sz], a->ri, a->rb, a->rd); 2484aea3d0cSYoshinori Sato return true; 2494aea3d0cSYoshinori Sato } 2504aea3d0cSYoshinori Sato 2514aea3d0cSYoshinori Sato /* mov.[bwl] rd,[ri,rb] */ 2524aea3d0cSYoshinori Sato static bool trans_MOV_ra(DisasContext *ctx, arg_MOV_ra *a) 2534aea3d0cSYoshinori Sato { 2544aea3d0cSYoshinori Sato prt("mov.%c\tr%d, [r%d, r%d]", size[a->sz], a->rs, a->ri, a->rb); 2554aea3d0cSYoshinori Sato return true; 2564aea3d0cSYoshinori Sato } 2574aea3d0cSYoshinori Sato 2584aea3d0cSYoshinori Sato 2594aea3d0cSYoshinori Sato /* mov.[bwl] dsp:[rs],dsp:[rd] */ 2604aea3d0cSYoshinori Sato /* mov.[bwl] rs,dsp:[rd] */ 2614aea3d0cSYoshinori Sato /* mov.[bwl] dsp:[rs],rd */ 2624aea3d0cSYoshinori Sato /* mov.[bwl] rs,rd */ 2634aea3d0cSYoshinori Sato static bool trans_MOV_mm(DisasContext *ctx, arg_MOV_mm *a) 2644aea3d0cSYoshinori Sato { 26567eb12d8SRichard Henderson char dspd[8], dsps[8], szc = size[a->sz]; 2664aea3d0cSYoshinori Sato 2674aea3d0cSYoshinori Sato if (a->lds == 3 && a->ldd == 3) { 2684aea3d0cSYoshinori Sato /* mov.[bwl] rs,rd */ 26967eb12d8SRichard Henderson prt("mov.%c\tr%d, r%d", szc, a->rs, a->rd); 27067eb12d8SRichard Henderson } else if (a->lds == 3) { 271fa6289e2SRichard Henderson rx_index_addr(ctx, dspd, a->ldd, a->sz); 27267eb12d8SRichard Henderson prt("mov.%c\tr%d, %s[r%d]", szc, a->rs, dspd, a->rd); 2734aea3d0cSYoshinori Sato } else if (a->ldd == 3) { 274fa6289e2SRichard Henderson rx_index_addr(ctx, dsps, a->lds, a->sz); 27567eb12d8SRichard Henderson prt("mov.%c\t%s[r%d], r%d", szc, dsps, a->rs, a->rd); 2764aea3d0cSYoshinori Sato } else { 277fa6289e2SRichard Henderson rx_index_addr(ctx, dsps, a->lds, a->sz); 278fa6289e2SRichard Henderson rx_index_addr(ctx, dspd, a->ldd, a->sz); 27967eb12d8SRichard Henderson prt("mov.%c\t%s[r%d], %s[r%d]", szc, dsps, a->rs, dspd, a->rd); 2804aea3d0cSYoshinori Sato } 2814aea3d0cSYoshinori Sato return true; 2824aea3d0cSYoshinori Sato } 2834aea3d0cSYoshinori Sato 2844aea3d0cSYoshinori Sato /* mov.[bwl] rs,[rd+] */ 2854aea3d0cSYoshinori Sato /* mov.[bwl] rs,[-rd] */ 2864aea3d0cSYoshinori Sato static bool trans_MOV_rp(DisasContext *ctx, arg_MOV_rp *a) 2874aea3d0cSYoshinori Sato { 28867eb12d8SRichard Henderson if (a->ad) { 28967eb12d8SRichard Henderson prt("mov.%c\tr%d, [-r%d]", size[a->sz], a->rs, a->rd); 29067eb12d8SRichard Henderson } else { 29167eb12d8SRichard Henderson prt("mov.%c\tr%d, [r%d+]", size[a->sz], a->rs, a->rd); 29267eb12d8SRichard Henderson } 2934aea3d0cSYoshinori Sato return true; 2944aea3d0cSYoshinori Sato } 2954aea3d0cSYoshinori Sato 2964aea3d0cSYoshinori Sato /* mov.[bwl] [rd+],rs */ 2974aea3d0cSYoshinori Sato /* mov.[bwl] [-rd],rs */ 2984aea3d0cSYoshinori Sato static bool trans_MOV_pr(DisasContext *ctx, arg_MOV_pr *a) 2994aea3d0cSYoshinori Sato { 30067eb12d8SRichard Henderson if (a->ad) { 30167eb12d8SRichard Henderson prt("mov.%c\t[-r%d], r%d", size[a->sz], a->rd, a->rs); 30267eb12d8SRichard Henderson } else { 30367eb12d8SRichard Henderson prt("mov.%c\t[r%d+], r%d", size[a->sz], a->rd, a->rs); 30467eb12d8SRichard Henderson } 3054aea3d0cSYoshinori Sato return true; 3064aea3d0cSYoshinori Sato } 3074aea3d0cSYoshinori Sato 3084aea3d0cSYoshinori Sato /* movu.[bw] dsp5:[rs],rd */ 3094aea3d0cSYoshinori Sato static bool trans_MOVU_mr(DisasContext *ctx, arg_MOVU_mr *a) 3104aea3d0cSYoshinori Sato { 3114aea3d0cSYoshinori Sato if (a->dsp > 0) { 3124aea3d0cSYoshinori Sato prt("movu.%c\t%d[r%d], r%d", size[a->sz], 3134aea3d0cSYoshinori Sato a->dsp << a->sz, a->rs, a->rd); 3144aea3d0cSYoshinori Sato } else { 3154aea3d0cSYoshinori Sato prt("movu.%c\t[r%d], r%d", size[a->sz], a->rs, a->rd); 3164aea3d0cSYoshinori Sato } 3174aea3d0cSYoshinori Sato return true; 3184aea3d0cSYoshinori Sato } 3194aea3d0cSYoshinori Sato 3204aea3d0cSYoshinori Sato /* movu.[bw] rs,rd */ 3214aea3d0cSYoshinori Sato static bool trans_MOVU_rr(DisasContext *ctx, arg_MOVU_rr *a) 3224aea3d0cSYoshinori Sato { 3234aea3d0cSYoshinori Sato prt("movu.%c\tr%d, r%d", size[a->sz], a->rs, a->rd); 3244aea3d0cSYoshinori Sato return true; 3254aea3d0cSYoshinori Sato } 3264aea3d0cSYoshinori Sato 3274aea3d0cSYoshinori Sato /* movu.[bw] [ri,rb],rd */ 3284aea3d0cSYoshinori Sato static bool trans_MOVU_ar(DisasContext *ctx, arg_MOVU_ar *a) 3294aea3d0cSYoshinori Sato { 3304aea3d0cSYoshinori Sato prt("mov.%c\t[r%d,r%d], r%d", size[a->sz], a->ri, a->rb, a->rd); 3314aea3d0cSYoshinori Sato return true; 3324aea3d0cSYoshinori Sato } 3334aea3d0cSYoshinori Sato 3344aea3d0cSYoshinori Sato /* movu.[bw] [rs+],rd */ 3354aea3d0cSYoshinori Sato /* movu.[bw] [-rs],rd */ 3364aea3d0cSYoshinori Sato static bool trans_MOVU_pr(DisasContext *ctx, arg_MOVU_pr *a) 3374aea3d0cSYoshinori Sato { 33867eb12d8SRichard Henderson if (a->ad) { 33967eb12d8SRichard Henderson prt("movu.%c\t[-r%d], r%d", size[a->sz], a->rd, a->rs); 34067eb12d8SRichard Henderson } else { 34167eb12d8SRichard Henderson prt("movu.%c\t[r%d+], r%d", size[a->sz], a->rd, a->rs); 34267eb12d8SRichard Henderson } 3434aea3d0cSYoshinori Sato return true; 3444aea3d0cSYoshinori Sato } 3454aea3d0cSYoshinori Sato 3464aea3d0cSYoshinori Sato /* pop rd */ 3474aea3d0cSYoshinori Sato static bool trans_POP(DisasContext *ctx, arg_POP *a) 3484aea3d0cSYoshinori Sato { 3494aea3d0cSYoshinori Sato prt("pop\tr%d", a->rd); 3504aea3d0cSYoshinori Sato return true; 3514aea3d0cSYoshinori Sato } 3524aea3d0cSYoshinori Sato 3534aea3d0cSYoshinori Sato /* popc rx */ 3544aea3d0cSYoshinori Sato static bool trans_POPC(DisasContext *ctx, arg_POPC *a) 3554aea3d0cSYoshinori Sato { 3564aea3d0cSYoshinori Sato prt("pop\tr%s", rx_crname(a->cr)); 3574aea3d0cSYoshinori Sato return true; 3584aea3d0cSYoshinori Sato } 3594aea3d0cSYoshinori Sato 3604aea3d0cSYoshinori Sato /* popm rd-rd2 */ 3614aea3d0cSYoshinori Sato static bool trans_POPM(DisasContext *ctx, arg_POPM *a) 3624aea3d0cSYoshinori Sato { 3634aea3d0cSYoshinori Sato prt("popm\tr%d-r%d", a->rd, a->rd2); 3644aea3d0cSYoshinori Sato return true; 3654aea3d0cSYoshinori Sato } 3664aea3d0cSYoshinori Sato 3674aea3d0cSYoshinori Sato /* push rs */ 3684aea3d0cSYoshinori Sato static bool trans_PUSH_r(DisasContext *ctx, arg_PUSH_r *a) 3694aea3d0cSYoshinori Sato { 3704aea3d0cSYoshinori Sato prt("push\tr%d", a->rs); 3714aea3d0cSYoshinori Sato return true; 3724aea3d0cSYoshinori Sato } 3734aea3d0cSYoshinori Sato 3744aea3d0cSYoshinori Sato /* push dsp[rs] */ 3754aea3d0cSYoshinori Sato static bool trans_PUSH_m(DisasContext *ctx, arg_PUSH_m *a) 3764aea3d0cSYoshinori Sato { 377fa6289e2SRichard Henderson char dsp[8]; 378fa6289e2SRichard Henderson 379fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, a->sz); 380fa6289e2SRichard Henderson prt("push\t%s[r%d]", dsp, a->rs); 3814aea3d0cSYoshinori Sato return true; 3824aea3d0cSYoshinori Sato } 3834aea3d0cSYoshinori Sato 3844aea3d0cSYoshinori Sato /* pushc rx */ 3854aea3d0cSYoshinori Sato static bool trans_PUSHC(DisasContext *ctx, arg_PUSHC *a) 3864aea3d0cSYoshinori Sato { 3874aea3d0cSYoshinori Sato prt("push\t%s", rx_crname(a->cr)); 3884aea3d0cSYoshinori Sato return true; 3894aea3d0cSYoshinori Sato } 3904aea3d0cSYoshinori Sato 3914aea3d0cSYoshinori Sato /* pushm rs-rs2*/ 3924aea3d0cSYoshinori Sato static bool trans_PUSHM(DisasContext *ctx, arg_PUSHM *a) 3934aea3d0cSYoshinori Sato { 3944aea3d0cSYoshinori Sato prt("pushm\tr%d-r%d", a->rs, a->rs2); 3954aea3d0cSYoshinori Sato return true; 3964aea3d0cSYoshinori Sato } 3974aea3d0cSYoshinori Sato 3984aea3d0cSYoshinori Sato /* xchg rs,rd */ 3994aea3d0cSYoshinori Sato static bool trans_XCHG_rr(DisasContext *ctx, arg_XCHG_rr *a) 4004aea3d0cSYoshinori Sato { 4014aea3d0cSYoshinori Sato prt("xchg\tr%d, r%d", a->rs, a->rd); 4024aea3d0cSYoshinori Sato return true; 4034aea3d0cSYoshinori Sato } 4044aea3d0cSYoshinori Sato /* xchg dsp[rs].<mi>,rd */ 4054aea3d0cSYoshinori Sato static bool trans_XCHG_mr(DisasContext *ctx, arg_XCHG_mr *a) 4064aea3d0cSYoshinori Sato { 4075cf7c960SRichard Henderson prt_ldmi(ctx, "xchg", a->ld, a->mi, a->rs, a->rd); 4084aea3d0cSYoshinori Sato return true; 4094aea3d0cSYoshinori Sato } 4104aea3d0cSYoshinori Sato 4114aea3d0cSYoshinori Sato /* stz #imm,rd */ 4124aea3d0cSYoshinori Sato static bool trans_STZ(DisasContext *ctx, arg_STZ *a) 4134aea3d0cSYoshinori Sato { 4144aea3d0cSYoshinori Sato prt_ir(ctx, "stz", a->imm, a->rd); 4154aea3d0cSYoshinori Sato return true; 4164aea3d0cSYoshinori Sato } 4174aea3d0cSYoshinori Sato 4184aea3d0cSYoshinori Sato /* stnz #imm,rd */ 4194aea3d0cSYoshinori Sato static bool trans_STNZ(DisasContext *ctx, arg_STNZ *a) 4204aea3d0cSYoshinori Sato { 4214aea3d0cSYoshinori Sato prt_ir(ctx, "stnz", a->imm, a->rd); 4224aea3d0cSYoshinori Sato return true; 4234aea3d0cSYoshinori Sato } 4244aea3d0cSYoshinori Sato 4254aea3d0cSYoshinori Sato /* rtsd #imm */ 4264aea3d0cSYoshinori Sato static bool trans_RTSD_i(DisasContext *ctx, arg_RTSD_i *a) 4274aea3d0cSYoshinori Sato { 4284aea3d0cSYoshinori Sato prt("rtsd\t#%d", a->imm << 2); 4294aea3d0cSYoshinori Sato return true; 4304aea3d0cSYoshinori Sato } 4314aea3d0cSYoshinori Sato 4324aea3d0cSYoshinori Sato /* rtsd #imm, rd-rd2 */ 4334aea3d0cSYoshinori Sato static bool trans_RTSD_irr(DisasContext *ctx, arg_RTSD_irr *a) 4344aea3d0cSYoshinori Sato { 4354aea3d0cSYoshinori Sato prt("rtsd\t#%d, r%d - r%d", a->imm << 2, a->rd, a->rd2); 4364aea3d0cSYoshinori Sato return true; 4374aea3d0cSYoshinori Sato } 4384aea3d0cSYoshinori Sato 4394aea3d0cSYoshinori Sato /* and #uimm:4, rd */ 4404aea3d0cSYoshinori Sato /* and #imm, rd */ 4414aea3d0cSYoshinori Sato static bool trans_AND_ir(DisasContext *ctx, arg_AND_ir *a) 4424aea3d0cSYoshinori Sato { 4434aea3d0cSYoshinori Sato prt_ir(ctx, "and", a->imm, a->rd); 4444aea3d0cSYoshinori Sato return true; 4454aea3d0cSYoshinori Sato } 4464aea3d0cSYoshinori Sato 4474aea3d0cSYoshinori Sato /* and dsp[rs], rd */ 4484aea3d0cSYoshinori Sato /* and rs,rd */ 4494aea3d0cSYoshinori Sato static bool trans_AND_mr(DisasContext *ctx, arg_AND_mr *a) 4504aea3d0cSYoshinori Sato { 451e283adeaSRichard Henderson prt_ldmi(ctx, "and", a->ld, a->mi, a->rs, a->rd); 4524aea3d0cSYoshinori Sato return true; 4534aea3d0cSYoshinori Sato } 4544aea3d0cSYoshinori Sato 4554aea3d0cSYoshinori Sato /* and rs,rs2,rd */ 4564aea3d0cSYoshinori Sato static bool trans_AND_rrr(DisasContext *ctx, arg_AND_rrr *a) 4574aea3d0cSYoshinori Sato { 4584aea3d0cSYoshinori Sato prt("and\tr%d,r%d, r%d", a->rs, a->rs2, a->rd); 4594aea3d0cSYoshinori Sato return true; 4604aea3d0cSYoshinori Sato } 4614aea3d0cSYoshinori Sato 4624aea3d0cSYoshinori Sato /* or #uimm:4, rd */ 4634aea3d0cSYoshinori Sato /* or #imm, rd */ 4644aea3d0cSYoshinori Sato static bool trans_OR_ir(DisasContext *ctx, arg_OR_ir *a) 4654aea3d0cSYoshinori Sato { 4664aea3d0cSYoshinori Sato prt_ir(ctx, "or", a->imm, a->rd); 4674aea3d0cSYoshinori Sato return true; 4684aea3d0cSYoshinori Sato } 4694aea3d0cSYoshinori Sato 4704aea3d0cSYoshinori Sato /* or dsp[rs], rd */ 4714aea3d0cSYoshinori Sato /* or rs,rd */ 4724aea3d0cSYoshinori Sato static bool trans_OR_mr(DisasContext *ctx, arg_OR_mr *a) 4734aea3d0cSYoshinori Sato { 474e283adeaSRichard Henderson prt_ldmi(ctx, "or", a->ld, a->mi, a->rs, a->rd); 4754aea3d0cSYoshinori Sato return true; 4764aea3d0cSYoshinori Sato } 4774aea3d0cSYoshinori Sato 4784aea3d0cSYoshinori Sato /* or rs,rs2,rd */ 4794aea3d0cSYoshinori Sato static bool trans_OR_rrr(DisasContext *ctx, arg_OR_rrr *a) 4804aea3d0cSYoshinori Sato { 4814aea3d0cSYoshinori Sato prt("or\tr%d, r%d, r%d", a->rs, a->rs2, a->rd); 4824aea3d0cSYoshinori Sato return true; 4834aea3d0cSYoshinori Sato } 4844aea3d0cSYoshinori Sato 4854aea3d0cSYoshinori Sato /* xor #imm, rd */ 4864aea3d0cSYoshinori Sato static bool trans_XOR_ir(DisasContext *ctx, arg_XOR_ir *a) 4874aea3d0cSYoshinori Sato { 4884aea3d0cSYoshinori Sato prt_ir(ctx, "xor", a->imm, a->rd); 4894aea3d0cSYoshinori Sato return true; 4904aea3d0cSYoshinori Sato } 4914aea3d0cSYoshinori Sato 4924aea3d0cSYoshinori Sato /* xor dsp[rs], rd */ 4934aea3d0cSYoshinori Sato /* xor rs,rd */ 4944aea3d0cSYoshinori Sato static bool trans_XOR_mr(DisasContext *ctx, arg_XOR_mr *a) 4954aea3d0cSYoshinori Sato { 496e283adeaSRichard Henderson prt_ldmi(ctx, "xor", a->ld, a->mi, a->rs, a->rd); 4974aea3d0cSYoshinori Sato return true; 4984aea3d0cSYoshinori Sato } 4994aea3d0cSYoshinori Sato 5004aea3d0cSYoshinori Sato /* tst #imm, rd */ 5014aea3d0cSYoshinori Sato static bool trans_TST_ir(DisasContext *ctx, arg_TST_ir *a) 5024aea3d0cSYoshinori Sato { 5034aea3d0cSYoshinori Sato prt_ir(ctx, "tst", a->imm, a->rd); 5044aea3d0cSYoshinori Sato return true; 5054aea3d0cSYoshinori Sato } 5064aea3d0cSYoshinori Sato 5074aea3d0cSYoshinori Sato /* tst dsp[rs], rd */ 5084aea3d0cSYoshinori Sato /* tst rs, rd */ 5094aea3d0cSYoshinori Sato static bool trans_TST_mr(DisasContext *ctx, arg_TST_mr *a) 5104aea3d0cSYoshinori Sato { 511e283adeaSRichard Henderson prt_ldmi(ctx, "tst", a->ld, a->mi, a->rs, a->rd); 5124aea3d0cSYoshinori Sato return true; 5134aea3d0cSYoshinori Sato } 5144aea3d0cSYoshinori Sato 5154aea3d0cSYoshinori Sato /* not rd */ 5164aea3d0cSYoshinori Sato /* not rs, rd */ 5174aea3d0cSYoshinori Sato static bool trans_NOT_rr(DisasContext *ctx, arg_NOT_rr *a) 5184aea3d0cSYoshinori Sato { 5194aea3d0cSYoshinori Sato if (a->rs != a->rd) { 52067eb12d8SRichard Henderson prt("not\tr%d, r%d", a->rs, a->rd); 52167eb12d8SRichard Henderson } else { 52267eb12d8SRichard Henderson prt("not\tr%d", a->rs); 5234aea3d0cSYoshinori Sato } 5244aea3d0cSYoshinori Sato return true; 5254aea3d0cSYoshinori Sato } 5264aea3d0cSYoshinori Sato 5274aea3d0cSYoshinori Sato /* neg rd */ 5284aea3d0cSYoshinori Sato /* neg rs, rd */ 5294aea3d0cSYoshinori Sato static bool trans_NEG_rr(DisasContext *ctx, arg_NEG_rr *a) 5304aea3d0cSYoshinori Sato { 5314aea3d0cSYoshinori Sato if (a->rs != a->rd) { 53267eb12d8SRichard Henderson prt("neg\tr%d, r%d", a->rs, a->rd); 53367eb12d8SRichard Henderson } else { 53467eb12d8SRichard Henderson prt("neg\tr%d", a->rs); 5354aea3d0cSYoshinori Sato } 5364aea3d0cSYoshinori Sato return true; 5374aea3d0cSYoshinori Sato } 5384aea3d0cSYoshinori Sato 5394aea3d0cSYoshinori Sato /* adc #imm, rd */ 5404aea3d0cSYoshinori Sato static bool trans_ADC_ir(DisasContext *ctx, arg_ADC_ir *a) 5414aea3d0cSYoshinori Sato { 5424aea3d0cSYoshinori Sato prt_ir(ctx, "adc", a->imm, a->rd); 5434aea3d0cSYoshinori Sato return true; 5444aea3d0cSYoshinori Sato } 5454aea3d0cSYoshinori Sato 5464aea3d0cSYoshinori Sato /* adc rs, rd */ 5474aea3d0cSYoshinori Sato static bool trans_ADC_rr(DisasContext *ctx, arg_ADC_rr *a) 5484aea3d0cSYoshinori Sato { 5494aea3d0cSYoshinori Sato prt("adc\tr%d, r%d", a->rs, a->rd); 5504aea3d0cSYoshinori Sato return true; 5514aea3d0cSYoshinori Sato } 5524aea3d0cSYoshinori Sato 5534aea3d0cSYoshinori Sato /* adc dsp[rs], rd */ 5544aea3d0cSYoshinori Sato static bool trans_ADC_mr(DisasContext *ctx, arg_ADC_mr *a) 5554aea3d0cSYoshinori Sato { 556fa6289e2SRichard Henderson char dsp[8]; 557fa6289e2SRichard Henderson 558fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, 2); 559fa6289e2SRichard Henderson prt("adc\t%s[r%d], r%d", dsp, a->rs, a->rd); 5604aea3d0cSYoshinori Sato return true; 5614aea3d0cSYoshinori Sato } 5624aea3d0cSYoshinori Sato 5634aea3d0cSYoshinori Sato /* add #uimm4, rd */ 5644aea3d0cSYoshinori Sato /* add #imm, rs, rd */ 5654aea3d0cSYoshinori Sato static bool trans_ADD_irr(DisasContext *ctx, arg_ADD_irr *a) 5664aea3d0cSYoshinori Sato { 5674aea3d0cSYoshinori Sato if (a->imm < 0x10 && a->rs2 == a->rd) { 5684aea3d0cSYoshinori Sato prt("add\t#%d, r%d", a->imm, a->rd); 5694aea3d0cSYoshinori Sato } else { 5704aea3d0cSYoshinori Sato prt("add\t#0x%08x, r%d, r%d", a->imm, a->rs2, a->rd); 5714aea3d0cSYoshinori Sato } 5724aea3d0cSYoshinori Sato return true; 5734aea3d0cSYoshinori Sato } 5744aea3d0cSYoshinori Sato 5754aea3d0cSYoshinori Sato /* add rs, rd */ 5764aea3d0cSYoshinori Sato /* add dsp[rs], rd */ 5774aea3d0cSYoshinori Sato static bool trans_ADD_mr(DisasContext *ctx, arg_ADD_mr *a) 5784aea3d0cSYoshinori Sato { 579e283adeaSRichard Henderson prt_ldmi(ctx, "add", a->ld, a->mi, a->rs, a->rd); 5804aea3d0cSYoshinori Sato return true; 5814aea3d0cSYoshinori Sato } 5824aea3d0cSYoshinori Sato 5834aea3d0cSYoshinori Sato /* add rs, rs2, rd */ 5844aea3d0cSYoshinori Sato static bool trans_ADD_rrr(DisasContext *ctx, arg_ADD_rrr *a) 5854aea3d0cSYoshinori Sato { 5864aea3d0cSYoshinori Sato prt("add\tr%d, r%d, r%d", a->rs, a->rs2, a->rd); 5874aea3d0cSYoshinori Sato return true; 5884aea3d0cSYoshinori Sato } 5894aea3d0cSYoshinori Sato 5904aea3d0cSYoshinori Sato /* cmp #imm4, rd */ 5914aea3d0cSYoshinori Sato /* cmp #imm8, rd */ 5924aea3d0cSYoshinori Sato /* cmp #imm, rs2 */ 5934aea3d0cSYoshinori Sato static bool trans_CMP_ir(DisasContext *ctx, arg_CMP_ir *a) 5944aea3d0cSYoshinori Sato { 5954aea3d0cSYoshinori Sato prt_ir(ctx, "cmp", a->imm, a->rs2); 5964aea3d0cSYoshinori Sato return true; 5974aea3d0cSYoshinori Sato } 5984aea3d0cSYoshinori Sato 5994aea3d0cSYoshinori Sato /* cmp rs, rs2 */ 6004aea3d0cSYoshinori Sato /* cmp dsp[rs], rs2 */ 6014aea3d0cSYoshinori Sato static bool trans_CMP_mr(DisasContext *ctx, arg_CMP_mr *a) 6024aea3d0cSYoshinori Sato { 603e283adeaSRichard Henderson prt_ldmi(ctx, "cmp", a->ld, a->mi, a->rs, a->rd); 6044aea3d0cSYoshinori Sato return true; 6054aea3d0cSYoshinori Sato } 6064aea3d0cSYoshinori Sato 6074aea3d0cSYoshinori Sato /* sub #imm4, rd */ 6084aea3d0cSYoshinori Sato static bool trans_SUB_ir(DisasContext *ctx, arg_SUB_ir *a) 6094aea3d0cSYoshinori Sato { 6104aea3d0cSYoshinori Sato prt("sub\t#%d, r%d", a->imm, a->rd); 6114aea3d0cSYoshinori Sato return true; 6124aea3d0cSYoshinori Sato } 6134aea3d0cSYoshinori Sato 6144aea3d0cSYoshinori Sato /* sub rs, rd */ 6154aea3d0cSYoshinori Sato /* sub dsp[rs], rd */ 6164aea3d0cSYoshinori Sato static bool trans_SUB_mr(DisasContext *ctx, arg_SUB_mr *a) 6174aea3d0cSYoshinori Sato { 618e283adeaSRichard Henderson prt_ldmi(ctx, "sub", a->ld, a->mi, a->rs, a->rd); 6194aea3d0cSYoshinori Sato return true; 6204aea3d0cSYoshinori Sato } 6214aea3d0cSYoshinori Sato 6224aea3d0cSYoshinori Sato /* sub rs, rs2, rd */ 6234aea3d0cSYoshinori Sato static bool trans_SUB_rrr(DisasContext *ctx, arg_SUB_rrr *a) 6244aea3d0cSYoshinori Sato { 6254aea3d0cSYoshinori Sato prt("sub\tr%d, r%d, r%d", a->rs, a->rs2, a->rd); 6264aea3d0cSYoshinori Sato return true; 6274aea3d0cSYoshinori Sato } 6284aea3d0cSYoshinori Sato 6294aea3d0cSYoshinori Sato /* sbb rs, rd */ 6304aea3d0cSYoshinori Sato static bool trans_SBB_rr(DisasContext *ctx, arg_SBB_rr *a) 6314aea3d0cSYoshinori Sato { 6324aea3d0cSYoshinori Sato prt("sbb\tr%d, r%d", a->rs, a->rd); 6334aea3d0cSYoshinori Sato return true; 6344aea3d0cSYoshinori Sato } 6354aea3d0cSYoshinori Sato 6364aea3d0cSYoshinori Sato /* sbb dsp[rs], rd */ 6374aea3d0cSYoshinori Sato static bool trans_SBB_mr(DisasContext *ctx, arg_SBB_mr *a) 6384aea3d0cSYoshinori Sato { 639e283adeaSRichard Henderson prt_ldmi(ctx, "sbb", a->ld, RX_IM_LONG, a->rs, a->rd); 6404aea3d0cSYoshinori Sato return true; 6414aea3d0cSYoshinori Sato } 6424aea3d0cSYoshinori Sato 6434aea3d0cSYoshinori Sato /* abs rd */ 6444aea3d0cSYoshinori Sato /* abs rs, rd */ 6454aea3d0cSYoshinori Sato static bool trans_ABS_rr(DisasContext *ctx, arg_ABS_rr *a) 6464aea3d0cSYoshinori Sato { 64767eb12d8SRichard Henderson if (a->rs != a->rd) { 64867eb12d8SRichard Henderson prt("abs\tr%d, r%d", a->rs, a->rd); 6494aea3d0cSYoshinori Sato } else { 65067eb12d8SRichard Henderson prt("abs\tr%d", a->rs); 6514aea3d0cSYoshinori Sato } 6524aea3d0cSYoshinori Sato return true; 6534aea3d0cSYoshinori Sato } 6544aea3d0cSYoshinori Sato 6554aea3d0cSYoshinori Sato /* max #imm, rd */ 6564aea3d0cSYoshinori Sato static bool trans_MAX_ir(DisasContext *ctx, arg_MAX_ir *a) 6574aea3d0cSYoshinori Sato { 6584aea3d0cSYoshinori Sato prt_ir(ctx, "max", a->imm, a->rd); 6594aea3d0cSYoshinori Sato return true; 6604aea3d0cSYoshinori Sato } 6614aea3d0cSYoshinori Sato 6624aea3d0cSYoshinori Sato /* max rs, rd */ 6634aea3d0cSYoshinori Sato /* max dsp[rs], rd */ 6644aea3d0cSYoshinori Sato static bool trans_MAX_mr(DisasContext *ctx, arg_MAX_mr *a) 6654aea3d0cSYoshinori Sato { 666e283adeaSRichard Henderson prt_ldmi(ctx, "max", a->ld, a->mi, a->rs, a->rd); 6674aea3d0cSYoshinori Sato return true; 6684aea3d0cSYoshinori Sato } 6694aea3d0cSYoshinori Sato 6704aea3d0cSYoshinori Sato /* min #imm, rd */ 6714aea3d0cSYoshinori Sato static bool trans_MIN_ir(DisasContext *ctx, arg_MIN_ir *a) 6724aea3d0cSYoshinori Sato { 6734aea3d0cSYoshinori Sato prt_ir(ctx, "min", a->imm, a->rd); 6744aea3d0cSYoshinori Sato return true; 6754aea3d0cSYoshinori Sato } 6764aea3d0cSYoshinori Sato 6774aea3d0cSYoshinori Sato /* min rs, rd */ 6784aea3d0cSYoshinori Sato /* min dsp[rs], rd */ 6794aea3d0cSYoshinori Sato static bool trans_MIN_mr(DisasContext *ctx, arg_MIN_mr *a) 6804aea3d0cSYoshinori Sato { 681e283adeaSRichard Henderson prt_ldmi(ctx, "min", a->ld, a->mi, a->rs, a->rd); 6824aea3d0cSYoshinori Sato return true; 6834aea3d0cSYoshinori Sato } 6844aea3d0cSYoshinori Sato 6854aea3d0cSYoshinori Sato /* mul #uimm4, rd */ 6864aea3d0cSYoshinori Sato /* mul #imm, rd */ 6874aea3d0cSYoshinori Sato static bool trans_MUL_ir(DisasContext *ctx, arg_MUL_ir *a) 6884aea3d0cSYoshinori Sato { 6894aea3d0cSYoshinori Sato prt_ir(ctx, "mul", a->imm, a->rd); 6904aea3d0cSYoshinori Sato return true; 6914aea3d0cSYoshinori Sato } 6924aea3d0cSYoshinori Sato 6934aea3d0cSYoshinori Sato /* mul rs, rd */ 6944aea3d0cSYoshinori Sato /* mul dsp[rs], rd */ 6954aea3d0cSYoshinori Sato static bool trans_MUL_mr(DisasContext *ctx, arg_MUL_mr *a) 6964aea3d0cSYoshinori Sato { 697e283adeaSRichard Henderson prt_ldmi(ctx, "mul", a->ld, a->mi, a->rs, a->rd); 6984aea3d0cSYoshinori Sato return true; 6994aea3d0cSYoshinori Sato } 7004aea3d0cSYoshinori Sato 7014aea3d0cSYoshinori Sato /* mul rs, rs2, rd */ 7024aea3d0cSYoshinori Sato static bool trans_MUL_rrr(DisasContext *ctx, arg_MUL_rrr *a) 7034aea3d0cSYoshinori Sato { 7044aea3d0cSYoshinori Sato prt("mul\tr%d,r%d,r%d", a->rs, a->rs2, a->rd); 7054aea3d0cSYoshinori Sato return true; 7064aea3d0cSYoshinori Sato } 7074aea3d0cSYoshinori Sato 7084aea3d0cSYoshinori Sato /* emul #imm, rd */ 7094aea3d0cSYoshinori Sato static bool trans_EMUL_ir(DisasContext *ctx, arg_EMUL_ir *a) 7104aea3d0cSYoshinori Sato { 7114aea3d0cSYoshinori Sato prt_ir(ctx, "emul", a->imm, a->rd); 7124aea3d0cSYoshinori Sato return true; 7134aea3d0cSYoshinori Sato } 7144aea3d0cSYoshinori Sato 7154aea3d0cSYoshinori Sato /* emul rs, rd */ 7164aea3d0cSYoshinori Sato /* emul dsp[rs], rd */ 7174aea3d0cSYoshinori Sato static bool trans_EMUL_mr(DisasContext *ctx, arg_EMUL_mr *a) 7184aea3d0cSYoshinori Sato { 719e283adeaSRichard Henderson prt_ldmi(ctx, "emul", a->ld, a->mi, a->rs, a->rd); 7204aea3d0cSYoshinori Sato return true; 7214aea3d0cSYoshinori Sato } 7224aea3d0cSYoshinori Sato 7234aea3d0cSYoshinori Sato /* emulu #imm, rd */ 7244aea3d0cSYoshinori Sato static bool trans_EMULU_ir(DisasContext *ctx, arg_EMULU_ir *a) 7254aea3d0cSYoshinori Sato { 7264aea3d0cSYoshinori Sato prt_ir(ctx, "emulu", a->imm, a->rd); 7274aea3d0cSYoshinori Sato return true; 7284aea3d0cSYoshinori Sato } 7294aea3d0cSYoshinori Sato 7304aea3d0cSYoshinori Sato /* emulu rs, rd */ 7314aea3d0cSYoshinori Sato /* emulu dsp[rs], rd */ 7324aea3d0cSYoshinori Sato static bool trans_EMULU_mr(DisasContext *ctx, arg_EMULU_mr *a) 7334aea3d0cSYoshinori Sato { 734e283adeaSRichard Henderson prt_ldmi(ctx, "emulu", a->ld, a->mi, a->rs, a->rd); 7354aea3d0cSYoshinori Sato return true; 7364aea3d0cSYoshinori Sato } 7374aea3d0cSYoshinori Sato 7384aea3d0cSYoshinori Sato /* div #imm, rd */ 7394aea3d0cSYoshinori Sato static bool trans_DIV_ir(DisasContext *ctx, arg_DIV_ir *a) 7404aea3d0cSYoshinori Sato { 7414aea3d0cSYoshinori Sato prt_ir(ctx, "div", a->imm, a->rd); 7424aea3d0cSYoshinori Sato return true; 7434aea3d0cSYoshinori Sato } 7444aea3d0cSYoshinori Sato 7454aea3d0cSYoshinori Sato /* div rs, rd */ 7464aea3d0cSYoshinori Sato /* div dsp[rs], rd */ 7474aea3d0cSYoshinori Sato static bool trans_DIV_mr(DisasContext *ctx, arg_DIV_mr *a) 7484aea3d0cSYoshinori Sato { 749e283adeaSRichard Henderson prt_ldmi(ctx, "div", a->ld, a->mi, a->rs, a->rd); 7504aea3d0cSYoshinori Sato return true; 7514aea3d0cSYoshinori Sato } 7524aea3d0cSYoshinori Sato 7534aea3d0cSYoshinori Sato /* divu #imm, rd */ 7544aea3d0cSYoshinori Sato static bool trans_DIVU_ir(DisasContext *ctx, arg_DIVU_ir *a) 7554aea3d0cSYoshinori Sato { 7564aea3d0cSYoshinori Sato prt_ir(ctx, "divu", a->imm, a->rd); 7574aea3d0cSYoshinori Sato return true; 7584aea3d0cSYoshinori Sato } 7594aea3d0cSYoshinori Sato 7604aea3d0cSYoshinori Sato /* divu rs, rd */ 7614aea3d0cSYoshinori Sato /* divu dsp[rs], rd */ 7624aea3d0cSYoshinori Sato static bool trans_DIVU_mr(DisasContext *ctx, arg_DIVU_mr *a) 7634aea3d0cSYoshinori Sato { 764e283adeaSRichard Henderson prt_ldmi(ctx, "divu", a->ld, a->mi, a->rs, a->rd); 7654aea3d0cSYoshinori Sato return true; 7664aea3d0cSYoshinori Sato } 7674aea3d0cSYoshinori Sato 7684aea3d0cSYoshinori Sato 7694aea3d0cSYoshinori Sato /* shll #imm:5, rd */ 7704aea3d0cSYoshinori Sato /* shll #imm:5, rs, rd */ 7714aea3d0cSYoshinori Sato static bool trans_SHLL_irr(DisasContext *ctx, arg_SHLL_irr *a) 7724aea3d0cSYoshinori Sato { 7734aea3d0cSYoshinori Sato if (a->rs2 != a->rd) { 77467eb12d8SRichard Henderson prt("shll\t#%d, r%d, r%d", a->imm, a->rs2, a->rd); 77567eb12d8SRichard Henderson } else { 77667eb12d8SRichard Henderson prt("shll\t#%d, r%d", a->imm, a->rd); 7774aea3d0cSYoshinori Sato } 7784aea3d0cSYoshinori Sato return true; 7794aea3d0cSYoshinori Sato } 7804aea3d0cSYoshinori Sato 7814aea3d0cSYoshinori Sato /* shll rs, rd */ 7824aea3d0cSYoshinori Sato static bool trans_SHLL_rr(DisasContext *ctx, arg_SHLL_rr *a) 7834aea3d0cSYoshinori Sato { 7844aea3d0cSYoshinori Sato prt("shll\tr%d, r%d", a->rs, a->rd); 7854aea3d0cSYoshinori Sato return true; 7864aea3d0cSYoshinori Sato } 7874aea3d0cSYoshinori Sato 7884aea3d0cSYoshinori Sato /* shar #imm:5, rd */ 7894aea3d0cSYoshinori Sato /* shar #imm:5, rs, rd */ 7904aea3d0cSYoshinori Sato static bool trans_SHAR_irr(DisasContext *ctx, arg_SHAR_irr *a) 7914aea3d0cSYoshinori Sato { 7924aea3d0cSYoshinori Sato if (a->rs2 != a->rd) { 79367eb12d8SRichard Henderson prt("shar\t#%d, r%d, r%d", a->imm, a->rs2, a->rd); 79467eb12d8SRichard Henderson } else { 79567eb12d8SRichard Henderson prt("shar\t#%d, r%d", a->imm, a->rd); 7964aea3d0cSYoshinori Sato } 7974aea3d0cSYoshinori Sato return true; 7984aea3d0cSYoshinori Sato } 7994aea3d0cSYoshinori Sato 8004aea3d0cSYoshinori Sato /* shar rs, rd */ 8014aea3d0cSYoshinori Sato static bool trans_SHAR_rr(DisasContext *ctx, arg_SHAR_rr *a) 8024aea3d0cSYoshinori Sato { 8034aea3d0cSYoshinori Sato prt("shar\tr%d, r%d", a->rs, a->rd); 8044aea3d0cSYoshinori Sato return true; 8054aea3d0cSYoshinori Sato } 8064aea3d0cSYoshinori Sato 8074aea3d0cSYoshinori Sato /* shlr #imm:5, rd */ 8084aea3d0cSYoshinori Sato /* shlr #imm:5, rs, rd */ 8094aea3d0cSYoshinori Sato static bool trans_SHLR_irr(DisasContext *ctx, arg_SHLR_irr *a) 8104aea3d0cSYoshinori Sato { 8114aea3d0cSYoshinori Sato if (a->rs2 != a->rd) { 81267eb12d8SRichard Henderson prt("shlr\t#%d, r%d, r%d", a->imm, a->rs2, a->rd); 81367eb12d8SRichard Henderson } else { 81467eb12d8SRichard Henderson prt("shlr\t#%d, r%d", a->imm, a->rd); 8154aea3d0cSYoshinori Sato } 8164aea3d0cSYoshinori Sato return true; 8174aea3d0cSYoshinori Sato } 8184aea3d0cSYoshinori Sato 8194aea3d0cSYoshinori Sato /* shlr rs, rd */ 8204aea3d0cSYoshinori Sato static bool trans_SHLR_rr(DisasContext *ctx, arg_SHLR_rr *a) 8214aea3d0cSYoshinori Sato { 8224aea3d0cSYoshinori Sato prt("shlr\tr%d, r%d", a->rs, a->rd); 8234aea3d0cSYoshinori Sato return true; 8244aea3d0cSYoshinori Sato } 8254aea3d0cSYoshinori Sato 8264aea3d0cSYoshinori Sato /* rolc rd */ 8274aea3d0cSYoshinori Sato static bool trans_ROLC(DisasContext *ctx, arg_ROLC *a) 8284aea3d0cSYoshinori Sato { 8294aea3d0cSYoshinori Sato prt("rorc\tr%d", a->rd); 8304aea3d0cSYoshinori Sato return true; 8314aea3d0cSYoshinori Sato } 8324aea3d0cSYoshinori Sato 8334aea3d0cSYoshinori Sato /* rorc rd */ 8344aea3d0cSYoshinori Sato static bool trans_RORC(DisasContext *ctx, arg_RORC *a) 8354aea3d0cSYoshinori Sato { 8364aea3d0cSYoshinori Sato prt("rorc\tr%d", a->rd); 8374aea3d0cSYoshinori Sato return true; 8384aea3d0cSYoshinori Sato } 8394aea3d0cSYoshinori Sato 8404aea3d0cSYoshinori Sato /* rotl #imm, rd */ 8414aea3d0cSYoshinori Sato static bool trans_ROTL_ir(DisasContext *ctx, arg_ROTL_ir *a) 8424aea3d0cSYoshinori Sato { 8434aea3d0cSYoshinori Sato prt("rotl\t#%d, r%d", a->imm, a->rd); 8444aea3d0cSYoshinori Sato return true; 8454aea3d0cSYoshinori Sato } 8464aea3d0cSYoshinori Sato 8474aea3d0cSYoshinori Sato /* rotl rs, rd */ 8484aea3d0cSYoshinori Sato static bool trans_ROTL_rr(DisasContext *ctx, arg_ROTL_rr *a) 8494aea3d0cSYoshinori Sato { 8504aea3d0cSYoshinori Sato prt("rotl\tr%d, r%d", a->rs, a->rd); 8514aea3d0cSYoshinori Sato return true; 8524aea3d0cSYoshinori Sato } 8534aea3d0cSYoshinori Sato 8544aea3d0cSYoshinori Sato /* rotr #imm, rd */ 8554aea3d0cSYoshinori Sato static bool trans_ROTR_ir(DisasContext *ctx, arg_ROTR_ir *a) 8564aea3d0cSYoshinori Sato { 8574aea3d0cSYoshinori Sato prt("rotr\t#%d, r%d", a->imm, a->rd); 8584aea3d0cSYoshinori Sato return true; 8594aea3d0cSYoshinori Sato } 8604aea3d0cSYoshinori Sato 8614aea3d0cSYoshinori Sato /* rotr rs, rd */ 8624aea3d0cSYoshinori Sato static bool trans_ROTR_rr(DisasContext *ctx, arg_ROTR_rr *a) 8634aea3d0cSYoshinori Sato { 8644aea3d0cSYoshinori Sato prt("rotr\tr%d, r%d", a->rs, a->rd); 8654aea3d0cSYoshinori Sato return true; 8664aea3d0cSYoshinori Sato } 8674aea3d0cSYoshinori Sato 8684aea3d0cSYoshinori Sato /* revl rs, rd */ 8694aea3d0cSYoshinori Sato static bool trans_REVL(DisasContext *ctx, arg_REVL *a) 8704aea3d0cSYoshinori Sato { 8714aea3d0cSYoshinori Sato prt("revl\tr%d, r%d", a->rs, a->rd); 8724aea3d0cSYoshinori Sato return true; 8734aea3d0cSYoshinori Sato } 8744aea3d0cSYoshinori Sato 8754aea3d0cSYoshinori Sato /* revw rs, rd */ 8764aea3d0cSYoshinori Sato static bool trans_REVW(DisasContext *ctx, arg_REVW *a) 8774aea3d0cSYoshinori Sato { 8784aea3d0cSYoshinori Sato prt("revw\tr%d, r%d", a->rs, a->rd); 8794aea3d0cSYoshinori Sato return true; 8804aea3d0cSYoshinori Sato } 8814aea3d0cSYoshinori Sato 8824aea3d0cSYoshinori Sato /* conditional branch helper */ 8834aea3d0cSYoshinori Sato static void rx_bcnd_main(DisasContext *ctx, int cd, int len, int dst) 8844aea3d0cSYoshinori Sato { 8854aea3d0cSYoshinori Sato static const char sz[] = {'s', 'b', 'w', 'a'}; 8864aea3d0cSYoshinori Sato prt("b%s.%c\t%08x", cond[cd], sz[len - 1], ctx->pc + dst); 8874aea3d0cSYoshinori Sato } 8884aea3d0cSYoshinori Sato 8894aea3d0cSYoshinori Sato /* beq dsp:3 / bne dsp:3 */ 8904aea3d0cSYoshinori Sato /* beq dsp:8 / bne dsp:8 */ 8914aea3d0cSYoshinori Sato /* bc dsp:8 / bnc dsp:8 */ 8924aea3d0cSYoshinori Sato /* bgtu dsp:8 / bleu dsp:8 */ 8934aea3d0cSYoshinori Sato /* bpz dsp:8 / bn dsp:8 */ 8944aea3d0cSYoshinori Sato /* bge dsp:8 / blt dsp:8 */ 8954aea3d0cSYoshinori Sato /* bgt dsp:8 / ble dsp:8 */ 8964aea3d0cSYoshinori Sato /* bo dsp:8 / bno dsp:8 */ 8974aea3d0cSYoshinori Sato /* beq dsp:16 / bne dsp:16 */ 8984aea3d0cSYoshinori Sato static bool trans_BCnd(DisasContext *ctx, arg_BCnd *a) 8994aea3d0cSYoshinori Sato { 9004aea3d0cSYoshinori Sato rx_bcnd_main(ctx, a->cd, a->sz, a->dsp); 9014aea3d0cSYoshinori Sato return true; 9024aea3d0cSYoshinori Sato } 9034aea3d0cSYoshinori Sato 9044aea3d0cSYoshinori Sato /* bra dsp:3 */ 9054aea3d0cSYoshinori Sato /* bra dsp:8 */ 9064aea3d0cSYoshinori Sato /* bra dsp:16 */ 9074aea3d0cSYoshinori Sato /* bra dsp:24 */ 9084aea3d0cSYoshinori Sato static bool trans_BRA(DisasContext *ctx, arg_BRA *a) 9094aea3d0cSYoshinori Sato { 9104aea3d0cSYoshinori Sato rx_bcnd_main(ctx, 14, a->sz, a->dsp); 9114aea3d0cSYoshinori Sato return true; 9124aea3d0cSYoshinori Sato } 9134aea3d0cSYoshinori Sato 9144aea3d0cSYoshinori Sato /* bra rs */ 9154aea3d0cSYoshinori Sato static bool trans_BRA_l(DisasContext *ctx, arg_BRA_l *a) 9164aea3d0cSYoshinori Sato { 9174aea3d0cSYoshinori Sato prt("bra.l\tr%d", a->rd); 9184aea3d0cSYoshinori Sato return true; 9194aea3d0cSYoshinori Sato } 9204aea3d0cSYoshinori Sato 9214aea3d0cSYoshinori Sato /* jmp rs */ 9224aea3d0cSYoshinori Sato static bool trans_JMP(DisasContext *ctx, arg_JMP *a) 9234aea3d0cSYoshinori Sato { 9244aea3d0cSYoshinori Sato prt("jmp\tr%d", a->rs); 9254aea3d0cSYoshinori Sato return true; 9264aea3d0cSYoshinori Sato } 9274aea3d0cSYoshinori Sato 9284aea3d0cSYoshinori Sato /* jsr rs */ 9294aea3d0cSYoshinori Sato static bool trans_JSR(DisasContext *ctx, arg_JSR *a) 9304aea3d0cSYoshinori Sato { 9314aea3d0cSYoshinori Sato prt("jsr\tr%d", a->rs); 9324aea3d0cSYoshinori Sato return true; 9334aea3d0cSYoshinori Sato } 9344aea3d0cSYoshinori Sato 9354aea3d0cSYoshinori Sato /* bsr dsp:16 */ 9364aea3d0cSYoshinori Sato /* bsr dsp:24 */ 9374aea3d0cSYoshinori Sato static bool trans_BSR(DisasContext *ctx, arg_BSR *a) 9384aea3d0cSYoshinori Sato { 9394aea3d0cSYoshinori Sato static const char sz[] = {'w', 'a'}; 9404aea3d0cSYoshinori Sato prt("bsr.%c\t%08x", sz[a->sz - 3], ctx->pc + a->dsp); 9414aea3d0cSYoshinori Sato return true; 9424aea3d0cSYoshinori Sato } 9434aea3d0cSYoshinori Sato 9444aea3d0cSYoshinori Sato /* bsr rs */ 9454aea3d0cSYoshinori Sato static bool trans_BSR_l(DisasContext *ctx, arg_BSR_l *a) 9464aea3d0cSYoshinori Sato { 9474aea3d0cSYoshinori Sato prt("bsr.l\tr%d", a->rd); 9484aea3d0cSYoshinori Sato return true; 9494aea3d0cSYoshinori Sato } 9504aea3d0cSYoshinori Sato 9514aea3d0cSYoshinori Sato /* rts */ 9524aea3d0cSYoshinori Sato static bool trans_RTS(DisasContext *ctx, arg_RTS *a) 9534aea3d0cSYoshinori Sato { 9544aea3d0cSYoshinori Sato prt("rts"); 9554aea3d0cSYoshinori Sato return true; 9564aea3d0cSYoshinori Sato } 9574aea3d0cSYoshinori Sato 9584aea3d0cSYoshinori Sato /* nop */ 9594aea3d0cSYoshinori Sato static bool trans_NOP(DisasContext *ctx, arg_NOP *a) 9604aea3d0cSYoshinori Sato { 9614aea3d0cSYoshinori Sato prt("nop"); 9624aea3d0cSYoshinori Sato return true; 9634aea3d0cSYoshinori Sato } 9644aea3d0cSYoshinori Sato 9654aea3d0cSYoshinori Sato /* scmpu */ 9664aea3d0cSYoshinori Sato static bool trans_SCMPU(DisasContext *ctx, arg_SCMPU *a) 9674aea3d0cSYoshinori Sato { 9684aea3d0cSYoshinori Sato prt("scmpu"); 9694aea3d0cSYoshinori Sato return true; 9704aea3d0cSYoshinori Sato } 9714aea3d0cSYoshinori Sato 9724aea3d0cSYoshinori Sato /* smovu */ 9734aea3d0cSYoshinori Sato static bool trans_SMOVU(DisasContext *ctx, arg_SMOVU *a) 9744aea3d0cSYoshinori Sato { 9754aea3d0cSYoshinori Sato prt("smovu"); 9764aea3d0cSYoshinori Sato return true; 9774aea3d0cSYoshinori Sato } 9784aea3d0cSYoshinori Sato 9794aea3d0cSYoshinori Sato /* smovf */ 9804aea3d0cSYoshinori Sato static bool trans_SMOVF(DisasContext *ctx, arg_SMOVF *a) 9814aea3d0cSYoshinori Sato { 9824aea3d0cSYoshinori Sato prt("smovf"); 9834aea3d0cSYoshinori Sato return true; 9844aea3d0cSYoshinori Sato } 9854aea3d0cSYoshinori Sato 9864aea3d0cSYoshinori Sato /* smovb */ 9874aea3d0cSYoshinori Sato static bool trans_SMOVB(DisasContext *ctx, arg_SMOVB *a) 9884aea3d0cSYoshinori Sato { 9894aea3d0cSYoshinori Sato prt("smovb"); 9904aea3d0cSYoshinori Sato return true; 9914aea3d0cSYoshinori Sato } 9924aea3d0cSYoshinori Sato 9934aea3d0cSYoshinori Sato /* suntile */ 9944aea3d0cSYoshinori Sato static bool trans_SUNTIL(DisasContext *ctx, arg_SUNTIL *a) 9954aea3d0cSYoshinori Sato { 9964aea3d0cSYoshinori Sato prt("suntil.%c", size[a->sz]); 9974aea3d0cSYoshinori Sato return true; 9984aea3d0cSYoshinori Sato } 9994aea3d0cSYoshinori Sato 10004aea3d0cSYoshinori Sato /* swhile */ 10014aea3d0cSYoshinori Sato static bool trans_SWHILE(DisasContext *ctx, arg_SWHILE *a) 10024aea3d0cSYoshinori Sato { 10034aea3d0cSYoshinori Sato prt("swhile.%c", size[a->sz]); 10044aea3d0cSYoshinori Sato return true; 10054aea3d0cSYoshinori Sato } 10064aea3d0cSYoshinori Sato /* sstr */ 10074aea3d0cSYoshinori Sato static bool trans_SSTR(DisasContext *ctx, arg_SSTR *a) 10084aea3d0cSYoshinori Sato { 10094aea3d0cSYoshinori Sato prt("sstr.%c", size[a->sz]); 10104aea3d0cSYoshinori Sato return true; 10114aea3d0cSYoshinori Sato } 10124aea3d0cSYoshinori Sato 10134aea3d0cSYoshinori Sato /* rmpa */ 10144aea3d0cSYoshinori Sato static bool trans_RMPA(DisasContext *ctx, arg_RMPA *a) 10154aea3d0cSYoshinori Sato { 10164aea3d0cSYoshinori Sato prt("rmpa.%c", size[a->sz]); 10174aea3d0cSYoshinori Sato return true; 10184aea3d0cSYoshinori Sato } 10194aea3d0cSYoshinori Sato 10204aea3d0cSYoshinori Sato /* mulhi rs,rs2 */ 10214aea3d0cSYoshinori Sato static bool trans_MULHI(DisasContext *ctx, arg_MULHI *a) 10224aea3d0cSYoshinori Sato { 10234aea3d0cSYoshinori Sato prt("mulhi\tr%d,r%d", a->rs, a->rs2); 10244aea3d0cSYoshinori Sato return true; 10254aea3d0cSYoshinori Sato } 10264aea3d0cSYoshinori Sato 10274aea3d0cSYoshinori Sato /* mullo rs,rs2 */ 10284aea3d0cSYoshinori Sato static bool trans_MULLO(DisasContext *ctx, arg_MULLO *a) 10294aea3d0cSYoshinori Sato { 10304aea3d0cSYoshinori Sato prt("mullo\tr%d, r%d", a->rs, a->rs2); 10314aea3d0cSYoshinori Sato return true; 10324aea3d0cSYoshinori Sato } 10334aea3d0cSYoshinori Sato 10344aea3d0cSYoshinori Sato /* machi rs,rs2 */ 10354aea3d0cSYoshinori Sato static bool trans_MACHI(DisasContext *ctx, arg_MACHI *a) 10364aea3d0cSYoshinori Sato { 10374aea3d0cSYoshinori Sato prt("machi\tr%d, r%d", a->rs, a->rs2); 10384aea3d0cSYoshinori Sato return true; 10394aea3d0cSYoshinori Sato } 10404aea3d0cSYoshinori Sato 10414aea3d0cSYoshinori Sato /* maclo rs,rs2 */ 10424aea3d0cSYoshinori Sato static bool trans_MACLO(DisasContext *ctx, arg_MACLO *a) 10434aea3d0cSYoshinori Sato { 10444aea3d0cSYoshinori Sato prt("maclo\tr%d, r%d", a->rs, a->rs2); 10454aea3d0cSYoshinori Sato return true; 10464aea3d0cSYoshinori Sato } 10474aea3d0cSYoshinori Sato 10484aea3d0cSYoshinori Sato /* mvfachi rd */ 10494aea3d0cSYoshinori Sato static bool trans_MVFACHI(DisasContext *ctx, arg_MVFACHI *a) 10504aea3d0cSYoshinori Sato { 10514aea3d0cSYoshinori Sato prt("mvfachi\tr%d", a->rd); 10524aea3d0cSYoshinori Sato return true; 10534aea3d0cSYoshinori Sato } 10544aea3d0cSYoshinori Sato 10554aea3d0cSYoshinori Sato /* mvfacmi rd */ 10564aea3d0cSYoshinori Sato static bool trans_MVFACMI(DisasContext *ctx, arg_MVFACMI *a) 10574aea3d0cSYoshinori Sato { 10584aea3d0cSYoshinori Sato prt("mvfacmi\tr%d", a->rd); 10594aea3d0cSYoshinori Sato return true; 10604aea3d0cSYoshinori Sato } 10614aea3d0cSYoshinori Sato 10624aea3d0cSYoshinori Sato /* mvtachi rs */ 10634aea3d0cSYoshinori Sato static bool trans_MVTACHI(DisasContext *ctx, arg_MVTACHI *a) 10644aea3d0cSYoshinori Sato { 10654aea3d0cSYoshinori Sato prt("mvtachi\tr%d", a->rs); 10664aea3d0cSYoshinori Sato return true; 10674aea3d0cSYoshinori Sato } 10684aea3d0cSYoshinori Sato 10694aea3d0cSYoshinori Sato /* mvtaclo rs */ 10704aea3d0cSYoshinori Sato static bool trans_MVTACLO(DisasContext *ctx, arg_MVTACLO *a) 10714aea3d0cSYoshinori Sato { 10724aea3d0cSYoshinori Sato prt("mvtaclo\tr%d", a->rs); 10734aea3d0cSYoshinori Sato return true; 10744aea3d0cSYoshinori Sato } 10754aea3d0cSYoshinori Sato 10764aea3d0cSYoshinori Sato /* racw #imm */ 10774aea3d0cSYoshinori Sato static bool trans_RACW(DisasContext *ctx, arg_RACW *a) 10784aea3d0cSYoshinori Sato { 10794aea3d0cSYoshinori Sato prt("racw\t#%d", a->imm + 1); 10804aea3d0cSYoshinori Sato return true; 10814aea3d0cSYoshinori Sato } 10824aea3d0cSYoshinori Sato 10834aea3d0cSYoshinori Sato /* sat rd */ 10844aea3d0cSYoshinori Sato static bool trans_SAT(DisasContext *ctx, arg_SAT *a) 10854aea3d0cSYoshinori Sato { 10864aea3d0cSYoshinori Sato prt("sat\tr%d", a->rd); 10874aea3d0cSYoshinori Sato return true; 10884aea3d0cSYoshinori Sato } 10894aea3d0cSYoshinori Sato 10904aea3d0cSYoshinori Sato /* satr */ 10914aea3d0cSYoshinori Sato static bool trans_SATR(DisasContext *ctx, arg_SATR *a) 10924aea3d0cSYoshinori Sato { 10934aea3d0cSYoshinori Sato prt("satr"); 10944aea3d0cSYoshinori Sato return true; 10954aea3d0cSYoshinori Sato } 10964aea3d0cSYoshinori Sato 10974aea3d0cSYoshinori Sato /* fadd #imm, rd */ 10984aea3d0cSYoshinori Sato static bool trans_FADD_ir(DisasContext *ctx, arg_FADD_ir *a) 10994aea3d0cSYoshinori Sato { 11004aea3d0cSYoshinori Sato prt("fadd\t#%d,r%d", li(ctx, 0), a->rd); 11014aea3d0cSYoshinori Sato return true; 11024aea3d0cSYoshinori Sato } 11034aea3d0cSYoshinori Sato 11044aea3d0cSYoshinori Sato /* fadd dsp[rs], rd */ 11054aea3d0cSYoshinori Sato /* fadd rs, rd */ 11064aea3d0cSYoshinori Sato static bool trans_FADD_mr(DisasContext *ctx, arg_FADD_mr *a) 11074aea3d0cSYoshinori Sato { 1108e283adeaSRichard Henderson prt_ldmi(ctx, "fadd", a->ld, RX_IM_LONG, a->rs, a->rd); 11094aea3d0cSYoshinori Sato return true; 11104aea3d0cSYoshinori Sato } 11114aea3d0cSYoshinori Sato 11124aea3d0cSYoshinori Sato /* fcmp #imm, rd */ 11134aea3d0cSYoshinori Sato static bool trans_FCMP_ir(DisasContext *ctx, arg_FCMP_ir *a) 11144aea3d0cSYoshinori Sato { 11154aea3d0cSYoshinori Sato prt("fadd\t#%d,r%d", li(ctx, 0), a->rd); 11164aea3d0cSYoshinori Sato return true; 11174aea3d0cSYoshinori Sato } 11184aea3d0cSYoshinori Sato 11194aea3d0cSYoshinori Sato /* fcmp dsp[rs], rd */ 11204aea3d0cSYoshinori Sato /* fcmp rs, rd */ 11214aea3d0cSYoshinori Sato static bool trans_FCMP_mr(DisasContext *ctx, arg_FCMP_mr *a) 11224aea3d0cSYoshinori Sato { 1123e283adeaSRichard Henderson prt_ldmi(ctx, "fcmp", a->ld, RX_IM_LONG, a->rs, a->rd); 11244aea3d0cSYoshinori Sato return true; 11254aea3d0cSYoshinori Sato } 11264aea3d0cSYoshinori Sato 11274aea3d0cSYoshinori Sato /* fsub #imm, rd */ 11284aea3d0cSYoshinori Sato static bool trans_FSUB_ir(DisasContext *ctx, arg_FSUB_ir *a) 11294aea3d0cSYoshinori Sato { 11304aea3d0cSYoshinori Sato prt("fsub\t#%d,r%d", li(ctx, 0), a->rd); 11314aea3d0cSYoshinori Sato return true; 11324aea3d0cSYoshinori Sato } 11334aea3d0cSYoshinori Sato 11344aea3d0cSYoshinori Sato /* fsub dsp[rs], rd */ 11354aea3d0cSYoshinori Sato /* fsub rs, rd */ 11364aea3d0cSYoshinori Sato static bool trans_FSUB_mr(DisasContext *ctx, arg_FSUB_mr *a) 11374aea3d0cSYoshinori Sato { 1138e283adeaSRichard Henderson prt_ldmi(ctx, "fsub", a->ld, RX_IM_LONG, a->rs, a->rd); 11394aea3d0cSYoshinori Sato return true; 11404aea3d0cSYoshinori Sato } 11414aea3d0cSYoshinori Sato 11424aea3d0cSYoshinori Sato /* ftoi dsp[rs], rd */ 11434aea3d0cSYoshinori Sato /* ftoi rs, rd */ 11444aea3d0cSYoshinori Sato static bool trans_FTOI(DisasContext *ctx, arg_FTOI *a) 11454aea3d0cSYoshinori Sato { 1146e283adeaSRichard Henderson prt_ldmi(ctx, "ftoi", a->ld, RX_IM_LONG, a->rs, a->rd); 11474aea3d0cSYoshinori Sato return true; 11484aea3d0cSYoshinori Sato } 11494aea3d0cSYoshinori Sato 11504aea3d0cSYoshinori Sato /* fmul #imm, rd */ 11514aea3d0cSYoshinori Sato static bool trans_FMUL_ir(DisasContext *ctx, arg_FMUL_ir *a) 11524aea3d0cSYoshinori Sato { 11534aea3d0cSYoshinori Sato prt("fmul\t#%d,r%d", li(ctx, 0), a->rd); 11544aea3d0cSYoshinori Sato return true; 11554aea3d0cSYoshinori Sato } 11564aea3d0cSYoshinori Sato 11574aea3d0cSYoshinori Sato /* fmul dsp[rs], rd */ 11584aea3d0cSYoshinori Sato /* fmul rs, rd */ 11594aea3d0cSYoshinori Sato static bool trans_FMUL_mr(DisasContext *ctx, arg_FMUL_mr *a) 11604aea3d0cSYoshinori Sato { 1161e283adeaSRichard Henderson prt_ldmi(ctx, "fmul", a->ld, RX_IM_LONG, a->rs, a->rd); 11624aea3d0cSYoshinori Sato return true; 11634aea3d0cSYoshinori Sato } 11644aea3d0cSYoshinori Sato 11654aea3d0cSYoshinori Sato /* fdiv #imm, rd */ 11664aea3d0cSYoshinori Sato static bool trans_FDIV_ir(DisasContext *ctx, arg_FDIV_ir *a) 11674aea3d0cSYoshinori Sato { 11684aea3d0cSYoshinori Sato prt("fdiv\t#%d,r%d", li(ctx, 0), a->rd); 11694aea3d0cSYoshinori Sato return true; 11704aea3d0cSYoshinori Sato } 11714aea3d0cSYoshinori Sato 11724aea3d0cSYoshinori Sato /* fdiv dsp[rs], rd */ 11734aea3d0cSYoshinori Sato /* fdiv rs, rd */ 11744aea3d0cSYoshinori Sato static bool trans_FDIV_mr(DisasContext *ctx, arg_FDIV_mr *a) 11754aea3d0cSYoshinori Sato { 1176e283adeaSRichard Henderson prt_ldmi(ctx, "fdiv", a->ld, RX_IM_LONG, a->rs, a->rd); 11774aea3d0cSYoshinori Sato return true; 11784aea3d0cSYoshinori Sato } 11794aea3d0cSYoshinori Sato 11804aea3d0cSYoshinori Sato /* round dsp[rs], rd */ 11814aea3d0cSYoshinori Sato /* round rs, rd */ 11824aea3d0cSYoshinori Sato static bool trans_ROUND(DisasContext *ctx, arg_ROUND *a) 11834aea3d0cSYoshinori Sato { 1184e283adeaSRichard Henderson prt_ldmi(ctx, "round", a->ld, RX_IM_LONG, a->rs, a->rd); 11854aea3d0cSYoshinori Sato return true; 11864aea3d0cSYoshinori Sato } 11874aea3d0cSYoshinori Sato 11884aea3d0cSYoshinori Sato /* itof rs, rd */ 11894aea3d0cSYoshinori Sato /* itof dsp[rs], rd */ 11904aea3d0cSYoshinori Sato static bool trans_ITOF(DisasContext *ctx, arg_ITOF *a) 11914aea3d0cSYoshinori Sato { 1192e283adeaSRichard Henderson prt_ldmi(ctx, "itof", a->ld, RX_IM_LONG, a->rs, a->rd); 11934aea3d0cSYoshinori Sato return true; 11944aea3d0cSYoshinori Sato } 11954aea3d0cSYoshinori Sato 11964aea3d0cSYoshinori Sato #define BOP_IM(name, reg) \ 11974aea3d0cSYoshinori Sato do { \ 1198fa6289e2SRichard Henderson char dsp[8]; \ 1199fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE); \ 1200fa6289e2SRichard Henderson prt("b%s\t#%d, %s[r%d]", #name, a->imm, dsp, reg); \ 12014aea3d0cSYoshinori Sato return true; \ 12024aea3d0cSYoshinori Sato } while (0) 12034aea3d0cSYoshinori Sato 12044aea3d0cSYoshinori Sato #define BOP_RM(name) \ 12054aea3d0cSYoshinori Sato do { \ 1206fa6289e2SRichard Henderson char dsp[8]; \ 1207fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE); \ 1208fa6289e2SRichard Henderson prt("b%s\tr%d, %s[r%d]", #name, a->rd, dsp, a->rs); \ 12094aea3d0cSYoshinori Sato return true; \ 12104aea3d0cSYoshinori Sato } while (0) 12114aea3d0cSYoshinori Sato 12124aea3d0cSYoshinori Sato /* bset #imm, dsp[rd] */ 12134aea3d0cSYoshinori Sato static bool trans_BSET_im(DisasContext *ctx, arg_BSET_im *a) 12144aea3d0cSYoshinori Sato { 12154aea3d0cSYoshinori Sato BOP_IM(bset, a->rs); 12164aea3d0cSYoshinori Sato } 12174aea3d0cSYoshinori Sato 12184aea3d0cSYoshinori Sato /* bset rs, dsp[rd] */ 12194aea3d0cSYoshinori Sato static bool trans_BSET_rm(DisasContext *ctx, arg_BSET_rm *a) 12204aea3d0cSYoshinori Sato { 12214aea3d0cSYoshinori Sato BOP_RM(set); 12224aea3d0cSYoshinori Sato } 12234aea3d0cSYoshinori Sato 12244aea3d0cSYoshinori Sato /* bset rs, rd */ 12254aea3d0cSYoshinori Sato static bool trans_BSET_rr(DisasContext *ctx, arg_BSET_rr *a) 12264aea3d0cSYoshinori Sato { 12274aea3d0cSYoshinori Sato prt("bset\tr%d,r%d", a->rs, a->rd); 12284aea3d0cSYoshinori Sato return true; 12294aea3d0cSYoshinori Sato } 12304aea3d0cSYoshinori Sato 12314aea3d0cSYoshinori Sato /* bset #imm, rd */ 12324aea3d0cSYoshinori Sato static bool trans_BSET_ir(DisasContext *ctx, arg_BSET_ir *a) 12334aea3d0cSYoshinori Sato { 12344aea3d0cSYoshinori Sato prt("bset\t#%d, r%d", a->imm, a->rd); 12354aea3d0cSYoshinori Sato return true; 12364aea3d0cSYoshinori Sato } 12374aea3d0cSYoshinori Sato 12384aea3d0cSYoshinori Sato /* bclr #imm, dsp[rd] */ 12394aea3d0cSYoshinori Sato static bool trans_BCLR_im(DisasContext *ctx, arg_BCLR_im *a) 12404aea3d0cSYoshinori Sato { 12414aea3d0cSYoshinori Sato BOP_IM(clr, a->rs); 12424aea3d0cSYoshinori Sato } 12434aea3d0cSYoshinori Sato 12444aea3d0cSYoshinori Sato /* bclr rs, dsp[rd] */ 12454aea3d0cSYoshinori Sato static bool trans_BCLR_rm(DisasContext *ctx, arg_BCLR_rm *a) 12464aea3d0cSYoshinori Sato { 12474aea3d0cSYoshinori Sato BOP_RM(clr); 12484aea3d0cSYoshinori Sato } 12494aea3d0cSYoshinori Sato 12504aea3d0cSYoshinori Sato /* bclr rs, rd */ 12514aea3d0cSYoshinori Sato static bool trans_BCLR_rr(DisasContext *ctx, arg_BCLR_rr *a) 12524aea3d0cSYoshinori Sato { 12534aea3d0cSYoshinori Sato prt("bclr\tr%d, r%d", a->rs, a->rd); 12544aea3d0cSYoshinori Sato return true; 12554aea3d0cSYoshinori Sato } 12564aea3d0cSYoshinori Sato 12574aea3d0cSYoshinori Sato /* bclr #imm, rd */ 12584aea3d0cSYoshinori Sato static bool trans_BCLR_ir(DisasContext *ctx, arg_BCLR_ir *a) 12594aea3d0cSYoshinori Sato { 12604aea3d0cSYoshinori Sato prt("bclr\t#%d,r%d", a->imm, a->rd); 12614aea3d0cSYoshinori Sato return true; 12624aea3d0cSYoshinori Sato } 12634aea3d0cSYoshinori Sato 12644aea3d0cSYoshinori Sato /* btst #imm, dsp[rd] */ 12654aea3d0cSYoshinori Sato static bool trans_BTST_im(DisasContext *ctx, arg_BTST_im *a) 12664aea3d0cSYoshinori Sato { 12674aea3d0cSYoshinori Sato BOP_IM(tst, a->rs); 12684aea3d0cSYoshinori Sato } 12694aea3d0cSYoshinori Sato 12704aea3d0cSYoshinori Sato /* btst rs, dsp[rd] */ 12714aea3d0cSYoshinori Sato static bool trans_BTST_rm(DisasContext *ctx, arg_BTST_rm *a) 12724aea3d0cSYoshinori Sato { 12734aea3d0cSYoshinori Sato BOP_RM(tst); 12744aea3d0cSYoshinori Sato } 12754aea3d0cSYoshinori Sato 12764aea3d0cSYoshinori Sato /* btst rs, rd */ 12774aea3d0cSYoshinori Sato static bool trans_BTST_rr(DisasContext *ctx, arg_BTST_rr *a) 12784aea3d0cSYoshinori Sato { 12794aea3d0cSYoshinori Sato prt("btst\tr%d, r%d", a->rs, a->rd); 12804aea3d0cSYoshinori Sato return true; 12814aea3d0cSYoshinori Sato } 12824aea3d0cSYoshinori Sato 12834aea3d0cSYoshinori Sato /* btst #imm, rd */ 12844aea3d0cSYoshinori Sato static bool trans_BTST_ir(DisasContext *ctx, arg_BTST_ir *a) 12854aea3d0cSYoshinori Sato { 12864aea3d0cSYoshinori Sato prt("btst\t#%d, r%d", a->imm, a->rd); 12874aea3d0cSYoshinori Sato return true; 12884aea3d0cSYoshinori Sato } 12894aea3d0cSYoshinori Sato 12904aea3d0cSYoshinori Sato /* bnot rs, dsp[rd] */ 12914aea3d0cSYoshinori Sato static bool trans_BNOT_rm(DisasContext *ctx, arg_BNOT_rm *a) 12924aea3d0cSYoshinori Sato { 12934aea3d0cSYoshinori Sato BOP_RM(not); 12944aea3d0cSYoshinori Sato } 12954aea3d0cSYoshinori Sato 12964aea3d0cSYoshinori Sato /* bnot rs, rd */ 12974aea3d0cSYoshinori Sato static bool trans_BNOT_rr(DisasContext *ctx, arg_BNOT_rr *a) 12984aea3d0cSYoshinori Sato { 12994aea3d0cSYoshinori Sato prt("bnot\tr%d, r%d", a->rs, a->rd); 13004aea3d0cSYoshinori Sato return true; 13014aea3d0cSYoshinori Sato } 13024aea3d0cSYoshinori Sato 13034aea3d0cSYoshinori Sato /* bnot #imm, dsp[rd] */ 13044aea3d0cSYoshinori Sato static bool trans_BNOT_im(DisasContext *ctx, arg_BNOT_im *a) 13054aea3d0cSYoshinori Sato { 13064aea3d0cSYoshinori Sato BOP_IM(not, a->rs); 13074aea3d0cSYoshinori Sato } 13084aea3d0cSYoshinori Sato 13094aea3d0cSYoshinori Sato /* bnot #imm, rd */ 13104aea3d0cSYoshinori Sato static bool trans_BNOT_ir(DisasContext *ctx, arg_BNOT_ir *a) 13114aea3d0cSYoshinori Sato { 13124aea3d0cSYoshinori Sato prt("bnot\t#%d, r%d", a->imm, a->rd); 13134aea3d0cSYoshinori Sato return true; 13144aea3d0cSYoshinori Sato } 13154aea3d0cSYoshinori Sato 13164aea3d0cSYoshinori Sato /* bmcond #imm, dsp[rd] */ 13174aea3d0cSYoshinori Sato static bool trans_BMCnd_im(DisasContext *ctx, arg_BMCnd_im *a) 13184aea3d0cSYoshinori Sato { 1319fa6289e2SRichard Henderson char dsp[8]; 1320fa6289e2SRichard Henderson 1321fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE); 1322fa6289e2SRichard Henderson prt("bm%s\t#%d, %s[r%d]", cond[a->cd], a->imm, dsp, a->rd); 13234aea3d0cSYoshinori Sato return true; 13244aea3d0cSYoshinori Sato } 13254aea3d0cSYoshinori Sato 13264aea3d0cSYoshinori Sato /* bmcond #imm, rd */ 13274aea3d0cSYoshinori Sato static bool trans_BMCnd_ir(DisasContext *ctx, arg_BMCnd_ir *a) 13284aea3d0cSYoshinori Sato { 13294aea3d0cSYoshinori Sato prt("bm%s\t#%d, r%d", cond[a->cd], a->imm, a->rd); 13304aea3d0cSYoshinori Sato return true; 13314aea3d0cSYoshinori Sato } 13324aea3d0cSYoshinori Sato 13334aea3d0cSYoshinori Sato /* clrpsw psw */ 13344aea3d0cSYoshinori Sato static bool trans_CLRPSW(DisasContext *ctx, arg_CLRPSW *a) 13354aea3d0cSYoshinori Sato { 13364aea3d0cSYoshinori Sato prt("clrpsw\t%c", psw[a->cb]); 13374aea3d0cSYoshinori Sato return true; 13384aea3d0cSYoshinori Sato } 13394aea3d0cSYoshinori Sato 13404aea3d0cSYoshinori Sato /* setpsw psw */ 13414aea3d0cSYoshinori Sato static bool trans_SETPSW(DisasContext *ctx, arg_SETPSW *a) 13424aea3d0cSYoshinori Sato { 13434aea3d0cSYoshinori Sato prt("setpsw\t%c", psw[a->cb]); 13444aea3d0cSYoshinori Sato return true; 13454aea3d0cSYoshinori Sato } 13464aea3d0cSYoshinori Sato 13474aea3d0cSYoshinori Sato /* mvtipl #imm */ 13484aea3d0cSYoshinori Sato static bool trans_MVTIPL(DisasContext *ctx, arg_MVTIPL *a) 13494aea3d0cSYoshinori Sato { 13504aea3d0cSYoshinori Sato prt("movtipl\t#%d", a->imm); 13514aea3d0cSYoshinori Sato return true; 13524aea3d0cSYoshinori Sato } 13534aea3d0cSYoshinori Sato 13544aea3d0cSYoshinori Sato /* mvtc #imm, rd */ 13554aea3d0cSYoshinori Sato static bool trans_MVTC_i(DisasContext *ctx, arg_MVTC_i *a) 13564aea3d0cSYoshinori Sato { 13574aea3d0cSYoshinori Sato prt("mvtc\t#0x%08x, %s", a->imm, rx_crname(a->cr)); 13584aea3d0cSYoshinori Sato return true; 13594aea3d0cSYoshinori Sato } 13604aea3d0cSYoshinori Sato 13614aea3d0cSYoshinori Sato /* mvtc rs, rd */ 13624aea3d0cSYoshinori Sato static bool trans_MVTC_r(DisasContext *ctx, arg_MVTC_r *a) 13634aea3d0cSYoshinori Sato { 13644aea3d0cSYoshinori Sato prt("mvtc\tr%d, %s", a->rs, rx_crname(a->cr)); 13654aea3d0cSYoshinori Sato return true; 13664aea3d0cSYoshinori Sato } 13674aea3d0cSYoshinori Sato 13684aea3d0cSYoshinori Sato /* mvfc rs, rd */ 13694aea3d0cSYoshinori Sato static bool trans_MVFC(DisasContext *ctx, arg_MVFC *a) 13704aea3d0cSYoshinori Sato { 13714aea3d0cSYoshinori Sato prt("mvfc\t%s, r%d", rx_crname(a->cr), a->rd); 13724aea3d0cSYoshinori Sato return true; 13734aea3d0cSYoshinori Sato } 13744aea3d0cSYoshinori Sato 13754aea3d0cSYoshinori Sato /* rtfi */ 13764aea3d0cSYoshinori Sato static bool trans_RTFI(DisasContext *ctx, arg_RTFI *a) 13774aea3d0cSYoshinori Sato { 13784aea3d0cSYoshinori Sato prt("rtfi"); 13794aea3d0cSYoshinori Sato return true; 13804aea3d0cSYoshinori Sato } 13814aea3d0cSYoshinori Sato 13824aea3d0cSYoshinori Sato /* rte */ 13834aea3d0cSYoshinori Sato static bool trans_RTE(DisasContext *ctx, arg_RTE *a) 13844aea3d0cSYoshinori Sato { 13854aea3d0cSYoshinori Sato prt("rte"); 13864aea3d0cSYoshinori Sato return true; 13874aea3d0cSYoshinori Sato } 13884aea3d0cSYoshinori Sato 13894aea3d0cSYoshinori Sato /* brk */ 13904aea3d0cSYoshinori Sato static bool trans_BRK(DisasContext *ctx, arg_BRK *a) 13914aea3d0cSYoshinori Sato { 13924aea3d0cSYoshinori Sato prt("brk"); 13934aea3d0cSYoshinori Sato return true; 13944aea3d0cSYoshinori Sato } 13954aea3d0cSYoshinori Sato 13964aea3d0cSYoshinori Sato /* int #imm */ 13974aea3d0cSYoshinori Sato static bool trans_INT(DisasContext *ctx, arg_INT *a) 13984aea3d0cSYoshinori Sato { 13994aea3d0cSYoshinori Sato prt("int\t#%d", a->imm); 14004aea3d0cSYoshinori Sato return true; 14014aea3d0cSYoshinori Sato } 14024aea3d0cSYoshinori Sato 14034aea3d0cSYoshinori Sato /* wait */ 14044aea3d0cSYoshinori Sato static bool trans_WAIT(DisasContext *ctx, arg_WAIT *a) 14054aea3d0cSYoshinori Sato { 14064aea3d0cSYoshinori Sato prt("wait"); 14074aea3d0cSYoshinori Sato return true; 14084aea3d0cSYoshinori Sato } 14094aea3d0cSYoshinori Sato 14104aea3d0cSYoshinori Sato /* sccnd.[bwl] rd */ 14114aea3d0cSYoshinori Sato /* sccnd.[bwl] dsp:[rd] */ 14124aea3d0cSYoshinori Sato static bool trans_SCCnd(DisasContext *ctx, arg_SCCnd *a) 14134aea3d0cSYoshinori Sato { 14144aea3d0cSYoshinori Sato if (a->ld < 3) { 1415fa6289e2SRichard Henderson char dsp[8]; 1416fa6289e2SRichard Henderson rx_index_addr(ctx, dsp, a->sz, a->ld); 1417fa6289e2SRichard Henderson prt("sc%s.%c\t%s[r%d]", cond[a->cd], size[a->sz], dsp, a->rd); 14184aea3d0cSYoshinori Sato } else { 1419fa6289e2SRichard Henderson prt("sc%s.%c\tr%d", cond[a->cd], size[a->sz], a->rd); 14204aea3d0cSYoshinori Sato } 14214aea3d0cSYoshinori Sato return true; 14224aea3d0cSYoshinori Sato } 14234aea3d0cSYoshinori Sato 14244aea3d0cSYoshinori Sato int print_insn_rx(bfd_vma addr, disassemble_info *dis) 14254aea3d0cSYoshinori Sato { 14264aea3d0cSYoshinori Sato DisasContext ctx; 14274aea3d0cSYoshinori Sato uint32_t insn; 14284aea3d0cSYoshinori Sato int i; 142905a8599fSRichard Henderson 14304aea3d0cSYoshinori Sato ctx.dis = dis; 14314aea3d0cSYoshinori Sato ctx.pc = ctx.addr = addr; 143205a8599fSRichard Henderson ctx.len = 0; 14334aea3d0cSYoshinori Sato 14344aea3d0cSYoshinori Sato insn = decode_load(&ctx); 14354aea3d0cSYoshinori Sato if (!decode(&ctx, insn)) { 14364aea3d0cSYoshinori Sato ctx.dis->fprintf_func(ctx.dis->stream, ".byte\t"); 14374aea3d0cSYoshinori Sato for (i = 0; i < ctx.addr - addr; i++) { 14384aea3d0cSYoshinori Sato if (i > 0) { 14394aea3d0cSYoshinori Sato ctx.dis->fprintf_func(ctx.dis->stream, ","); 14404aea3d0cSYoshinori Sato } 14414aea3d0cSYoshinori Sato ctx.dis->fprintf_func(ctx.dis->stream, "0x%02x", insn >> 24); 14424aea3d0cSYoshinori Sato insn <<= 8; 14434aea3d0cSYoshinori Sato } 14444aea3d0cSYoshinori Sato } 14454aea3d0cSYoshinori Sato return ctx.addr - addr; 14464aea3d0cSYoshinori Sato } 1447