1 /* $NetBSD: db_disasm.c,v 1.23 2019/04/06 03:06:27 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1998-2000 Internet Initiative Japan Inc. 5 * All rights reserved. 6 * 7 * Author: Akinori Koketsu 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistribution with functional modification must include 15 * prominent notice stating how and when and by whom it is 16 * modified. 17 * 3. Redistributions in binary form have to be along with the source 18 * code or documentation which include above copyright notice, this 19 * list of conditions and the following disclaimer. 20 * 4. All commercial advertising materials mentioning features or use 21 * of this software must display the following acknowledgement: 22 * This product includes software developed by Internet 23 * Initiative Japan Inc. 24 * 25 * THIS SOFTWARE IS PROVIDED BY ``AS IS'' AND ANY EXPRESS OR IMPLIED 26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 27 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 28 * DISCLAIMED. 29 */ 30 31 #include <sys/cdefs.h> 32 __KERNEL_RCSID(0, "$NetBSD: db_disasm.c,v 1.23 2019/04/06 03:06:27 thorpej Exp $"); 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 37 #include <machine/db_machdep.h> 38 39 #include <ddb/db_command.h> 40 #include <ddb/db_interface.h> 41 #include <ddb/db_output.h> 42 43 static uint16_t get_insn(const void *); 44 45 static void get_opcode(const uint16_t *, char *, size_t); 46 47 static void f_02(const uint16_t *, char *, size_t); 48 static void f_03(const uint16_t *, char *, size_t); 49 static void f_04(const uint16_t *, char *, size_t); 50 static void f_08(const uint16_t *, char *, size_t); 51 static void f_09(const uint16_t *, char *, size_t); 52 static void f_0a(const uint16_t *, char *, size_t); 53 static void f_0b(const uint16_t *, char *, size_t); 54 static void f_0c(const uint16_t *, char *, size_t); 55 static void f_10(const uint16_t *, char *, size_t); 56 static void f_20(const uint16_t *, char *, size_t); 57 static void f_24(const uint16_t *, char *, size_t); 58 static void f_28(const uint16_t *, char *, size_t); 59 static void f_2c(const uint16_t *, char *, size_t); 60 static void f_30(const uint16_t *, char *, size_t); 61 static void f_34(const uint16_t *, char *, size_t); 62 static void f_38(const uint16_t *, char *, size_t); 63 static void f_3c(const uint16_t *, char *, size_t); 64 static void f_40(const uint16_t *, char *, size_t); 65 static void f_41(const uint16_t *, char *, size_t); 66 static void f_42(const uint16_t *, char *, size_t); 67 static void f_43(const uint16_t *, char *, size_t); 68 static void f_44(const uint16_t *, char *, size_t); 69 static void f_45(const uint16_t *, char *, size_t); 70 static void f_46(const uint16_t *, char *, size_t); 71 static void f_47(const uint16_t *, char *, size_t); 72 static void f_48(const uint16_t *, char *, size_t); 73 static void f_49(const uint16_t *, char *, size_t); 74 static void f_4a(const uint16_t *, char *, size_t); 75 static void f_4b(const uint16_t *, char *, size_t); 76 static void f_4c(const uint16_t *, char *, size_t); 77 static void f_4d(const uint16_t *, char *, size_t); 78 static void f_4e(const uint16_t *, char *, size_t); 79 static void f_4f(const uint16_t *, char *, size_t); 80 static void f_50(const uint16_t *, char *, size_t); 81 static void f_60(const uint16_t *, char *, size_t); 82 static void f_64(const uint16_t *, char *, size_t); 83 static void f_68(const uint16_t *, char *, size_t); 84 static void f_6c(const uint16_t *, char *, size_t); 85 static void f_70(const uint16_t *, char *, size_t); 86 static void f_80(const uint16_t *, char *, size_t); 87 static void f_90(const uint16_t *, char *, size_t); 88 static void f_a0(const uint16_t *, char *, size_t); 89 static void f_b0(const uint16_t *, char *, size_t); 90 static void f_c0(const uint16_t *, char *, size_t); 91 static void f_d0(const uint16_t *, char *, size_t); 92 static void f_e0(const uint16_t *, char *, size_t); 93 static void f_f0(const uint16_t *, char *, size_t); 94 static void f_f4(const uint16_t *, char *, size_t); 95 static void f_f8(const uint16_t *, char *, size_t); 96 static void f_fc(const uint16_t *, char *, size_t); 97 static void f_fd(const uint16_t *, char *, size_t); 98 static void f_fe(const uint16_t *, char *, size_t); 99 100 typedef void (*rasm_t)(const uint16_t *, char *, size_t); 101 static rasm_t f[16][16] = { 102 { /* [0][0-7] */ NULL, NULL, f_02, f_03, f_04, f_04, f_04, f_04, 103 /* [0][8-f] */ f_08, f_09, f_0a, f_0b, f_0c, f_0c, f_0c, f_0c }, 104 { /* [1][0-7] */ f_10, f_10, f_10, f_10, f_10, f_10, f_10, f_10, 105 /* [1][8-f] */ f_10, f_10, f_10, f_10, f_10, f_10, f_10, f_10 }, 106 { /* [2][0-7] */ f_20, f_20, f_20, f_20, f_24, f_24, f_24, f_24, 107 /* [2][8-f] */ f_28, f_28, f_28, f_28, f_2c, f_2c, f_2c, f_2c }, 108 { /* [3][0-7] */ f_30, f_30, f_30, f_30, f_34, f_34, f_34, f_34, 109 /* [3][8-f] */ f_38, f_38, f_38, f_38, f_3c, f_3c, f_3c, f_3c }, 110 { /* [4][0-7] */ f_40, f_41, f_42, f_43, f_44, f_45, f_46, f_47, 111 /* [4][8-f] */ f_48, f_49, f_4a, f_4b, f_4c, f_4d, f_4e, f_4f }, 112 { /* [5][0-7] */ f_50, f_50, f_50, f_50, f_50, f_50, f_50, f_50, 113 /* [5][8-f] */ f_50, f_50, f_50, f_50, f_50, f_50, f_50, f_50 }, 114 { /* [6][0-7] */ f_60, f_60, f_60, f_60, f_64, f_64, f_64, f_64, 115 /* [6][8-f] */ f_68, f_68, f_68, f_68, f_6c, f_6c, f_6c, f_6c }, 116 { /* [7][0-7] */ f_70, f_70, f_70, f_70, f_70, f_70, f_70, f_70, 117 /* [7][8-f] */ f_70, f_70, f_70, f_70, f_70, f_70, f_70, f_70 }, 118 { /* [8][0-7] */ f_80, f_80, f_80, f_80, f_80, f_80, f_80, f_80, 119 /* [8][8-f] */ f_80, f_80, f_80, f_80, f_80, f_80, f_80, f_80 }, 120 { /* [9][0-7] */ f_90, f_90, f_90, f_90, f_90, f_90, f_90, f_90, 121 /* [9][8-f] */ f_90, f_90, f_90, f_90, f_90, f_90, f_90, f_90 }, 122 { /* [a][0-7] */ f_a0, f_a0, f_a0, f_a0, f_a0, f_a0, f_a0, f_a0, 123 /* [a][8-f] */ f_a0, f_a0, f_a0, f_a0, f_a0, f_a0, f_a0, f_a0 }, 124 { /* [b][0-7] */ f_b0, f_b0, f_b0, f_b0, f_b0, f_b0, f_b0, f_b0, 125 /* [b][8-f] */ f_b0, f_b0, f_b0, f_b0, f_b0, f_b0, f_b0, f_b0 }, 126 { /* [c][0-7] */ f_c0, f_c0, f_c0, f_c0, f_c0, f_c0, f_c0, f_c0, 127 /* [c][8-f] */ f_c0, f_c0, f_c0, f_c0, f_c0, f_c0, f_c0, f_c0 }, 128 { /* [d][0-7] */ f_d0, f_d0, f_d0, f_d0, f_d0, f_d0, f_d0, f_d0, 129 /* [d][8-f] */ f_d0, f_d0, f_d0, f_d0, f_d0, f_d0, f_d0, f_d0 }, 130 { /* [e][0-7] */ f_e0, f_e0, f_e0, f_e0, f_e0, f_e0, f_e0, f_e0, 131 /* [e][8-f] */ f_e0, f_e0, f_e0, f_e0, f_e0, f_e0, f_e0, f_e0 }, 132 { /* [f][0-7] */ f_f0, f_f0, f_f0, f_f0, f_f4, f_f4, f_f4, f_f4, 133 /* [f][8-f] */ f_f8, f_f8, f_f8, f_f8, f_fc, f_fd, f_fe, NULL } 134 }; 135 136 db_addr_t 137 db_disasm(db_addr_t loc, bool altfmt) 138 { 139 const void *pc = (void *)loc; 140 char line[40]; 141 142 get_opcode(pc, line, sizeof(line)); 143 db_printf("%s\n", line); 144 145 return (loc + 2); 146 } 147 148 149 static uint16_t 150 get_insn(const void *pc) 151 { 152 vaddr_t addr = (uintptr_t)pc; 153 uint16_t insn; 154 int retval; 155 156 if (addr & 1) 157 db_error("Instruction address not aligned\n"); 158 159 if (addr >= SH3_P4SEG_BASE) /* p4: on-chip i/o registers */ 160 db_error("Instruction address in P4 area\n"); 161 162 if ((intptr_t)addr >= 0) { /* p0: user-space */ 163 if (ufetch_16(pc, &insn)) 164 db_error("Instruction fetch fault (user)\n"); 165 } 166 else { /* kernel p1/p2/p3 */ 167 retval = kcopy(pc, &insn, sizeof(insn)); 168 if (retval != 0) 169 db_error("Instruction fetch fault (kernel)\n"); 170 } 171 172 return insn; 173 } 174 175 static void 176 get_opcode(const uint16_t *pc, char *buf, size_t len) 177 { 178 uint16_t insn = get_insn(pc); 179 int n0, n3; 180 181 strlcpy(buf, "????", len); 182 183 n0 = (insn & 0xf000) >> 12; 184 n3 = (insn & 0x000f); 185 186 if (f[n0][n3] != NULL) { 187 (*f[n0][n3])(pc, buf, len); 188 } 189 } 190 191 static void 192 f_02(const uint16_t *pc, char *buf, size_t len) 193 { 194 uint16_t insn = get_insn(pc); 195 int rn, type, md; 196 197 rn = (insn & 0x0f00) >> 8; 198 type = (insn & 0x00c0) >> 6; 199 md = (insn & 0x0030) >> 4; 200 201 switch (type) { 202 case 0: 203 switch (md) { 204 case 0: 205 snprintf(buf, len, "stc sr, r%d", rn); 206 break; 207 208 case 1: 209 snprintf(buf, len, "stc gbr, r%d", rn); 210 break; 211 212 case 2: 213 snprintf(buf, len, "stc vbr, r%d", rn); 214 break; 215 216 case 3: 217 snprintf(buf, len, "stc ssr, r%d", rn); 218 break; 219 220 } 221 break; 222 223 case 1: 224 switch (md) { 225 case 0: 226 snprintf(buf, len, "stc spc, r%d", rn); 227 break; 228 } 229 break; 230 231 case 2: 232 snprintf(buf, len, "stc r%d_bank, r%d", md, rn); 233 break; 234 235 case 3: 236 snprintf(buf, len, "stc r%d_bank, r%d", md+4, rn); 237 break; 238 } /* end of switch (type) */ 239 } 240 241 static void 242 f_03(const uint16_t *pc, char *buf, size_t len) 243 { 244 uint16_t insn = get_insn(pc); 245 int rn, type, md; 246 247 rn = (insn & 0x0f00) >> 8; 248 type = (insn & 0x00c0) >> 6; 249 md = (insn & 0x0030) >> 4; 250 251 switch (type) { 252 case 0: 253 switch (md) { 254 case 0: 255 snprintf(buf, len, "bsrf r%d", rn); 256 break; 257 258 case 2: 259 snprintf(buf, len, "braf r%d", rn); 260 break; 261 } 262 break; 263 264 case 2: 265 switch (md) { 266 case 0: 267 snprintf(buf, len, "pref @r%d", rn); 268 break; 269 } 270 break; 271 } /* end of switch (type) */ 272 } 273 274 275 static void 276 f_04(const uint16_t *pc, char *buf, size_t len) 277 { 278 uint16_t insn = get_insn(pc); 279 int rn, rm, md; 280 281 rn = (insn & 0x0f00) >> 8; 282 rm = (insn & 0x00f0) >> 4; 283 md = (insn & 0x0003); 284 285 switch (md) { 286 case 0: 287 snprintf(buf, len, "mov.b r%d, @(r0, r%d)", rm, rn); 288 break; 289 290 case 1: 291 snprintf(buf, len, "mov.w r%d, @(r0, r%d)", rm, rn); 292 break; 293 294 case 2: 295 snprintf(buf, len, "mov.l r%d, @(r0, r%d)", rm, rn); 296 break; 297 298 case 3: 299 snprintf(buf, len, "mul.l r%d, r%d)", rm, rn); 300 break; 301 } /* end of switch (md) */ 302 } 303 304 static void 305 f_08(const uint16_t *pc, char *buf, size_t len) 306 { 307 uint16_t insn = get_insn(pc); 308 int n1, type, md; 309 310 n1 = (insn & 0x0f00) >> 8; 311 type = (insn & 0x00c0) >> 6; 312 md = (insn & 0x0030) >> 4; 313 314 if (n1 != 0) 315 return; 316 317 switch (type) { 318 case 0: 319 switch (md) { 320 case 0: 321 snprintf(buf, len, "clrt"); 322 break; 323 324 case 1: 325 snprintf(buf, len, "sett"); 326 break; 327 328 case 2: 329 snprintf(buf, len, "clrmac"); 330 break; 331 332 case 3: 333 snprintf(buf, len, "ldtlb"); 334 break; 335 } 336 break; 337 338 case 1: 339 switch (md) { 340 case 0: 341 snprintf(buf, len, "clrs"); 342 break; 343 344 case 1: 345 snprintf(buf, len, "sets"); 346 break; 347 } 348 break; 349 } /* end of switch (type) */ 350 } 351 352 static void 353 f_09(const uint16_t *pc, char *buf, size_t len) 354 { 355 uint16_t insn = get_insn(pc); 356 int rn, fx; 357 358 rn = (insn & 0x0f00) >> 8; 359 fx = (insn & 0x00f0) >> 4; 360 361 switch (fx) { 362 case 0: 363 if (rn != 0) 364 return; 365 snprintf(buf, len, "nop"); 366 break; 367 368 case 1: 369 if (rn != 0) 370 return; 371 snprintf(buf, len, "div0u"); 372 break; 373 374 case 2: 375 snprintf(buf, len, "movt r%d", rn); 376 break; 377 } /* end of switch (fx) */ 378 } 379 380 static void 381 f_0a(const uint16_t *pc, char *buf, size_t len) 382 { 383 uint16_t insn = get_insn(pc); 384 int rn, type, md; 385 386 rn = (insn & 0x0f00) >> 8; 387 type = (insn & 0x00c0) >> 6; 388 md = (insn & 0x0030) >> 4; 389 390 switch (type) { 391 case 0: 392 switch (md) { 393 case 0: 394 snprintf(buf, len, "sts mach, r%d", rn); 395 break; 396 397 case 1: 398 snprintf(buf, len, "sts macl, r%d", rn); 399 break; 400 401 case 2: 402 snprintf(buf, len, "sts pr, r%d", rn); 403 break; 404 } 405 break; 406 407 case 1: 408 switch (md) { 409 case 1: 410 snprintf(buf, len, "sts fpul, r%d", rn); 411 break; 412 413 case 2: 414 snprintf(buf, len, "sts fpscr, r%d", rn); 415 break; 416 } 417 break; 418 } /* end of switch (type) */ 419 } 420 421 static void 422 f_0b(const uint16_t *pc, char *buf, size_t len) 423 { 424 uint16_t insn = get_insn(pc); 425 int n1, fx; 426 427 n1 = (insn & 0x0f00) >> 8; 428 if (n1 != 0) 429 return; 430 431 fx = (insn & 0x00f0) >> 4; 432 switch (fx) { 433 case 0: 434 snprintf(buf, len, "rts"); 435 break; 436 437 case 1: 438 snprintf(buf, len, "sleep"); 439 break; 440 441 case 2: 442 snprintf(buf, len, "rte"); 443 break; 444 } /* end of switch (fx) */ 445 } 446 447 static void 448 f_0c(const uint16_t *pc, char *buf, size_t len) 449 { 450 uint16_t insn = get_insn(pc); 451 int rn, rm, md; 452 453 rn = (insn & 0x0f00) >> 8; 454 rm = (insn & 0x00f0) >> 4; 455 md = (insn & 0x0003); 456 457 switch (md) { 458 case 0: 459 snprintf(buf, len, "mov.b @(r0, r%d), r%d", rm, rn); 460 break; 461 462 case 1: 463 snprintf(buf, len, "mov.w @(r0, r%d), r%d", rm, rn); 464 break; 465 466 case 2: 467 snprintf(buf, len, "mov.l @(r0, r%d), r%d", rm, rn); 468 break; 469 470 case 3: 471 snprintf(buf, len, "mac.l @r%d+, r%d+", rm, rn); 472 break; 473 } /* end of switch (md) */ 474 } 475 476 static void 477 f_10(const uint16_t *pc, char *buf, size_t len) 478 { 479 uint16_t insn = get_insn(pc); 480 int rn, rm, disp; 481 482 rn = (insn & 0x0f00) >> 8; 483 rm = (insn & 0x00f0) >> 4; 484 disp = (insn & 0x000f); 485 disp *= 4; 486 487 snprintf(buf, len, "mov.l r%d, @(%d, r%d)", rm, disp, rn); 488 } 489 490 static void 491 f_20(const uint16_t *pc, char *buf, size_t len) 492 { 493 uint16_t insn = get_insn(pc); 494 int rn, rm, md; 495 496 rn = (insn & 0x0f00) >> 8; 497 rm = (insn & 0x00f0) >> 4; 498 md = (insn & 0x0003); 499 500 switch (md) { 501 case 0: 502 snprintf(buf, len, "mov.b r%d, @r%d", rm, rn); 503 break; 504 505 case 1: 506 snprintf(buf, len, "mov.w r%d, @r%d", rm, rn); 507 break; 508 509 case 2: 510 snprintf(buf, len, "mov.l r%d, @r%d", rm, rn); 511 break; 512 } /* end of switch (md) */ 513 } 514 515 516 static void 517 f_24(const uint16_t *pc, char *buf, size_t len) 518 { 519 uint16_t insn = get_insn(pc); 520 int rn, rm, md; 521 522 rn = (insn & 0x0f00) >> 8; 523 rm = (insn & 0x00f0) >> 4; 524 md = (insn & 0x0003); 525 526 switch (md) { 527 case 0: 528 snprintf(buf, len, "mov.b r%d, @-r%d", rm, rn); 529 break; 530 531 case 1: 532 snprintf(buf, len, "mov.w r%d, @-r%d", rm, rn); 533 break; 534 535 case 2: 536 snprintf(buf, len, "mov.l r%d, @-r%d", rm, rn); 537 break; 538 539 case 3: 540 snprintf(buf, len, "div0s r%d, r%d)", rm, rn); 541 break; 542 } /* end of switch (md) */ 543 } 544 545 static void 546 f_28(const uint16_t *pc, char *buf, size_t len) 547 { 548 uint16_t insn = get_insn(pc); 549 int rn, rm, md; 550 551 rn = (insn & 0x0f00) >> 8; 552 rm = (insn & 0x00f0) >> 4; 553 md = (insn & 0x0003); 554 555 switch (md) { 556 case 0: 557 snprintf(buf, len, "tst r%d, r%d", rm, rn); 558 break; 559 560 case 1: 561 snprintf(buf, len, "and r%d, r%d", rm, rn); 562 break; 563 564 case 2: 565 snprintf(buf, len, "xor r%d, r%d", rm, rn); 566 break; 567 568 case 3: 569 snprintf(buf, len, "or r%d, r%d", rm, rn); 570 break; 571 } /* end of switch (md) */ 572 } 573 574 575 static void 576 f_2c(const uint16_t *pc, char *buf, size_t len) 577 { 578 uint16_t insn = get_insn(pc); 579 int rn, rm, md; 580 581 rn = (insn & 0x0f00) >> 8; 582 rm = (insn & 0x00f0) >> 4; 583 md = (insn & 0x0003); 584 585 switch (md) { 586 case 0: 587 snprintf(buf, len, "cmp/str r%d, r%d", rm, rn); 588 break; 589 590 case 1: 591 snprintf(buf, len, "xtrct r%d, r%d", rm, rn); 592 break; 593 594 case 2: 595 snprintf(buf, len, "mulu.w r%d, r%d", rm, rn); 596 break; 597 598 case 3: 599 snprintf(buf, len, "muls.w r%d, r%d", rm, rn); 600 break; 601 } /* end of switch (md) */ 602 } 603 604 static void 605 f_30(const uint16_t *pc, char *buf, size_t len) 606 { 607 uint16_t insn = get_insn(pc); 608 int rn, rm, md; 609 610 rn = (insn & 0x0f00) >> 8; 611 rm = (insn & 0x00f0) >> 4; 612 md = (insn & 0x0003); 613 614 switch (md) { 615 case 0: 616 snprintf(buf, len, "cmp/eq r%d, r%d", rm, rn); 617 break; 618 619 case 2: 620 snprintf(buf, len, "cmp/hs r%d, r%d", rm, rn); 621 break; 622 623 case 3: 624 snprintf(buf, len, "cmp/ge r%d, r%d", rm, rn); 625 break; 626 } /* end of switch (md) */ 627 } 628 629 630 static void 631 f_34(const uint16_t *pc, char *buf, size_t len) 632 { 633 uint16_t insn = get_insn(pc); 634 int rn, rm, md; 635 636 rn = (insn & 0x0f00) >> 8; 637 rm = (insn & 0x00f0) >> 4; 638 md = (insn & 0x0003); 639 640 switch (md) { 641 case 0: 642 snprintf(buf, len, "div1 r%d, r%d", rm, rn); 643 break; 644 645 case 1: 646 snprintf(buf, len, "dmulu.l r%d, r%d", rm, rn); 647 break; 648 649 case 2: 650 snprintf(buf, len, "cmp/hi r%d, r%d", rm, rn); 651 break; 652 653 case 3: 654 snprintf(buf, len, "cmp/gt r%d, r%d", rm, rn); 655 break; 656 } /* end of switch (md) */ 657 } 658 659 static void 660 f_38(const uint16_t *pc, char *buf, size_t len) 661 { 662 uint16_t insn = get_insn(pc); 663 int rn, rm, md; 664 665 rn = (insn & 0x0f00) >> 8; 666 rm = (insn & 0x00f0) >> 4; 667 md = (insn & 0x0003); 668 669 switch (md) { 670 case 0: 671 snprintf(buf, len, "sub r%d, r%d", rm, rn); 672 break; 673 674 case 2: 675 snprintf(buf, len, "subc r%d, r%d", rm, rn); 676 break; 677 678 case 3: 679 snprintf(buf, len, "subv r%d, r%d", rm, rn); 680 break; 681 } /* end of switch (md) */ 682 } 683 684 685 static void 686 f_3c(const uint16_t *pc, char *buf, size_t len) 687 { 688 uint16_t insn = get_insn(pc); 689 int rn, rm, md; 690 691 rn = (insn & 0x0f00) >> 8; 692 rm = (insn & 0x00f0) >> 4; 693 md = (insn & 0x0003); 694 695 switch (md) { 696 case 0: 697 snprintf(buf, len, "add r%d, r%d", rm, rn); 698 break; 699 700 case 1: 701 snprintf(buf, len, "dmulu.l r%d, r%d", rm, rn); 702 break; 703 704 case 2: 705 snprintf(buf, len, "addc r%d, r%d", rm, rn); 706 break; 707 708 case 3: 709 snprintf(buf, len, "addv r%d, r%d", rm, rn); 710 break; 711 } /* end of switch (md) */ 712 } 713 714 715 static void 716 f_40(const uint16_t *pc, char *buf, size_t len) 717 { 718 uint16_t insn = get_insn(pc); 719 int rn, fx; 720 721 rn = (insn & 0x0f00) >> 8; 722 fx = (insn & 0x00f0) >> 4; 723 724 switch (fx) { 725 case 0: 726 snprintf(buf, len, "shll r%d", rn); 727 break; 728 729 case 1: 730 snprintf(buf, len, "dt r%d", rn); 731 break; 732 733 case 2: 734 snprintf(buf, len, "shal r%d", rn); 735 break; 736 } /* end of switch (fx) */ 737 } 738 739 static void 740 f_41(const uint16_t *pc, char *buf, size_t len) 741 { 742 uint16_t insn = get_insn(pc); 743 int rn, fx; 744 745 rn = (insn & 0x0f00) >> 8; 746 fx = (insn & 0x00f0) >> 4; 747 748 switch (fx) { 749 case 0: 750 snprintf(buf, len, "shlr r%d", rn); 751 break; 752 753 case 1: 754 snprintf(buf, len, "cmp/pz r%d", rn); 755 break; 756 757 case 2: 758 snprintf(buf, len, "shar r%d", rn); 759 break; 760 } /* end of switch (fx) */ 761 } 762 763 764 static void 765 f_42(const uint16_t *pc, char *buf, size_t len) 766 { 767 uint16_t insn = get_insn(pc); 768 int rn, type, md; 769 770 rn = (insn & 0x0f00) >> 8; 771 type = (insn & 0x00c0) >> 6; 772 md = (insn & 0x0030) >> 4; 773 774 switch (type) { 775 case 0: 776 switch (md) { 777 case 0: 778 snprintf(buf, len, "sts.l mach, @-r%d", rn); 779 break; 780 781 case 1: 782 snprintf(buf, len, "sts.l macl, @-r%d", rn); 783 break; 784 785 case 2: 786 snprintf(buf, len, "sts.l pr, @-r%d", rn); 787 break; 788 } 789 break; 790 791 case 1: 792 switch (md) { 793 case 1: 794 snprintf(buf, len, "sts.l fpul, @-r%d", rn); 795 break; 796 797 case 2: 798 snprintf(buf, len, "sts.l fpscr, @-r%d", rn); 799 break; 800 } 801 break; 802 } /* end of switch (type) */ 803 } 804 805 static void 806 f_43(const uint16_t *pc, char *buf, size_t len) 807 { 808 uint16_t insn = get_insn(pc); 809 int rn, type, md; 810 811 rn = (insn & 0x0f00) >> 8; 812 type = (insn & 0x00c0) >> 6; 813 md = (insn & 0x0030) >> 4; 814 815 switch (type) { 816 case 0: 817 switch (md) { 818 case 0: 819 snprintf(buf, len, "stc.l sr, @-r%d", rn); 820 break; 821 822 case 1: 823 snprintf(buf, len, "stc.l gbr, @-r%d", rn); 824 break; 825 826 case 2: 827 snprintf(buf, len, "stc.l vbr, @-r%d", rn); 828 break; 829 830 case 3: 831 snprintf(buf, len, "stc.l ssr, @-r%d", rn); 832 break; 833 } 834 break; 835 836 case 1: 837 switch (md) { 838 case 0: 839 snprintf(buf, len, "stc.l spc, @-r%d", rn); 840 break; 841 } 842 break; 843 844 case 2: 845 snprintf(buf, len, "stc.l r%d_bank, @-r%d", md, rn); 846 break; 847 848 case 3: 849 snprintf(buf, len, "stc.l r%d_bank, @-r%d", md+4, rn); 850 break; 851 } /* end of switch (type) */ 852 } 853 854 static void 855 f_44(const uint16_t *pc, char *buf, size_t len) 856 { 857 uint16_t insn = get_insn(pc); 858 int rn, fx; 859 860 rn = (insn & 0x0f00) >> 8; 861 fx = (insn & 0x00f0) >> 4; 862 863 switch (fx) { 864 case 0: 865 snprintf(buf, len, "rotl r%d", rn); 866 break; 867 868 case 2: 869 snprintf(buf, len, "rotcl r%d", rn); 870 break; 871 } /* end of switch (fx) */ 872 } 873 874 static void 875 f_45(const uint16_t *pc, char *buf, size_t len) 876 { 877 uint16_t insn = get_insn(pc); 878 int rn, fx; 879 880 rn = (insn & 0x0f00) >> 8; 881 fx = (insn & 0x00f0) >> 4; 882 883 switch (fx) { 884 case 0: 885 snprintf(buf, len, "rotr r%d", rn); 886 break; 887 888 case 1: 889 snprintf(buf, len, "cmp/pl r%d", rn); 890 break; 891 892 case 2: 893 snprintf(buf, len, "rotcr r%d", rn); 894 break; 895 } /* end of switch (fx) */ 896 } 897 898 static void 899 f_46(const uint16_t *pc, char *buf, size_t len) 900 { 901 uint16_t insn = get_insn(pc); 902 int rm, type, md; 903 904 rm = (insn & 0x0f00) >> 8; 905 type = (insn & 0x00c0) >> 6; 906 md = (insn & 0x0030) >> 4; 907 908 switch (type) { 909 case 0: 910 switch (md) { 911 case 0: 912 snprintf(buf, len, "lds.l @r%d+, mach", rm); 913 break; 914 915 case 1: 916 snprintf(buf, len, "lds.l @r%d+, macl", rm); 917 break; 918 919 case 2: 920 snprintf(buf, len, "lds.l @r%d+, pr", rm); 921 break; 922 } 923 break; 924 925 case 1: 926 switch (md) { 927 case 1: 928 snprintf(buf, len, "lds.l @r%d+, fpul", rm); 929 break; 930 931 case 2: 932 snprintf(buf, len, "lds.l @r%d+, fpscr", rm); 933 break; 934 } 935 break; 936 } /* end of switch (type) */ 937 } 938 939 static void 940 f_47(const uint16_t *pc, char *buf, size_t len) 941 { 942 uint16_t insn = get_insn(pc); 943 int rm, type, md; 944 945 rm = (insn & 0x0f00) >> 8; 946 type = (insn & 0x00c0) >> 6; 947 md = (insn & 0x0030) >> 4; 948 949 switch (type) { 950 case 0: 951 switch (md) { 952 case 0: 953 snprintf(buf, len, "ldc.l @r%d+, sr", rm); 954 break; 955 956 case 1: 957 snprintf(buf, len, "ldc.l @r%d+, gbr", rm); 958 break; 959 960 case 2: 961 snprintf(buf, len, "ldc.l @r%d+, vbr", rm); 962 break; 963 964 case 3: 965 snprintf(buf, len, "ldc.l @r%d+, ssr", rm); 966 break; 967 } 968 break; 969 970 case 1: 971 switch (md) { 972 case 0: 973 snprintf(buf, len, "ldc.l @r%d+, spc", rm); 974 break; 975 } 976 break; 977 978 case 2: 979 snprintf(buf, len, "ldc.l @r%d+, r%d_bank", rm, md); 980 break; 981 982 case 3: 983 snprintf(buf, len, "ldc.l @r%d+, r%d_bank", rm, md+4); 984 break; 985 } /* end of switch (type) */ 986 } 987 988 static void 989 f_48(const uint16_t *pc, char *buf, size_t len) 990 { 991 uint16_t insn = get_insn(pc); 992 int rn, fx; 993 994 rn = (insn & 0x0f00) >> 8; 995 fx = (insn & 0x00f0) >> 4; 996 997 switch (fx) { 998 case 0: 999 snprintf(buf, len, "shll2 r%d", rn); 1000 break; 1001 1002 case 1: 1003 snprintf(buf, len, "shll8 r%d", rn); 1004 break; 1005 1006 case 2: 1007 snprintf(buf, len, "shll16 r%d", rn); 1008 break; 1009 } /* end of switch (fx) */ 1010 } 1011 1012 static void 1013 f_49(const uint16_t *pc, char *buf, size_t len) 1014 { 1015 uint16_t insn = get_insn(pc); 1016 int rn, fx; 1017 1018 rn = (insn & 0x0f00) >> 8; 1019 fx = (insn & 0x00f0) >> 4; 1020 1021 switch (fx) { 1022 case 0: 1023 snprintf(buf, len, "shlr2 r%d", rn); 1024 break; 1025 1026 case 1: 1027 snprintf(buf, len, "shlr8 r%d", rn); 1028 break; 1029 1030 case 2: 1031 snprintf(buf, len, "shlr16 r%d", rn); 1032 break; 1033 } /* end of switch (fx) */ 1034 } 1035 1036 static void 1037 f_4a(const uint16_t *pc, char *buf, size_t len) 1038 { 1039 uint16_t insn = get_insn(pc); 1040 int rm, type, md; 1041 1042 rm = (insn & 0x0f00) >> 8; 1043 type = (insn & 0x00c0) >> 6; 1044 md = (insn & 0x0030) >> 4; 1045 1046 switch (type) { 1047 case 0: 1048 switch (md) { 1049 case 0: 1050 snprintf(buf, len, "lds r%d, mach", rm); 1051 break; 1052 1053 case 1: 1054 snprintf(buf, len, "lds r%d, macl", rm); 1055 break; 1056 1057 case 2: 1058 snprintf(buf, len, "lds r%d, pr", rm); 1059 break; 1060 } 1061 break; 1062 1063 case 1: 1064 switch (md) { 1065 case 1: 1066 snprintf(buf, len, "lds r%d, fpul", rm); 1067 break; 1068 1069 case 2: 1070 snprintf(buf, len, "lds r%d, fpscr", rm); 1071 break; 1072 } 1073 break; 1074 } /* end of switch (type) */ 1075 } 1076 1077 static void 1078 f_4b(const uint16_t *pc, char *buf, size_t len) 1079 { 1080 uint16_t insn = get_insn(pc); 1081 int rm, fx; 1082 1083 rm = (insn & 0x0f00) >> 8; 1084 fx = (insn & 0x00f0) >> 4; 1085 1086 switch (fx) { 1087 case 0: 1088 snprintf(buf, len, "jsr @r%d", rm); 1089 break; 1090 1091 case 1: 1092 snprintf(buf, len, "tas.b @r%d", rm); 1093 break; 1094 1095 case 2: 1096 snprintf(buf, len, "jmp @r%d", rm); 1097 break; 1098 } /* end of switch (fx) */ 1099 } 1100 1101 static void 1102 f_4c(const uint16_t *pc, char *buf, size_t len) 1103 { 1104 uint16_t insn = get_insn(pc); 1105 int rn, rm; 1106 1107 rn = (insn & 0x0f00) >> 8; 1108 rm = (insn & 0x00f0) >> 4; 1109 snprintf(buf, len, "shad r%d, r%d", rm, rn); 1110 } 1111 1112 static void 1113 f_4d(const uint16_t *pc, char *buf, size_t len) 1114 { 1115 uint16_t insn = get_insn(pc); 1116 int rn, rm; 1117 1118 rn = (insn & 0x0f00) >> 8; 1119 rm = (insn & 0x00f0) >> 4; 1120 snprintf(buf, len, "shld r%d, r%d", rm, rn); 1121 } 1122 1123 static void 1124 f_4e(const uint16_t *pc, char *buf, size_t len) 1125 { 1126 uint16_t insn = get_insn(pc); 1127 int rm, type, md; 1128 1129 rm = (insn & 0x0f00) >> 8; 1130 type = (insn & 0x00c0) >> 6; 1131 md = (insn & 0x0030) >> 4; 1132 1133 switch (type) { 1134 case 0: 1135 switch (md) { 1136 case 0: 1137 snprintf(buf, len, "ldc r%d, sr", rm); 1138 break; 1139 1140 case 1: 1141 snprintf(buf, len, "ldc r%d, gbr", rm); 1142 break; 1143 1144 case 2: 1145 snprintf(buf, len, "ldc r%d, vbr", rm); 1146 break; 1147 1148 case 3: 1149 snprintf(buf, len, "ldc r%d, ssr", rm); 1150 break; 1151 } 1152 break; 1153 1154 case 1: 1155 switch (md) { 1156 case 0: 1157 snprintf(buf, len, "ldc r%d, spc", rm); 1158 break; 1159 } 1160 break; 1161 1162 case 2: 1163 snprintf(buf, len, "ldc r%d, r%d_bank", rm, md); 1164 break; 1165 1166 case 3: 1167 snprintf(buf, len, "ldc r%d, r%d_bank", rm, md+4); 1168 break; 1169 } /* end of switch (type) */ 1170 } 1171 1172 static void 1173 f_4f(const uint16_t *pc, char *buf, size_t len) 1174 { 1175 uint16_t insn = get_insn(pc); 1176 int rn, rm; 1177 1178 rn = (insn & 0x0f00) >> 8; 1179 rm = (insn & 0x00f0) >> 4; 1180 snprintf(buf, len, "mac.w @r%d+, @r%d+", rm, rn); 1181 } 1182 1183 static void 1184 f_50(const uint16_t *pc, char *buf, size_t len) 1185 { 1186 uint16_t insn = get_insn(pc); 1187 int rn, rm, disp; 1188 1189 rn = (insn & 0x0f00) >> 8; 1190 rm = (insn & 0x00f0) >> 4; 1191 disp = (insn & 0x000f); 1192 disp *= 4; 1193 1194 snprintf(buf, len, "mov.l @(%d, r%d), r%d", disp, rm, rn); 1195 } 1196 1197 static void 1198 f_60(const uint16_t *pc, char *buf, size_t len) 1199 { 1200 uint16_t insn = get_insn(pc); 1201 int rn, rm, md; 1202 1203 rn = (insn & 0x0f00) >> 8; 1204 rm = (insn & 0x00f0) >> 4; 1205 md = (insn & 0x0003); 1206 1207 switch (md) { 1208 case 0: 1209 snprintf(buf, len, "mov.b @r%d, r%d", rm, rn); 1210 break; 1211 1212 case 1: 1213 snprintf(buf, len, "mov.w @r%d, r%d", rm, rn); 1214 break; 1215 1216 case 2: 1217 snprintf(buf, len, "mov.l @r%d, r%d", rm, rn); 1218 break; 1219 1220 case 3: 1221 snprintf(buf, len, "mov r%d, r%d", rm, rn); 1222 break; 1223 } /* end of switch (md) */ 1224 } 1225 1226 static void 1227 f_64(const uint16_t *pc, char *buf, size_t len) 1228 { 1229 uint16_t insn = get_insn(pc); 1230 int rn, rm, md; 1231 1232 rn = (insn & 0x0f00) >> 8; 1233 rm = (insn & 0x00f0) >> 4; 1234 md = (insn & 0x0003); 1235 1236 switch (md) { 1237 case 0: 1238 snprintf(buf, len, "mov.b @r%d+, r%d", rm, rn); 1239 break; 1240 1241 case 1: 1242 snprintf(buf, len, "mov.w @r%d+, r%d", rm, rn); 1243 break; 1244 1245 case 2: 1246 snprintf(buf, len, "mov.l @r%d+, r%d", rm, rn); 1247 break; 1248 1249 case 3: 1250 snprintf(buf, len, "not r%d, r%d", rm, rn); 1251 break; 1252 } /* end of switch (md) */ 1253 } 1254 1255 static void 1256 f_68(const uint16_t *pc, char *buf, size_t len) 1257 { 1258 uint16_t insn = get_insn(pc); 1259 int rn, rm, md; 1260 1261 rn = (insn & 0x0f00) >> 8; 1262 rm = (insn & 0x00f0) >> 4; 1263 md = (insn & 0x0003); 1264 1265 switch (md) { 1266 case 0: 1267 snprintf(buf, len, "swap.b r%d, r%d", rm, rn); 1268 break; 1269 1270 case 1: 1271 snprintf(buf, len, "swap.w r%d, r%d", rm, rn); 1272 break; 1273 1274 case 2: 1275 snprintf(buf, len, "negc r%d, r%d", rm, rn); 1276 break; 1277 1278 case 3: 1279 snprintf(buf, len, "neg r%d, r%d", rm, rn); 1280 break; 1281 } /* end of switch (md) */ 1282 } 1283 1284 static void 1285 f_6c(const uint16_t *pc, char *buf, size_t len) 1286 { 1287 uint16_t insn = get_insn(pc); 1288 int rn, rm, md; 1289 1290 rn = (insn & 0x0f00) >> 8; 1291 rm = (insn & 0x00f0) >> 4; 1292 md = (insn & 0x0003); 1293 1294 switch (md) { 1295 case 0: 1296 snprintf(buf, len, "extu.b r%d, r%d", rm, rn); 1297 break; 1298 1299 case 1: 1300 snprintf(buf, len, "extu.w r%d, r%d", rm, rn); 1301 break; 1302 1303 case 2: 1304 snprintf(buf, len, "exts.b r%d, r%d", rm, rn); 1305 break; 1306 1307 case 3: 1308 snprintf(buf, len, "exts.w r%d, r%d", rm, rn); 1309 break; 1310 } /* end of switch (md) */ 1311 } 1312 1313 static void 1314 f_70(const uint16_t *pc, char *buf, size_t len) 1315 { 1316 uint16_t insn = get_insn(pc); 1317 int rn, imm; 1318 1319 rn = (insn & 0x0f00) >> 8; 1320 imm = (int) ((char) (insn & 0x00ff)); 1321 1322 snprintf(buf, len, "add #0x%x, r%d", imm, rn); 1323 } 1324 1325 static void 1326 f_80(const uint16_t *pc, char *buf, size_t len) 1327 { 1328 uint16_t insn = get_insn(pc); 1329 int type, md, rn, disp; 1330 1331 type = (insn & 0x0c00) >> 10; 1332 md = (insn & 0x0300) >> 8; 1333 1334 switch (type) { 1335 case 0: 1336 rn = (insn & 0x00f0) >> 4; 1337 disp = (insn & 0x000f); 1338 1339 switch (md) { 1340 case 0: 1341 snprintf(buf, len, "mov.b r0, @(%d, r%d)", disp, rn); 1342 break; 1343 1344 case 1: 1345 disp *= 2; 1346 snprintf(buf, len, "mov.w r0, @(%d, r%d)", disp, rn); 1347 break; 1348 } 1349 break; 1350 1351 case 1: 1352 rn = (insn & 0x00f0) >> 4; 1353 disp = (insn & 0x000f); 1354 1355 switch (md) { 1356 case 0: 1357 snprintf(buf, len, "mov.b @(%d, r%d), r0", disp, rn); 1358 break; 1359 1360 case 1: 1361 disp *= 2; 1362 snprintf(buf, len, "mov.w @(%d, r%d), r0", disp, rn); 1363 break; 1364 } 1365 break; 1366 1367 case 2: 1368 disp = (insn & 0x00ff); 1369 1370 switch (md) { 1371 case 0: 1372 snprintf(buf, len, "cmp/eq #%d, r0", disp); 1373 break; 1374 1375 case 1: 1376 disp = (int) ((char) disp); 1377 disp *= 2; 1378 snprintf(buf, len, "bt 0x%x", disp); 1379 break; 1380 1381 case 3: 1382 disp = (int) ((char) disp); 1383 disp *= 2; 1384 snprintf(buf, len, "bf 0x%x", disp); 1385 break; 1386 } 1387 break; 1388 1389 case 3: 1390 disp = (int) ((char) (insn & 0x00ff)); 1391 disp *= 2; 1392 1393 switch (md) { 1394 case 1: 1395 snprintf(buf, len, "bt/s 0x%x", disp); 1396 break; 1397 1398 case 3: 1399 snprintf(buf, len, "bf/s 0x%x", disp); 1400 break; 1401 } 1402 break; 1403 } /* end of switch (type) */ 1404 } 1405 1406 static void 1407 f_90(const uint16_t *pc, char *buf, size_t len) 1408 { 1409 uint16_t insn = get_insn(pc); 1410 int rn, disp; 1411 1412 rn = (insn & 0x0f00) >> 8; 1413 disp = (insn & 0x00ff); 1414 disp *= 2; 1415 1416 snprintf(buf, len, "mov.w @(%d, pc), r%d", disp, rn); 1417 } 1418 1419 static void 1420 f_a0(const uint16_t *pc, char *buf, size_t len) 1421 { 1422 uint16_t insn = get_insn(pc); 1423 int disp; 1424 1425 disp = (insn & 0x0fff); 1426 if (disp & 0x0800) /* negative displacement? */ 1427 disp |= 0xfffff000; /* sign extend */ 1428 disp *= 2; 1429 1430 snprintf(buf, len, "bra %d(0x%x)", disp, disp); 1431 } 1432 1433 static void 1434 f_b0(const uint16_t *pc, char *buf, size_t len) 1435 { 1436 uint16_t insn = get_insn(pc); 1437 int disp; 1438 1439 disp = (insn & 0x0fff); 1440 if (disp & 0x0800) /* negative displacement? */ 1441 disp |= 0xfffff000; /* sign extend */ 1442 disp *= 2; 1443 1444 snprintf(buf, len, "bsr %d(0x%x)", disp, disp); 1445 } 1446 1447 static void 1448 f_c0(const uint16_t *pc, char *buf, size_t len) 1449 { 1450 uint16_t insn = get_insn(pc); 1451 int type, md, imm; 1452 1453 type = (insn & 0x0c00) >> 10; 1454 md = (insn & 0x0300) >> 8; 1455 imm = (insn & 0x00ff); 1456 1457 switch (type) { 1458 case 0: 1459 switch (md) { 1460 case 0: 1461 snprintf(buf, len, "mov.b r0, @(%d, gbr)", imm); 1462 break; 1463 1464 case 1: 1465 imm *= 2; 1466 snprintf(buf, len, "mov.w r0, @(%d, gbr)", imm); 1467 break; 1468 1469 case 2: 1470 imm *= 4; 1471 snprintf(buf, len, "mov.l r0, @(%d, gbr)", imm); 1472 break; 1473 1474 case 3: 1475 snprintf(buf, len, "trapa #0x%x", imm); 1476 break; 1477 } 1478 break; 1479 1480 case 1: 1481 switch (md) { 1482 case 0: 1483 snprintf(buf, len, "mov.b @(%d, gbr), r0", imm); 1484 break; 1485 1486 case 1: 1487 imm *= 2; 1488 snprintf(buf, len, "mov.w @(%d, gbr), r0", imm); 1489 break; 1490 1491 case 2: 1492 imm *= 4; 1493 snprintf(buf, len, "mov.l @(%d, gbr), r0", imm); 1494 break; 1495 1496 case 3: 1497 imm *= 4; 1498 snprintf(buf, len, "mova @(%d, pc), r0", imm); 1499 break; 1500 } 1501 break; 1502 1503 case 2: 1504 switch (md) { 1505 case 0: 1506 snprintf(buf, len, "tst #%d, r0", imm); 1507 break; 1508 1509 case 1: 1510 snprintf(buf, len, "and #%d, r0", imm); 1511 break; 1512 1513 case 2: 1514 snprintf(buf, len, "xor #%d, r0", imm); 1515 break; 1516 1517 case 3: 1518 snprintf(buf, len, "or #%d, r0", imm); 1519 break; 1520 } 1521 break; 1522 1523 case 3: 1524 switch (md) { 1525 case 0: 1526 snprintf(buf, len, "tst.b #%d, @(r0, gbr)", imm); 1527 break; 1528 1529 case 1: 1530 snprintf(buf, len, "and.b #%d, @(r0, gbr)", imm); 1531 break; 1532 1533 case 2: 1534 snprintf(buf, len, "xor.b #%d, @(r0, gbr)", imm); 1535 break; 1536 1537 case 3: 1538 snprintf(buf, len, "or.b #%d, @(r0, gbr)", imm); 1539 break; 1540 } 1541 break; 1542 } /* end of switch (type) */ 1543 } 1544 1545 1546 static void 1547 f_d0(const uint16_t *pc, char *buf, size_t len) 1548 { 1549 uint16_t insn = get_insn(pc); 1550 int rn, disp; 1551 1552 rn = (insn & 0x0f00) >> 8; 1553 disp = (insn & 0x00ff); 1554 disp *= 4; 1555 1556 snprintf(buf, len, "mov.l @(%d, pc), r%d", disp, rn); 1557 } 1558 1559 static void 1560 f_e0(const uint16_t *pc, char *buf, size_t len) 1561 { 1562 uint16_t insn = get_insn(pc); 1563 int rn, imm; 1564 1565 rn = (insn & 0x0f00) >> 8; 1566 imm = (int) ((char) (insn & 0x00ff)); 1567 1568 snprintf(buf, len, "mov #0x%x, r%d", imm, rn); 1569 } 1570 1571 static void 1572 f_f0(const uint16_t *pc, char *buf, size_t len) 1573 { 1574 uint16_t insn = get_insn(pc); 1575 int rn, rm, md; 1576 1577 rn = (insn & 0x0f00) >> 8; 1578 rm = (insn & 0x00f0) >> 4; 1579 md = (insn & 0x0003); 1580 1581 switch (md) { 1582 case 0: 1583 snprintf(buf, len, "fadd fr%d, fr%d", rm, rn); 1584 break; 1585 1586 case 1: 1587 snprintf(buf, len, "fsub fr%d, fr%d", rm, rn); 1588 break; 1589 1590 case 2: 1591 snprintf(buf, len, "fmul fr%d, fr%d", rm, rn); 1592 break; 1593 1594 case 3: 1595 snprintf(buf, len, "fdiv fr%d, fr%d", rm, rn); 1596 break; 1597 } /* end of switch (md) */ 1598 } 1599 1600 static void 1601 f_f4(const uint16_t *pc, char *buf, size_t len) 1602 { 1603 uint16_t insn = get_insn(pc); 1604 int rn, rm, md; 1605 1606 rn = (insn & 0x0f00) >> 8; 1607 rm = (insn & 0x00f0) >> 4; 1608 md = (insn & 0x0003); 1609 1610 switch (md) { 1611 case 0: 1612 snprintf(buf, len, "fcmp/eq fr%d, fr%d", rm, rn); 1613 break; 1614 1615 case 1: 1616 snprintf(buf, len, "fcmp/gt fr%d, fr%d", rm, rn); 1617 break; 1618 1619 case 2: 1620 snprintf(buf, len, "fmov.s @(r0, r%d), fr%d", rm, rn); 1621 break; 1622 1623 case 3: 1624 snprintf(buf, len, "fmov.s fr%d, @(r0, r%d)", rm, rn); 1625 break; 1626 } /* end of switch (md) */ 1627 } 1628 1629 static void 1630 f_f8(const uint16_t *pc, char *buf, size_t len) 1631 { 1632 uint16_t insn = get_insn(pc); 1633 int rn, rm, md; 1634 1635 rn = (insn & 0x0f00) >> 8; 1636 rm = (insn & 0x00f0) >> 4; 1637 md = (insn & 0x0003); 1638 1639 switch (md) { 1640 case 0: 1641 snprintf(buf, len, "fmov.s @r%d, fr%d", rm, rn); 1642 break; 1643 1644 case 1: 1645 snprintf(buf, len, "fmov.s @r%d+, fr%d", rm, rn); 1646 break; 1647 1648 case 2: 1649 snprintf(buf, len, "fmov.s fr%d, @r%d", rm, rn); 1650 break; 1651 1652 case 3: 1653 snprintf(buf, len, "fmov.s fr%d, @-r%d", rm, rn); 1654 break; 1655 } /* end of switch (md) */ 1656 } 1657 1658 static void 1659 f_fc(const uint16_t *pc, char *buf, size_t len) 1660 { 1661 uint16_t insn = get_insn(pc); 1662 int rn, rm; 1663 1664 rn = (insn & 0x0f00) >> 8; 1665 rm = (insn & 0x00f0) >> 4; 1666 1667 snprintf(buf, len, "fmov fr%d, fr%d", rm, rn); 1668 } 1669 1670 static void 1671 f_fd(const uint16_t *pc, char *buf, size_t len) 1672 { 1673 uint16_t insn = get_insn(pc); 1674 int rn, type, md; 1675 1676 rn = (insn & 0x0f00) >> 8; 1677 type = (insn & 0x00c0) >> 6; 1678 md = (insn & 0x0030) >> 4; 1679 1680 switch (type) { 1681 case 0: 1682 switch (md) { 1683 case 0: 1684 snprintf(buf, len, "fsts fpul, fr%d", rn); 1685 break; 1686 1687 case 1: 1688 snprintf(buf, len, "flds fr%d, fpul", rn); 1689 break; 1690 1691 case 2: 1692 snprintf(buf, len, "float fpul, fr%d", rn); 1693 break; 1694 1695 case 3: 1696 snprintf(buf, len, "ftrc fr%d, fpul", rn); 1697 break; 1698 } 1699 break; 1700 1701 case 1: 1702 switch (md) { 1703 case 0: 1704 snprintf(buf, len, "fneg fr%d", rn); 1705 break; 1706 1707 case 1: 1708 snprintf(buf, len, "fabs fr%d", rn); 1709 break; 1710 1711 case 2: 1712 snprintf(buf, len, "fsqrt fr%d", rn); 1713 break; 1714 } 1715 break; 1716 1717 case 2: 1718 switch (md) { 1719 case 0: 1720 case 1: 1721 snprintf(buf, len, "fldi%d fr%d", md, rn); 1722 break; 1723 } 1724 break; 1725 } /* end of switch (type) */ 1726 } 1727 1728 static void 1729 f_fe(const uint16_t *pc, char *buf, size_t len) 1730 { 1731 uint16_t insn = get_insn(pc); 1732 int rn, rm; 1733 1734 rn = (insn & 0x0f00) >> 8; 1735 rm = (insn & 0x00f0) >> 4; 1736 1737 snprintf(buf, len, "fmac fr0, fr%d, fr%d", rm, rn); 1738 } 1739
Indexes created Sun Oct 25 00:26:45 UTC 2026