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