target/rx/disas.c

   1 /*
   2  * Renesas RX Disassembler
   3  *
   4  * Copyright (c) 2019 Yoshinori Sato <[email protected]>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2 or later, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "qemu/osdep.h"
  20 #include "disas/dis-asm.h"
  21 #include "qemu/bitops.h"
  22 #include "cpu.h"
  23
  24 typedef struct DisasContext {
  25     disassemble_info *dis;
  26     uint32_t addr;
  27     uint32_t pc;
  28     uint8_t len;
  29     uint8_t bytes[8];
  30 } DisasContext;
  31
  32
  33 static uint32_t decode_load_bytes(DisasContext *ctx, uint32_t insn,
  34                                   int i, int n)
  35 {
  36     uint32_t addr = ctx->addr;
  37
  38     g_assert(ctx->len == i);
  39     g_assert(n <= ARRAY_SIZE(ctx->bytes));
  40
  41     while (++i <= n) {
  42         ctx->dis->read_memory_func(addr++, &ctx->bytes[i - 1], 1, ctx->dis);
  43         insn |= ctx->bytes[i - 1] << (32 - i * 8);
  44     }
  45     ctx->addr = addr;
  46     ctx->len = n;
  47
  48     return insn;
  49 }
  50
  51 static int32_t li(DisasContext *ctx, int sz)
  52 {
  53     uint32_t addr = ctx->addr;
  54     uintptr_t len = ctx->len;
  55
  56     switch (sz) {
  57     case 1:
  58         g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes));
  59         ctx->addr += 1;
  60         ctx->len += 1;
  61         ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis);
  62         return (int8_t)ctx->bytes[len];
  63     case 2:
  64         g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes));
  65         ctx->addr += 2;
  66         ctx->len += 2;
  67         ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis);
  68         return ldsw_le_p(ctx->bytes + len);
  69     case 3:
  70         g_assert(len + 3 <= ARRAY_SIZE(ctx->bytes));
  71         ctx->addr += 3;
  72         ctx->len += 3;
  73         ctx->dis->read_memory_func(addr, ctx->bytes + len, 3, ctx->dis);
  74         return (int8_t)ctx->bytes[len + 2] << 16 | lduw_le_p(ctx->bytes + len);
  75     case 0:
  76         g_assert(len + 4 <= ARRAY_SIZE(ctx->bytes));
  77         ctx->addr += 4;
  78         ctx->len += 4;
  79         ctx->dis->read_memory_func(addr, ctx->bytes + len, 4, ctx->dis);
  80         return ldl_le_p(ctx->bytes + len);
  81     default:
  82         g_assert_not_reached();
  83     }
  84 }
  85
  86 static int bdsp_s(DisasContext *ctx, int d)
  87 {
  88     /*
  89      * 0 -> 8
  90      * 1 -> 9
  91      * 2 -> 10
  92      * 3 -> 3
  93      * :
  94      * 7 -> 7
  95      */
  96     if (d < 3) {
  97         d += 8;
  98     }
  99     return d;
 100 }
 101
 102 /* Include the auto-generated decoder.  */
 103 #include "decode-insns.c.inc"
 104
 105 static void dump_bytes(DisasContext *ctx)
 106 {
 107     int i, len = ctx->len;
 108
 109     for (i = 0; i < len; ++i) {
 110         ctx->dis->fprintf_func(ctx->dis->stream, "%02x ", ctx->bytes[i]);
 111     }
 112     ctx->dis->fprintf_func(ctx->dis->stream, "%*c", (8 - i) * 3, '\t');
 113 }
 114
 115 #define prt(...) \
 116     do {                                                        \
 117         dump_bytes(ctx);                                        \
 118         ctx->dis->fprintf_func(ctx->dis->stream, __VA_ARGS__);  \
 119     } while (0)
 120
 121 #define RX_MEMORY_BYTE 0
 122 #define RX_MEMORY_WORD 1
 123 #define RX_MEMORY_LONG 2
 124
 125 #define RX_IM_BYTE 0
 126 #define RX_IM_WORD 1
 127 #define RX_IM_LONG 2
 128 #define RX_IM_UWORD 3
 129
 130 static const char size[] = {'b', 'w', 'l'};
 131 static const char cond[][4] = {
 132     "eq", "ne", "c", "nc", "gtu", "leu", "pz", "n",
 133     "ge", "lt", "gt", "le", "o", "no", "ra", "f"
 134 };
 135 static const char psw[] = {
 136     'c', 'z', 's', 'o', 0, 0, 0, 0,
 137     'i', 'u', 0, 0, 0, 0, 0, 0,
 138 };
 139
 140 static void rx_index_addr(DisasContext *ctx, char out[8], int ld, int mi)
 141 {
 142     uint32_t addr = ctx->addr;
 143     uintptr_t len = ctx->len;
 144     uint16_t dsp;
 145
 146     switch (ld) {
 147     case 0:
 148         /* No index; return empty string.  */
 149         out[0] = '\0';
 150         return;
 151     case 1:
 152         g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes));
 153         ctx->addr += 1;
 154         ctx->len += 1;
 155         ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis);
 156         dsp = ctx->bytes[len];
 157         break;
 158     case 2:
 159         g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes));
 160         ctx->addr += 2;
 161         ctx->len += 2;
 162         ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis);
 163         dsp = lduw_le_p(ctx->bytes + len);
 164         break;
 165     default:
 166         g_assert_not_reached();
 167     }
 168
 169     sprintf(out, "%u", dsp << (mi < 3 ? mi : 4 - mi));
 170 }
 171
 172 static void prt_ldmi(DisasContext *ctx, const char *insn,
 173                      int ld, int mi, int rs, int rd)
 174 {
 175     static const char sizes[][4] = {".b", ".w", ".l", ".uw", ".ub"};
 176     char dsp[8];
 177
 178     if (ld < 3) {
 179         rx_index_addr(ctx, dsp, ld, mi);
 180         prt("%s\t%s[r%d]%s, r%d", insn, dsp, rs, sizes[mi], rd);
 181     } else {
 182         prt("%s\tr%d, r%d", insn, rs, rd);
 183     }
 184 }
 185
 186 static void prt_ir(DisasContext *ctx, const char *insn, int imm, int rd)
 187 {
 188     if (imm < 0x100) {
 189         prt("%s\t#%d, r%d", insn, imm, rd);
 190     } else {
 191         prt("%s\t#0x%08x, r%d", insn, imm, rd);
 192     }
 193 }
 194
 195 /* mov.[bwl] rs,dsp:[rd] */
 196 static bool trans_MOV_rm(DisasContext *ctx, arg_MOV_rm *a)
 197 {
 198     if (a->dsp > 0) {
 199         prt("mov.%c\tr%d,%d[r%d]",
 200             size[a->sz], a->rs, a->dsp << a->sz, a->rd);
 201     } else {
 202         prt("mov.%c\tr%d,[r%d]",
 203             size[a->sz], a->rs, a->rd);
 204     }
 205     return true;
 206 }
 207
 208 /* mov.[bwl] dsp:[rs],rd */
 209 static bool trans_MOV_mr(DisasContext *ctx, arg_MOV_mr *a)
 210 {
 211     if (a->dsp > 0) {
 212         prt("mov.%c\t%d[r%d], r%d",
 213             size[a->sz], a->dsp << a->sz, a->rs, a->rd);
 214     } else {
 215         prt("mov.%c\t[r%d], r%d",
 216             size[a->sz], a->rs, a->rd);
 217     }
 218     return true;
 219 }
 220
 221 /* mov.l #uimm4,rd */
 222 /* mov.l #uimm8,rd */
 223 /* mov.l #imm,rd */
 224 static bool trans_MOV_ir(DisasContext *ctx, arg_MOV_ir *a)
 225 {
 226     prt_ir(ctx, "mov.l", a->imm, a->rd);
 227     return true;
 228 }
 229
 230 /* mov.[bwl] #uimm8,dsp:[rd] */
 231 /* mov #imm, dsp:[rd] */
 232 static bool trans_MOV_im(DisasContext *ctx, arg_MOV_im *a)
 233 {
 234     if (a->dsp > 0) {
 235         prt("mov.%c\t#%d,%d[r%d]",
 236             size[a->sz], a->imm, a->dsp << a->sz, a->rd);
 237     } else {
 238         prt("mov.%c\t#%d,[r%d]",
 239             size[a->sz], a->imm, a->rd);
 240     }
 241     return true;
 242 }
 243
 244 /* mov.[bwl] [ri,rb],rd */
 245 static bool trans_MOV_ar(DisasContext *ctx, arg_MOV_ar *a)
 246 {
 247     prt("mov.%c\t[r%d,r%d], r%d", size[a->sz], a->ri, a->rb, a->rd);
 248     return true;
 249 }
 250
 251 /* mov.[bwl] rd,[ri,rb] */
 252 static bool trans_MOV_ra(DisasContext *ctx, arg_MOV_ra *a)
 253 {
 254     prt("mov.%c\tr%d, [r%d, r%d]", size[a->sz], a->rs, a->ri, a->rb);
 255     return true;
 256 }
 257
 258
 259 /* mov.[bwl] dsp:[rs],dsp:[rd] */
 260 /* mov.[bwl] rs,dsp:[rd] */
 261 /* mov.[bwl] dsp:[rs],rd */
 262 /* mov.[bwl] rs,rd */
 263 static bool trans_MOV_mm(DisasContext *ctx, arg_MOV_mm *a)
 264 {
 265     char dspd[8], dsps[8], szc = size[a->sz];
 266
 267     if (a->lds == 3 && a->ldd == 3) {
 268         /* mov.[bwl] rs,rd */
 269         prt("mov.%c\tr%d, r%d", szc, a->rs, a->rd);
 270     } else if (a->lds == 3) {
 271         rx_index_addr(ctx, dspd, a->ldd, a->sz);
 272         prt("mov.%c\tr%d, %s[r%d]", szc, a->rs, dspd, a->rd);
 273     } else if (a->ldd == 3) {
 274         rx_index_addr(ctx, dsps, a->lds, a->sz);
 275         prt("mov.%c\t%s[r%d], r%d", szc, dsps, a->rs, a->rd);
 276     } else {
 277         rx_index_addr(ctx, dsps, a->lds, a->sz);
 278         rx_index_addr(ctx, dspd, a->ldd, a->sz);
 279         prt("mov.%c\t%s[r%d], %s[r%d]", szc, dsps, a->rs, dspd, a->rd);
 280     }
 281     return true;
 282 }
 283
 284 /* mov.[bwl] rs,[rd+] */
 285 /* mov.[bwl] rs,[-rd] */
 286 static bool trans_MOV_rp(DisasContext *ctx, arg_MOV_rp *a)
 287 {
 288     if (a->ad) {
 289         prt("mov.%c\tr%d, [-r%d]", size[a->sz], a->rs, a->rd);
 290     } else {
 291         prt("mov.%c\tr%d, [r%d+]", size[a->sz], a->rs, a->rd);
 292     }
 293     return true;
 294 }
 295
 296 /* mov.[bwl] [rd+],rs */
 297 /* mov.[bwl] [-rd],rs */
 298 static bool trans_MOV_pr(DisasContext *ctx, arg_MOV_pr *a)
 299 {
 300     if (a->ad) {
 301         prt("mov.%c\t[-r%d], r%d", size[a->sz], a->rd, a->rs);
 302     } else {
 303         prt("mov.%c\t[r%d+], r%d", size[a->sz], a->rd, a->rs);
 304     }
 305     return true;
 306 }
 307
 308 /* movu.[bw] dsp5:[rs],rd */
 309 static bool trans_MOVU_mr(DisasContext *ctx, arg_MOVU_mr *a)
 310 {
 311     if (a->dsp > 0) {
 312         prt("movu.%c\t%d[r%d], r%d", size[a->sz],
 313             a->dsp << a->sz, a->rs, a->rd);
 314     } else {
 315         prt("movu.%c\t[r%d], r%d", size[a->sz], a->rs, a->rd);
 316     }
 317     return true;
 318 }
 319
 320 /* movu.[bw] rs,rd */
 321 static bool trans_MOVU_rr(DisasContext *ctx, arg_MOVU_rr *a)
 322 {
 323     prt("movu.%c\tr%d, r%d", size[a->sz], a->rs, a->rd);
 324     return true;
 325 }
 326
 327 /* movu.[bw] [ri,rb],rd */
 328 static bool trans_MOVU_ar(DisasContext *ctx, arg_MOVU_ar *a)
 329 {
 330     prt("mov.%c\t[r%d,r%d], r%d", size[a->sz], a->ri, a->rb, a->rd);
 331     return true;
 332 }
 333
 334 /* movu.[bw] [rs+],rd */
 335 /* movu.[bw] [-rs],rd */
 336 static bool trans_MOVU_pr(DisasContext *ctx, arg_MOVU_pr *a)
 337 {
 338     if (a->ad) {
 339         prt("movu.%c\t[-r%d], r%d", size[a->sz], a->rd, a->rs);
 340     } else {
 341         prt("movu.%c\t[r%d+], r%d", size[a->sz], a->rd, a->rs);
 342     }
 343     return true;
 344 }
 345
 346 /* pop rd */
 347 static bool trans_POP(DisasContext *ctx, arg_POP *a)
 348 {
 349     prt("pop\tr%d", a->rd);
 350     return true;
 351 }
 352
 353 /* popc rx */
 354 static bool trans_POPC(DisasContext *ctx, arg_POPC *a)
 355 {
 356     prt("pop\tr%s", rx_crname(a->cr));
 357     return true;
 358 }
 359
 360 /* popm rd-rd2 */
 361 static bool trans_POPM(DisasContext *ctx, arg_POPM *a)
 362 {
 363     prt("popm\tr%d-r%d", a->rd, a->rd2);
 364     return true;
 365 }
 366
 367 /* push rs */
 368 static bool trans_PUSH_r(DisasContext *ctx, arg_PUSH_r *a)
 369 {
 370     prt("push\tr%d", a->rs);
 371     return true;
 372 }
 373
 374 /* push dsp[rs] */
 375 static bool trans_PUSH_m(DisasContext *ctx, arg_PUSH_m *a)
 376 {
 377     char dsp[8];
 378
 379     rx_index_addr(ctx, dsp, a->ld, a->sz);
 380     prt("push\t%s[r%d]", dsp, a->rs);
 381     return true;
 382 }
 383
 384 /* pushc rx */
 385 static bool trans_PUSHC(DisasContext *ctx, arg_PUSHC *a)
 386 {
 387     prt("push\t%s", rx_crname(a->cr));
 388     return true;
 389 }
 390
 391 /* pushm rs-rs2*/
 392 static bool trans_PUSHM(DisasContext *ctx, arg_PUSHM *a)
 393 {
 394     prt("pushm\tr%d-r%d", a->rs, a->rs2);
 395     return true;
 396 }
 397
 398 /* xchg rs,rd */
 399 static bool trans_XCHG_rr(DisasContext *ctx, arg_XCHG_rr *a)
 400 {
 401     prt("xchg\tr%d, r%d", a->rs, a->rd);
 402     return true;
 403 }
 404 /* xchg dsp[rs].<mi>,rd */
 405 static bool trans_XCHG_mr(DisasContext *ctx, arg_XCHG_mr *a)
 406 {
 407     prt_ldmi(ctx, "xchg", a->ld, a->mi, a->rs, a->rd);
 408     return true;
 409 }
 410
 411 /* stz #imm,rd */
 412 static bool trans_STZ(DisasContext *ctx, arg_STZ *a)
 413 {
 414     prt_ir(ctx, "stz", a->imm, a->rd);
 415     return true;
 416 }
 417
 418 /* stnz #imm,rd */
 419 static bool trans_STNZ(DisasContext *ctx, arg_STNZ *a)
 420 {
 421     prt_ir(ctx, "stnz", a->imm, a->rd);
 422     return true;
 423 }
 424
 425 /* rtsd #imm */
 426 static bool trans_RTSD_i(DisasContext *ctx, arg_RTSD_i *a)
 427 {
 428     prt("rtsd\t#%d", a->imm << 2);
 429     return true;
 430 }
 431
 432 /* rtsd #imm, rd-rd2 */
 433 static bool trans_RTSD_irr(DisasContext *ctx, arg_RTSD_irr *a)
 434 {
 435     prt("rtsd\t#%d, r%d - r%d", a->imm << 2, a->rd, a->rd2);
 436     return true;
 437 }
 438
 439 /* and #uimm:4, rd */
 440 /* and #imm, rd */
 441 static bool trans_AND_ir(DisasContext *ctx, arg_AND_ir *a)
 442 {
 443     prt_ir(ctx, "and", a->imm, a->rd);
 444     return true;
 445 }
 446
 447 /* and dsp[rs], rd */
 448 /* and rs,rd */
 449 static bool trans_AND_mr(DisasContext *ctx, arg_AND_mr *a)
 450 {
 451     prt_ldmi(ctx, "and", a->ld, a->mi, a->rs, a->rd);
 452     return true;
 453 }
 454
 455 /* and rs,rs2,rd */
 456 static bool trans_AND_rrr(DisasContext *ctx, arg_AND_rrr *a)
 457 {
 458     prt("and\tr%d,r%d, r%d", a->rs, a->rs2, a->rd);
 459     return true;
 460 }
 461
 462 /* or #uimm:4, rd */
 463 /* or #imm, rd */
 464 static bool trans_OR_ir(DisasContext *ctx, arg_OR_ir *a)
 465 {
 466     prt_ir(ctx, "or", a->imm, a->rd);
 467     return true;
 468 }
 469
 470 /* or dsp[rs], rd */
 471 /* or rs,rd */
 472 static bool trans_OR_mr(DisasContext *ctx, arg_OR_mr *a)
 473 {
 474     prt_ldmi(ctx, "or", a->ld, a->mi, a->rs, a->rd);
 475     return true;
 476 }
 477
 478 /* or rs,rs2,rd */
 479 static bool trans_OR_rrr(DisasContext *ctx, arg_OR_rrr *a)
 480 {
 481     prt("or\tr%d, r%d, r%d", a->rs, a->rs2, a->rd);
 482     return true;
 483 }
 484
 485 /* xor #imm, rd */
 486 static bool trans_XOR_ir(DisasContext *ctx, arg_XOR_ir *a)
 487 {
 488     prt_ir(ctx, "xor", a->imm, a->rd);
 489     return true;
 490 }
 491
 492 /* xor dsp[rs], rd */
 493 /* xor rs,rd */
 494 static bool trans_XOR_mr(DisasContext *ctx, arg_XOR_mr *a)
 495 {
 496     prt_ldmi(ctx, "xor", a->ld, a->mi, a->rs, a->rd);
 497     return true;
 498 }
 499
 500 /* tst #imm, rd */
 501 static bool trans_TST_ir(DisasContext *ctx, arg_TST_ir *a)
 502 {
 503     prt_ir(ctx, "tst", a->imm, a->rd);
 504     return true;
 505 }
 506
 507 /* tst dsp[rs], rd */
 508 /* tst rs, rd */
 509 static bool trans_TST_mr(DisasContext *ctx, arg_TST_mr *a)
 510 {
 511     prt_ldmi(ctx, "tst", a->ld, a->mi, a->rs, a->rd);
 512     return true;
 513 }
 514
 515 /* not rd */
 516 /* not rs, rd */
 517 static bool trans_NOT_rr(DisasContext *ctx, arg_NOT_rr *a)
 518 {
 519     if (a->rs != a->rd) {
 520         prt("not\tr%d, r%d", a->rs, a->rd);
 521     } else {
 522         prt("not\tr%d", a->rs);
 523     }
 524     return true;
 525 }
 526
 527 /* neg rd */
 528 /* neg rs, rd */
 529 static bool trans_NEG_rr(DisasContext *ctx, arg_NEG_rr *a)
 530 {
 531     if (a->rs != a->rd) {
 532         prt("neg\tr%d, r%d", a->rs, a->rd);
 533     } else {
 534         prt("neg\tr%d", a->rs);
 535     }
 536     return true;
 537 }
 538
 539 /* adc #imm, rd */
 540 static bool trans_ADC_ir(DisasContext *ctx, arg_ADC_ir *a)
 541 {
 542     prt_ir(ctx, "adc", a->imm, a->rd);
 543     return true;
 544 }
 545
 546 /* adc rs, rd */
 547 static bool trans_ADC_rr(DisasContext *ctx, arg_ADC_rr *a)
 548 {
 549     prt("adc\tr%d, r%d", a->rs, a->rd);
 550     return true;
 551 }
 552
 553 /* adc dsp[rs], rd */
 554 static bool trans_ADC_mr(DisasContext *ctx, arg_ADC_mr *a)
 555 {
 556     char dsp[8];
 557
 558     rx_index_addr(ctx, dsp, a->ld, 2);
 559     prt("adc\t%s[r%d], r%d", dsp, a->rs, a->rd);
 560     return true;
 561 }
 562
 563 /* add #uimm4, rd */
 564 /* add #imm, rs, rd */
 565 static bool trans_ADD_irr(DisasContext *ctx, arg_ADD_irr *a)
 566 {
 567     if (a->imm < 0x10 && a->rs2 == a->rd) {
 568         prt("add\t#%d, r%d", a->imm, a->rd);
 569     } else {
 570         prt("add\t#0x%08x, r%d, r%d", a->imm, a->rs2, a->rd);
 571     }
 572     return true;
 573 }
 574
 575 /* add rs, rd */
 576 /* add dsp[rs], rd */
 577 static bool trans_ADD_mr(DisasContext *ctx, arg_ADD_mr *a)
 578 {
 579     prt_ldmi(ctx, "add", a->ld, a->mi, a->rs, a->rd);
 580     return true;
 581 }
 582
 583 /* add rs, rs2, rd */
 584 static bool trans_ADD_rrr(DisasContext *ctx, arg_ADD_rrr *a)
 585 {
 586     prt("add\tr%d, r%d, r%d", a->rs, a->rs2, a->rd);
 587     return true;
 588 }
 589
 590 /* cmp #imm4, rd */
 591 /* cmp #imm8, rd */
 592 /* cmp #imm, rs2 */
 593 static bool trans_CMP_ir(DisasContext *ctx, arg_CMP_ir *a)
 594 {
 595     prt_ir(ctx, "cmp", a->imm, a->rs2);
 596     return true;
 597 }
 598
 599 /* cmp rs, rs2 */
 600 /* cmp dsp[rs], rs2 */
 601 static bool trans_CMP_mr(DisasContext *ctx, arg_CMP_mr *a)
 602 {
 603     prt_ldmi(ctx, "cmp", a->ld, a->mi, a->rs, a->rd);
 604     return true;
 605 }
 606
 607 /* sub #imm4, rd */
 608 static bool trans_SUB_ir(DisasContext *ctx, arg_SUB_ir *a)
 609 {
 610     prt("sub\t#%d, r%d", a->imm, a->rd);
 611     return true;
 612 }
 613
 614 /* sub rs, rd */
 615 /* sub dsp[rs], rd */
 616 static bool trans_SUB_mr(DisasContext *ctx, arg_SUB_mr *a)
 617 {
 618     prt_ldmi(ctx, "sub", a->ld, a->mi, a->rs, a->rd);
 619     return true;
 620 }
 621
 622 /* sub rs, rs2, rd */
 623 static bool trans_SUB_rrr(DisasContext *ctx, arg_SUB_rrr *a)
 624 {
 625     prt("sub\tr%d, r%d, r%d", a->rs, a->rs2, a->rd);
 626     return true;
 627 }
 628
 629 /* sbb rs, rd */
 630 static bool trans_SBB_rr(DisasContext *ctx, arg_SBB_rr *a)
 631 {
 632     prt("sbb\tr%d, r%d", a->rs, a->rd);
 633     return true;
 634 }
 635
 636 /* sbb dsp[rs], rd */
 637 static bool trans_SBB_mr(DisasContext *ctx, arg_SBB_mr *a)
 638 {
 639     prt_ldmi(ctx, "sbb", a->ld, RX_IM_LONG, a->rs, a->rd);
 640     return true;
 641 }
 642
 643 /* abs rd */
 644 /* abs rs, rd */
 645 static bool trans_ABS_rr(DisasContext *ctx, arg_ABS_rr *a)
 646 {
 647     if (a->rs != a->rd) {
 648         prt("abs\tr%d, r%d", a->rs, a->rd);
 649     } else {
 650         prt("abs\tr%d", a->rs);
 651     }
 652     return true;
 653 }
 654
 655 /* max #imm, rd */
 656 static bool trans_MAX_ir(DisasContext *ctx, arg_MAX_ir *a)
 657 {
 658     prt_ir(ctx, "max", a->imm, a->rd);
 659     return true;
 660 }
 661
 662 /* max rs, rd */
 663 /* max dsp[rs], rd */
 664 static bool trans_MAX_mr(DisasContext *ctx, arg_MAX_mr *a)
 665 {
 666     prt_ldmi(ctx, "max", a->ld, a->mi, a->rs, a->rd);
 667     return true;
 668 }
 669
 670 /* min #imm, rd */
 671 static bool trans_MIN_ir(DisasContext *ctx, arg_MIN_ir *a)
 672 {
 673     prt_ir(ctx, "min", a->imm, a->rd);
 674     return true;
 675 }
 676
 677 /* min rs, rd */
 678 /* min dsp[rs], rd */
 679 static bool trans_MIN_mr(DisasContext *ctx, arg_MIN_mr *a)
 680 {
 681     prt_ldmi(ctx, "min", a->ld, a->mi, a->rs, a->rd);
 682     return true;
 683 }
 684
 685 /* mul #uimm4, rd */
 686 /* mul #imm, rd */
 687 static bool trans_MUL_ir(DisasContext *ctx, arg_MUL_ir *a)
 688 {
 689     prt_ir(ctx, "mul", a->imm, a->rd);
 690     return true;
 691 }
 692
 693 /* mul rs, rd */
 694 /* mul dsp[rs], rd */
 695 static bool trans_MUL_mr(DisasContext *ctx, arg_MUL_mr *a)
 696 {
 697     prt_ldmi(ctx, "mul", a->ld, a->mi, a->rs, a->rd);
 698     return true;
 699 }
 700
 701 /* mul rs, rs2, rd */
 702 static bool trans_MUL_rrr(DisasContext *ctx, arg_MUL_rrr *a)
 703 {
 704     prt("mul\tr%d,r%d,r%d", a->rs, a->rs2, a->rd);
 705     return true;
 706 }
 707
 708 /* emul #imm, rd */
 709 static bool trans_EMUL_ir(DisasContext *ctx, arg_EMUL_ir *a)
 710 {
 711     prt_ir(ctx, "emul", a->imm, a->rd);
 712     return true;
 713 }
 714
 715 /* emul rs, rd */
 716 /* emul dsp[rs], rd */
 717 static bool trans_EMUL_mr(DisasContext *ctx, arg_EMUL_mr *a)
 718 {
 719     prt_ldmi(ctx, "emul", a->ld, a->mi, a->rs, a->rd);
 720     return true;
 721 }
 722
 723 /* emulu #imm, rd */
 724 static bool trans_EMULU_ir(DisasContext *ctx, arg_EMULU_ir *a)
 725 {
 726     prt_ir(ctx, "emulu", a->imm, a->rd);
 727     return true;
 728 }
 729
 730 /* emulu rs, rd */
 731 /* emulu dsp[rs], rd */
 732 static bool trans_EMULU_mr(DisasContext *ctx, arg_EMULU_mr *a)
 733 {
 734     prt_ldmi(ctx, "emulu", a->ld, a->mi, a->rs, a->rd);
 735     return true;
 736 }
 737
 738 /* div #imm, rd */
 739 static bool trans_DIV_ir(DisasContext *ctx, arg_DIV_ir *a)
 740 {
 741     prt_ir(ctx, "div", a->imm, a->rd);
 742     return true;
 743 }
 744
 745 /* div rs, rd */
 746 /* div dsp[rs], rd */
 747 static bool trans_DIV_mr(DisasContext *ctx, arg_DIV_mr *a)
 748 {
 749     prt_ldmi(ctx, "div", a->ld, a->mi, a->rs, a->rd);
 750     return true;
 751 }
 752
 753 /* divu #imm, rd */
 754 static bool trans_DIVU_ir(DisasContext *ctx, arg_DIVU_ir *a)
 755 {
 756     prt_ir(ctx, "divu", a->imm, a->rd);
 757     return true;
 758 }
 759
 760 /* divu rs, rd */
 761 /* divu dsp[rs], rd */
 762 static bool trans_DIVU_mr(DisasContext *ctx, arg_DIVU_mr *a)
 763 {
 764     prt_ldmi(ctx, "divu", a->ld, a->mi, a->rs, a->rd);
 765     return true;
 766 }
 767
 768
 769 /* shll #imm:5, rd */
 770 /* shll #imm:5, rs, rd */
 771 static bool trans_SHLL_irr(DisasContext *ctx, arg_SHLL_irr *a)
 772 {
 773     if (a->rs2 != a->rd) {
 774         prt("shll\t#%d, r%d, r%d", a->imm, a->rs2, a->rd);
 775     } else {
 776         prt("shll\t#%d, r%d", a->imm, a->rd);
 777     }
 778     return true;
 779 }
 780
 781 /* shll rs, rd */
 782 static bool trans_SHLL_rr(DisasContext *ctx, arg_SHLL_rr *a)
 783 {
 784     prt("shll\tr%d, r%d", a->rs, a->rd);
 785     return true;
 786 }
 787
 788 /* shar #imm:5, rd */
 789 /* shar #imm:5, rs, rd */
 790 static bool trans_SHAR_irr(DisasContext *ctx, arg_SHAR_irr *a)
 791 {
 792     if (a->rs2 != a->rd) {
 793         prt("shar\t#%d, r%d, r%d", a->imm, a->rs2, a->rd);
 794     } else {
 795         prt("shar\t#%d, r%d", a->imm, a->rd);
 796     }
 797     return true;
 798 }
 799
 800 /* shar rs, rd */
 801 static bool trans_SHAR_rr(DisasContext *ctx, arg_SHAR_rr *a)
 802 {
 803     prt("shar\tr%d, r%d", a->rs, a->rd);
 804     return true;
 805 }
 806
 807 /* shlr #imm:5, rd */
 808 /* shlr #imm:5, rs, rd */
 809 static bool trans_SHLR_irr(DisasContext *ctx, arg_SHLR_irr *a)
 810 {
 811     if (a->rs2 != a->rd) {
 812         prt("shlr\t#%d, r%d, r%d", a->imm, a->rs2, a->rd);
 813     } else {
 814         prt("shlr\t#%d, r%d", a->imm, a->rd);
 815     }
 816     return true;
 817 }
 818
 819 /* shlr rs, rd */
 820 static bool trans_SHLR_rr(DisasContext *ctx, arg_SHLR_rr *a)
 821 {
 822     prt("shlr\tr%d, r%d", a->rs, a->rd);
 823     return true;
 824 }
 825
 826 /* rolc rd */
 827 static bool trans_ROLC(DisasContext *ctx, arg_ROLC *a)
 828 {
 829     prt("rorc\tr%d", a->rd);
 830     return true;
 831 }
 832
 833 /* rorc rd */
 834 static bool trans_RORC(DisasContext *ctx, arg_RORC *a)
 835 {
 836     prt("rorc\tr%d", a->rd);
 837     return true;
 838 }
 839
 840 /* rotl #imm, rd */
 841 static bool trans_ROTL_ir(DisasContext *ctx, arg_ROTL_ir *a)
 842 {
 843     prt("rotl\t#%d, r%d", a->imm, a->rd);
 844     return true;
 845 }
 846
 847 /* rotl rs, rd */
 848 static bool trans_ROTL_rr(DisasContext *ctx, arg_ROTL_rr *a)
 849 {
 850     prt("rotl\tr%d, r%d", a->rs, a->rd);
 851     return true;
 852 }
 853
 854 /* rotr #imm, rd */
 855 static bool trans_ROTR_ir(DisasContext *ctx, arg_ROTR_ir *a)
 856 {
 857     prt("rotr\t#%d, r%d", a->imm, a->rd);
 858     return true;
 859 }
 860
 861 /* rotr rs, rd */
 862 static bool trans_ROTR_rr(DisasContext *ctx, arg_ROTR_rr *a)
 863 {
 864     prt("rotr\tr%d, r%d", a->rs, a->rd);
 865     return true;
 866 }
 867
 868 /* revl rs, rd */
 869 static bool trans_REVL(DisasContext *ctx, arg_REVL *a)
 870 {
 871     prt("revl\tr%d, r%d", a->rs, a->rd);
 872     return true;
 873 }
 874
 875 /* revw rs, rd */
 876 static bool trans_REVW(DisasContext *ctx, arg_REVW *a)
 877 {
 878     prt("revw\tr%d, r%d", a->rs, a->rd);
 879     return true;
 880 }
 881
 882 /* conditional branch helper */
 883 static void rx_bcnd_main(DisasContext *ctx, int cd, int len, int dst)
 884 {
 885     static const char sz[] = {'s', 'b', 'w', 'a'};
 886     prt("b%s.%c\t%08x", cond[cd], sz[len - 1], ctx->pc + dst);
 887 }
 888
 889 /* beq dsp:3 / bne dsp:3 */
 890 /* beq dsp:8 / bne dsp:8 */
 891 /* bc dsp:8 / bnc dsp:8 */
 892 /* bgtu dsp:8 / bleu dsp:8 */
 893 /* bpz dsp:8 / bn dsp:8 */
 894 /* bge dsp:8 / blt dsp:8 */
 895 /* bgt dsp:8 / ble dsp:8 */
 896 /* bo dsp:8 / bno dsp:8 */
 897 /* beq dsp:16 / bne dsp:16 */
 898 static bool trans_BCnd(DisasContext *ctx, arg_BCnd *a)
 899 {
 900     rx_bcnd_main(ctx, a->cd, a->sz, a->dsp);
 901     return true;
 902 }
 903
 904 /* bra dsp:3 */
 905 /* bra dsp:8 */
 906 /* bra dsp:16 */
 907 /* bra dsp:24 */
 908 static bool trans_BRA(DisasContext *ctx, arg_BRA *a)
 909 {
 910     rx_bcnd_main(ctx, 14, a->sz, a->dsp);
 911     return true;
 912 }
 913
 914 /* bra rs */
 915 static bool trans_BRA_l(DisasContext *ctx, arg_BRA_l *a)
 916 {
 917     prt("bra.l\tr%d", a->rd);
 918     return true;
 919 }
 920
 921 /* jmp rs */
 922 static bool trans_JMP(DisasContext *ctx, arg_JMP *a)
 923 {
 924     prt("jmp\tr%d", a->rs);
 925     return true;
 926 }
 927
 928 /* jsr rs */
 929 static bool trans_JSR(DisasContext *ctx, arg_JSR *a)
 930 {
 931     prt("jsr\tr%d", a->rs);
 932     return true;
 933 }
 934
 935 /* bsr dsp:16 */
 936 /* bsr dsp:24 */
 937 static bool trans_BSR(DisasContext *ctx, arg_BSR *a)
 938 {
 939     static const char sz[] = {'w', 'a'};
 940     prt("bsr.%c\t%08x", sz[a->sz - 3], ctx->pc + a->dsp);
 941     return true;
 942 }
 943
 944 /* bsr rs */
 945 static bool trans_BSR_l(DisasContext *ctx, arg_BSR_l *a)
 946 {
 947     prt("bsr.l\tr%d", a->rd);
 948     return true;
 949 }
 950
 951 /* rts */
 952 static bool trans_RTS(DisasContext *ctx, arg_RTS *a)
 953 {
 954     prt("rts");
 955     return true;
 956 }
 957
 958 /* nop */
 959 static bool trans_NOP(DisasContext *ctx, arg_NOP *a)
 960 {
 961     prt("nop");
 962     return true;
 963 }
 964
 965 /* scmpu */
 966 static bool trans_SCMPU(DisasContext *ctx, arg_SCMPU *a)
 967 {
 968     prt("scmpu");
 969     return true;
 970 }
 971
 972 /* smovu */
 973 static bool trans_SMOVU(DisasContext *ctx, arg_SMOVU *a)
 974 {
 975     prt("smovu");
 976     return true;
 977 }
 978
 979 /* smovf */
 980 static bool trans_SMOVF(DisasContext *ctx, arg_SMOVF *a)
 981 {
 982     prt("smovf");
 983     return true;
 984 }
 985
 986 /* smovb */
 987 static bool trans_SMOVB(DisasContext *ctx, arg_SMOVB *a)
 988 {
 989     prt("smovb");
 990     return true;
 991 }
 992
 993 /* suntile */
 994 static bool trans_SUNTIL(DisasContext *ctx, arg_SUNTIL *a)
 995 {
 996     prt("suntil.%c", size[a->sz]);
 997     return true;
 998 }
 999
1000 /* swhile */
1001 static bool trans_SWHILE(DisasContext *ctx, arg_SWHILE *a)
1002 {
1003     prt("swhile.%c", size[a->sz]);
1004     return true;
1005 }
1006 /* sstr */
1007 static bool trans_SSTR(DisasContext *ctx, arg_SSTR *a)
1008 {
1009     prt("sstr.%c", size[a->sz]);
1010     return true;
1011 }
1012
1013 /* rmpa */
1014 static bool trans_RMPA(DisasContext *ctx, arg_RMPA *a)
1015 {
1016     prt("rmpa.%c", size[a->sz]);
1017     return true;
1018 }
1019
1020 /* mulhi rs,rs2 */
1021 static bool trans_MULHI(DisasContext *ctx, arg_MULHI *a)
1022 {
1023     prt("mulhi\tr%d,r%d", a->rs, a->rs2);
1024     return true;
1025 }
1026
1027 /* mullo rs,rs2 */
1028 static bool trans_MULLO(DisasContext *ctx, arg_MULLO *a)
1029 {
1030     prt("mullo\tr%d, r%d", a->rs, a->rs2);
1031     return true;
1032 }
1033
1034 /* machi rs,rs2 */
1035 static bool trans_MACHI(DisasContext *ctx, arg_MACHI *a)
1036 {
1037     prt("machi\tr%d, r%d", a->rs, a->rs2);
1038     return true;
1039 }
1040
1041 /* maclo rs,rs2 */
1042 static bool trans_MACLO(DisasContext *ctx, arg_MACLO *a)
1043 {
1044     prt("maclo\tr%d, r%d", a->rs, a->rs2);
1045     return true;
1046 }
1047
1048 /* mvfachi rd */
1049 static bool trans_MVFACHI(DisasContext *ctx, arg_MVFACHI *a)
1050 {
1051     prt("mvfachi\tr%d", a->rd);
1052     return true;
1053 }
1054
1055 /* mvfacmi rd */
1056 static bool trans_MVFACMI(DisasContext *ctx, arg_MVFACMI *a)
1057 {
1058     prt("mvfacmi\tr%d", a->rd);
1059     return true;
1060 }
1061
1062 /* mvtachi rs */
1063 static bool trans_MVTACHI(DisasContext *ctx, arg_MVTACHI *a)
1064 {
1065     prt("mvtachi\tr%d", a->rs);
1066     return true;
1067 }
1068
1069 /* mvtaclo rs */
1070 static bool trans_MVTACLO(DisasContext *ctx, arg_MVTACLO *a)
1071 {
1072     prt("mvtaclo\tr%d", a->rs);
1073     return true;
1074 }
1075
1076 /* racw #imm */
1077 static bool trans_RACW(DisasContext *ctx, arg_RACW *a)
1078 {
1079     prt("racw\t#%d", a->imm + 1);
1080     return true;
1081 }
1082
1083 /* sat rd */
1084 static bool trans_SAT(DisasContext *ctx, arg_SAT *a)
1085 {
1086     prt("sat\tr%d", a->rd);
1087     return true;
1088 }
1089
1090 /* satr */
1091 static bool trans_SATR(DisasContext *ctx, arg_SATR *a)
1092 {
1093     prt("satr");
1094     return true;
1095 }
1096
1097 /* fadd #imm, rd */
1098 static bool trans_FADD_ir(DisasContext *ctx, arg_FADD_ir *a)
1099 {
1100     prt("fadd\t#%d,r%d", li(ctx, 0), a->rd);
1101     return true;
1102 }
1103
1104 /* fadd dsp[rs], rd */
1105 /* fadd rs, rd */
1106 static bool trans_FADD_mr(DisasContext *ctx, arg_FADD_mr *a)
1107 {
1108     prt_ldmi(ctx, "fadd", a->ld, RX_IM_LONG, a->rs, a->rd);
1109     return true;
1110 }
1111
1112 /* fcmp #imm, rd */
1113 static bool trans_FCMP_ir(DisasContext *ctx, arg_FCMP_ir *a)
1114 {
1115     prt("fadd\t#%d,r%d", li(ctx, 0), a->rd);
1116     return true;
1117 }
1118
1119 /* fcmp dsp[rs], rd */
1120 /* fcmp rs, rd */
1121 static bool trans_FCMP_mr(DisasContext *ctx, arg_FCMP_mr *a)
1122 {
1123     prt_ldmi(ctx, "fcmp", a->ld, RX_IM_LONG, a->rs, a->rd);
1124     return true;
1125 }
1126
1127 /* fsub #imm, rd */
1128 static bool trans_FSUB_ir(DisasContext *ctx, arg_FSUB_ir *a)
1129 {
1130     prt("fsub\t#%d,r%d", li(ctx, 0), a->rd);
1131     return true;
1132 }
1133
1134 /* fsub dsp[rs], rd */
1135 /* fsub rs, rd */
1136 static bool trans_FSUB_mr(DisasContext *ctx, arg_FSUB_mr *a)
1137 {
1138     prt_ldmi(ctx, "fsub", a->ld, RX_IM_LONG, a->rs, a->rd);
1139     return true;
1140 }
1141
1142 /* ftoi dsp[rs], rd */
1143 /* ftoi rs, rd */
1144 static bool trans_FTOI(DisasContext *ctx, arg_FTOI *a)
1145 {
1146     prt_ldmi(ctx, "ftoi", a->ld, RX_IM_LONG, a->rs, a->rd);
1147     return true;
1148 }
1149
1150 /* fmul #imm, rd */
1151 static bool trans_FMUL_ir(DisasContext *ctx, arg_FMUL_ir *a)
1152 {
1153     prt("fmul\t#%d,r%d", li(ctx, 0), a->rd);
1154     return true;
1155 }
1156
1157 /* fmul dsp[rs], rd */
1158 /* fmul rs, rd */
1159 static bool trans_FMUL_mr(DisasContext *ctx, arg_FMUL_mr *a)
1160 {
1161     prt_ldmi(ctx, "fmul", a->ld, RX_IM_LONG, a->rs, a->rd);
1162     return true;
1163 }
1164
1165 /* fdiv #imm, rd */
1166 static bool trans_FDIV_ir(DisasContext *ctx, arg_FDIV_ir *a)
1167 {
1168     prt("fdiv\t#%d,r%d", li(ctx, 0), a->rd);
1169     return true;
1170 }
1171
1172 /* fdiv dsp[rs], rd */
1173 /* fdiv rs, rd */
1174 static bool trans_FDIV_mr(DisasContext *ctx, arg_FDIV_mr *a)
1175 {
1176     prt_ldmi(ctx, "fdiv", a->ld, RX_IM_LONG, a->rs, a->rd);
1177     return true;
1178 }
1179
1180 /* round dsp[rs], rd */
1181 /* round rs, rd */
1182 static bool trans_ROUND(DisasContext *ctx, arg_ROUND *a)
1183 {
1184     prt_ldmi(ctx, "round", a->ld, RX_IM_LONG, a->rs, a->rd);
1185     return true;
1186 }
1187
1188 /* itof rs, rd */
1189 /* itof dsp[rs], rd */
1190 static bool trans_ITOF(DisasContext *ctx, arg_ITOF *a)
1191 {
1192     prt_ldmi(ctx, "itof", a->ld, RX_IM_LONG, a->rs, a->rd);
1193     return true;
1194 }
1195
1196 #define BOP_IM(name, reg)                                       \
1197     do {                                                        \
1198         char dsp[8];                                            \
1199         rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE);         \
1200         prt("b%s\t#%d, %s[r%d]", #name, a->imm, dsp, reg);      \
1201         return true;                                            \
1202     } while (0)
1203
1204 #define BOP_RM(name)                                            \
1205     do {                                                        \
1206         char dsp[8];                                            \
1207         rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE);         \
1208         prt("b%s\tr%d, %s[r%d]", #name, a->rd, dsp, a->rs);     \
1209         return true;                                            \
1210     } while (0)
1211
1212 /* bset #imm, dsp[rd] */
1213 static bool trans_BSET_im(DisasContext *ctx, arg_BSET_im *a)
1214 {
1215     BOP_IM(bset, a->rs);
1216 }
1217
1218 /* bset rs, dsp[rd] */
1219 static bool trans_BSET_rm(DisasContext *ctx, arg_BSET_rm *a)
1220 {
1221     BOP_RM(set);
1222 }
1223
1224 /* bset rs, rd */
1225 static bool trans_BSET_rr(DisasContext *ctx, arg_BSET_rr *a)
1226 {
1227     prt("bset\tr%d,r%d", a->rs, a->rd);
1228     return true;
1229 }
1230
1231 /* bset #imm, rd */
1232 static bool trans_BSET_ir(DisasContext *ctx, arg_BSET_ir *a)
1233 {
1234     prt("bset\t#%d, r%d", a->imm, a->rd);
1235     return true;
1236 }
1237
1238 /* bclr #imm, dsp[rd] */
1239 static bool trans_BCLR_im(DisasContext *ctx, arg_BCLR_im *a)
1240 {
1241     BOP_IM(clr, a->rs);
1242 }
1243
1244 /* bclr rs, dsp[rd] */
1245 static bool trans_BCLR_rm(DisasContext *ctx, arg_BCLR_rm *a)
1246 {
1247     BOP_RM(clr);
1248 }
1249
1250 /* bclr rs, rd */
1251 static bool trans_BCLR_rr(DisasContext *ctx, arg_BCLR_rr *a)
1252 {
1253     prt("bclr\tr%d, r%d", a->rs, a->rd);
1254     return true;
1255 }
1256
1257 /* bclr #imm, rd */
1258 static bool trans_BCLR_ir(DisasContext *ctx, arg_BCLR_ir *a)
1259 {
1260     prt("bclr\t#%d,r%d", a->imm, a->rd);
1261     return true;
1262 }
1263
1264 /* btst #imm, dsp[rd] */
1265 static bool trans_BTST_im(DisasContext *ctx, arg_BTST_im *a)
1266 {
1267     BOP_IM(tst, a->rs);
1268 }
1269
1270 /* btst rs, dsp[rd] */
1271 static bool trans_BTST_rm(DisasContext *ctx, arg_BTST_rm *a)
1272 {
1273     BOP_RM(tst);
1274 }
1275
1276 /* btst rs, rd */
1277 static bool trans_BTST_rr(DisasContext *ctx, arg_BTST_rr *a)
1278 {
1279     prt("btst\tr%d, r%d", a->rs, a->rd);
1280     return true;
1281 }
1282
1283 /* btst #imm, rd */
1284 static bool trans_BTST_ir(DisasContext *ctx, arg_BTST_ir *a)
1285 {
1286     prt("btst\t#%d, r%d", a->imm, a->rd);
1287     return true;
1288 }
1289
1290 /* bnot rs, dsp[rd] */
1291 static bool trans_BNOT_rm(DisasContext *ctx, arg_BNOT_rm *a)
1292 {
1293     BOP_RM(not);
1294 }
1295
1296 /* bnot rs, rd */
1297 static bool trans_BNOT_rr(DisasContext *ctx, arg_BNOT_rr *a)
1298 {
1299     prt("bnot\tr%d, r%d", a->rs, a->rd);
1300     return true;
1301 }
1302
1303 /* bnot #imm, dsp[rd] */
1304 static bool trans_BNOT_im(DisasContext *ctx, arg_BNOT_im *a)
1305 {
1306     BOP_IM(not, a->rs);
1307 }
1308
1309 /* bnot #imm, rd */
1310 static bool trans_BNOT_ir(DisasContext *ctx, arg_BNOT_ir *a)
1311 {
1312     prt("bnot\t#%d, r%d", a->imm, a->rd);
1313     return true;
1314 }
1315
1316 /* bmcond #imm, dsp[rd] */
1317 static bool trans_BMCnd_im(DisasContext *ctx, arg_BMCnd_im *a)
1318 {
1319     char dsp[8];
1320
1321     rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE);
1322     prt("bm%s\t#%d, %s[r%d]", cond[a->cd], a->imm, dsp, a->rd);
1323     return true;
1324 }
1325
1326 /* bmcond #imm, rd */
1327 static bool trans_BMCnd_ir(DisasContext *ctx, arg_BMCnd_ir *a)
1328 {
1329     prt("bm%s\t#%d, r%d", cond[a->cd], a->imm, a->rd);
1330     return true;
1331 }
1332
1333 /* clrpsw psw */
1334 static bool trans_CLRPSW(DisasContext *ctx, arg_CLRPSW *a)
1335 {
1336     prt("clrpsw\t%c", psw[a->cb]);
1337     return true;
1338 }
1339
1340 /* setpsw psw */
1341 static bool trans_SETPSW(DisasContext *ctx, arg_SETPSW *a)
1342 {
1343     prt("setpsw\t%c", psw[a->cb]);
1344     return true;
1345 }
1346
1347 /* mvtipl #imm */
1348 static bool trans_MVTIPL(DisasContext *ctx, arg_MVTIPL *a)
1349 {
1350     prt("movtipl\t#%d", a->imm);
1351     return true;
1352 }
1353
1354 /* mvtc #imm, rd */
1355 static bool trans_MVTC_i(DisasContext *ctx, arg_MVTC_i *a)
1356 {
1357     prt("mvtc\t#0x%08x, %s", a->imm, rx_crname(a->cr));
1358     return true;
1359 }
1360
1361 /* mvtc rs, rd */
1362 static bool trans_MVTC_r(DisasContext *ctx, arg_MVTC_r *a)
1363 {
1364     prt("mvtc\tr%d, %s", a->rs, rx_crname(a->cr));
1365     return true;
1366 }
1367
1368 /* mvfc rs, rd */
1369 static bool trans_MVFC(DisasContext *ctx, arg_MVFC *a)
1370 {
1371     prt("mvfc\t%s, r%d", rx_crname(a->cr), a->rd);
1372     return true;
1373 }
1374
1375 /* rtfi */
1376 static bool trans_RTFI(DisasContext *ctx, arg_RTFI *a)
1377 {
1378     prt("rtfi");
1379     return true;
1380 }
1381
1382 /* rte */
1383 static bool trans_RTE(DisasContext *ctx, arg_RTE *a)
1384 {
1385     prt("rte");
1386     return true;
1387 }
1388
1389 /* brk */
1390 static bool trans_BRK(DisasContext *ctx, arg_BRK *a)
1391 {
1392     prt("brk");
1393     return true;
1394 }
1395
1396 /* int #imm */
1397 static bool trans_INT(DisasContext *ctx, arg_INT *a)
1398 {
1399     prt("int\t#%d", a->imm);
1400     return true;
1401 }
1402
1403 /* wait */
1404 static bool trans_WAIT(DisasContext *ctx, arg_WAIT *a)
1405 {
1406     prt("wait");
1407     return true;
1408 }
1409
1410 /* sccnd.[bwl] rd */
1411 /* sccnd.[bwl] dsp:[rd] */
1412 static bool trans_SCCnd(DisasContext *ctx, arg_SCCnd *a)
1413 {
1414     if (a->ld < 3) {
1415         char dsp[8];
1416         rx_index_addr(ctx, dsp, a->sz, a->ld);
1417         prt("sc%s.%c\t%s[r%d]", cond[a->cd], size[a->sz], dsp, a->rd);
1418     } else {
1419         prt("sc%s.%c\tr%d", cond[a->cd], size[a->sz], a->rd);
1420     }
1421     return true;
1422 }
1423
1424 int print_insn_rx(bfd_vma addr, disassemble_info *dis)
1425 {
1426     DisasContext ctx;
1427     uint32_t insn;
1428     int i;
1429
1430     ctx.dis = dis;
1431     ctx.pc = ctx.addr = addr;
1432     ctx.len = 0;
1433
1434     insn = decode_load(&ctx);
1435     if (!decode(&ctx, insn)) {
1436         ctx.dis->fprintf_func(ctx.dis->stream, ".byte\t");
1437         for (i = 0; i < ctx.addr - addr; i++) {
1438             if (i > 0) {
1439                 ctx.dis->fprintf_func(ctx.dis->stream, ",");
1440             }
1441             ctx.dis->fprintf_func(ctx.dis->stream, "0x%02x", insn >> 24);
1442             insn <<= 8;
1443         }
1444     }
1445     return ctx.addr - addr;
1446 }