1 /* Disassemble Imagination Technologies Meta instructions. 2 Copyright (C) 2013-2016 Free Software Foundation, Inc. 3 Contributed by Imagination Technologies Ltd. 4 5 This library is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 3 of the License, or 8 (at your option) any later version. 9 10 It is distributed in the hope that it will be useful, but WITHOUT 11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 12 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 13 License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 18 MA 02110-1301, USA. */ 19 20 #include "sysdep.h" 21 #include "dis-asm.h" 22 #include "opintl.h" 23 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 28 #include "opcode/metag.h" 29 30 /* Column widths for printing. */ 31 #define PREFIX_WIDTH "10" 32 #define INSN_NAME_WIDTH "10" 33 34 #define OPERAND_WIDTH 92 35 #define ADDR_WIDTH 20 36 #define REG_WIDTH 64 37 #define DSP_PREFIX_WIDTH 17 38 39 /* Value to print if we fail to parse a register name. */ 40 const char unknown_reg[] = "?"; 41 42 /* Return the size of a GET or SET instruction. */ 43 unsigned int 44 metag_get_set_size_bytes (unsigned int opcode) 45 { 46 switch (((opcode) >> 24) & 0x5) 47 { 48 case 0x5: 49 return 8; 50 case 0x4: 51 return 4; 52 case 0x1: 53 return 2; 54 case 0x0: 55 return 1; 56 } 57 return 1; 58 } 59 60 /* Return the size of an extended GET or SET instruction. */ 61 unsigned int 62 metag_get_set_ext_size_bytes (unsigned int opcode) 63 { 64 switch (((opcode) >> 1) & 0x3) 65 { 66 case 0x3: 67 return 8; 68 case 0x2: 69 return 4; 70 case 0x1: 71 return 2; 72 case 0x0: 73 return 1; 74 } 75 return 1; 76 } 77 78 /* Return the size of a conditional SET instruction. */ 79 unsigned int 80 metag_cond_set_size_bytes (unsigned int opcode) 81 { 82 switch (opcode & 0x201) 83 { 84 case 0x201: 85 return 8; 86 case 0x200: 87 return 4; 88 case 0x001: 89 return 2; 90 case 0x000: 91 return 1; 92 } 93 return 1; 94 } 95 96 /* Return a value sign-extended. */ 97 static int 98 sign_extend (int n, unsigned int bits) 99 { 100 int mask = 1 << (bits - 1); 101 return -(n & mask) | n; 102 } 103 104 /* Return the short interpretation of UNIT. */ 105 static unsigned int 106 short_unit (unsigned int unit) 107 { 108 if (unit == UNIT_CT) 109 return UNIT_A1; 110 else 111 return unit; 112 } 113 114 /* Return the register corresponding to UNIT and NUMBER or NULL. */ 115 static const metag_reg * 116 lookup_reg (unsigned int unit, unsigned int number) 117 { 118 size_t i; 119 120 for (i = 0; i < sizeof(metag_regtab)/sizeof(metag_regtab[0]); i++) 121 { 122 const metag_reg *reg = &metag_regtab[i]; 123 124 if (reg->unit == unit && reg->no == number) 125 return reg; 126 } 127 return NULL; 128 } 129 130 131 /* Return the register name corresponding to UNIT and NUMBER or NULL. */ 132 static const char * 133 lookup_reg_name (unsigned int unit, unsigned int number) 134 { 135 const metag_reg *reg; 136 137 reg = lookup_reg (unit, number); 138 139 if (reg) 140 return reg->name; 141 else 142 return unknown_reg; 143 } 144 145 /* Return the unit that is the pair of UNIT. */ 146 static unsigned int 147 get_pair_unit (unsigned int unit) 148 { 149 switch (unit) 150 { 151 case UNIT_D0: 152 return UNIT_D1; 153 case UNIT_D1: 154 return UNIT_D0; 155 case UNIT_A0: 156 return UNIT_A1; 157 case UNIT_A1: 158 return UNIT_A0; 159 default: 160 return unit; 161 } 162 } 163 164 /* Return the name of the pair register for UNIT and NUMBER or NULL. */ 165 static const char * 166 lookup_pair_reg_name (unsigned int unit, unsigned int number) 167 { 168 if (unit == UNIT_FX) 169 return lookup_reg_name (unit, number + 1); 170 else 171 return lookup_reg_name (get_pair_unit (unit), number); 172 } 173 174 /* Return the name of the accumulator register for PART. */ 175 static const char * 176 lookup_acf_name (unsigned int part) 177 { 178 size_t i; 179 180 for (i = 0; i < sizeof(metag_acftab)/sizeof(metag_acftab[0]); i++) 181 { 182 const metag_acf *acf = &metag_acftab[i]; 183 184 if (acf->part == part) 185 return acf->name; 186 } 187 return "ACF.?"; 188 } 189 190 /* Return the register name for the O2R register for UNIT and NUMBER. */ 191 static const char * 192 lookup_o2r (enum metag_unit unit, unsigned int number) 193 { 194 unsigned int o2r_unit; 195 enum metag_unit actual_unit = UNIT_A0; 196 const metag_reg *reg; 197 198 o2r_unit = (number & ~O2R_REG_MASK) >> 3; 199 number = number & O2R_REG_MASK; 200 201 if (unit == UNIT_A0) 202 { 203 switch (o2r_unit) 204 { 205 case 0: 206 actual_unit = UNIT_A1; 207 break; 208 case 1: 209 actual_unit = UNIT_D0; 210 break; 211 case 2: 212 actual_unit = UNIT_RD; 213 break; 214 case 3: 215 actual_unit = UNIT_D1; 216 break; 217 } 218 } 219 else if (unit == UNIT_A1) 220 { 221 switch (o2r_unit) 222 { 223 case 0: 224 actual_unit = UNIT_D1; 225 break; 226 case 1: 227 actual_unit = UNIT_D0; 228 break; 229 case 2: 230 actual_unit = UNIT_RD; 231 break; 232 case 3: 233 actual_unit = UNIT_A0; 234 break; 235 } 236 } 237 else if (unit == UNIT_D0) 238 { 239 switch (o2r_unit) 240 { 241 case 0: 242 actual_unit = UNIT_A1; 243 break; 244 case 1: 245 actual_unit = UNIT_D1; 246 break; 247 case 2: 248 actual_unit = UNIT_RD; 249 break; 250 case 3: 251 actual_unit = UNIT_A0; 252 break; 253 } 254 } 255 else if (unit == UNIT_D1) 256 { 257 switch (o2r_unit) 258 { 259 case 0: 260 actual_unit = UNIT_A1; 261 break; 262 case 1: 263 actual_unit = UNIT_D0; 264 break; 265 case 2: 266 actual_unit = UNIT_RD; 267 break; 268 case 3: 269 actual_unit = UNIT_A0; 270 break; 271 } 272 } 273 274 reg = lookup_reg (actual_unit, number); 275 276 if (reg) 277 return reg->name; 278 else 279 return unknown_reg; 280 } 281 282 /* Return the string for split condition code CODE. */ 283 static const char * 284 lookup_scc_flags (unsigned int code) 285 { 286 size_t i; 287 288 for (i = 0; i < sizeof (metag_dsp_scondtab) / sizeof (metag_dsp_scondtab[0]); i++) 289 { 290 if (metag_dsp_scondtab[i].code == code) 291 { 292 return metag_dsp_scondtab[i].name; 293 } 294 } 295 return NULL; 296 } 297 298 /* Return the string for FPU split condition code CODE. */ 299 static const char * 300 lookup_fpu_scc_flags (unsigned int code) 301 { 302 size_t i; 303 304 for (i = 0; i < sizeof (metag_fpu_scondtab) / sizeof (metag_fpu_scondtab[0]); i++) 305 { 306 if (metag_fpu_scondtab[i].code == code) 307 { 308 return metag_fpu_scondtab[i].name; 309 } 310 } 311 return NULL; 312 } 313 314 /* Print an instruction with PREFIX, NAME and OPERANDS. */ 315 static void 316 print_insn (disassemble_info *outf, const char *prefix, const char *name, 317 const char *operands) 318 { 319 outf->fprintf_func (outf->stream, "%-" PREFIX_WIDTH "s%-" INSN_NAME_WIDTH "s%s", prefix, name, operands); 320 } 321 322 /* Print an instruction with no operands. */ 323 static void 324 print_none (unsigned int insn_word ATTRIBUTE_UNUSED, 325 bfd_vma pc ATTRIBUTE_UNUSED, 326 const insn_template *template, 327 disassemble_info *outf) 328 { 329 outf->fprintf_func (outf->stream, "%-" PREFIX_WIDTH "s%s", "", 330 template->name); 331 } 332 333 /* Print a unit to unit MOV instruction. */ 334 static void 335 print_mov_u2u (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 336 const insn_template *template, 337 disassemble_info *outf) 338 { 339 unsigned int dest_unit, dest_no, src_unit, src_no; 340 unsigned int is_kick = (insn_word & 0x1) && !((insn_word >> 9) & 0x1); 341 unsigned int major = MAJOR_OPCODE (insn_word); 342 unsigned int minor = MINOR_OPCODE (insn_word); 343 char buf[OPERAND_WIDTH]; 344 const char *dest_reg; 345 const char *src_reg; 346 347 dest_unit = (insn_word >> 5) & UNIT_MASK; 348 dest_no = (insn_word >> 14) & REG_MASK; 349 350 dest_reg = lookup_reg_name (dest_unit, dest_no); 351 352 if (is_kick) 353 src_unit = UNIT_TR; 354 else 355 src_unit = (insn_word >> 10) & UNIT_MASK; 356 357 /* This is really an RTI/RTH. No, really. */ 358 if (major == OPC_MISC && 359 minor == 0x3 && 360 src_unit == 0xf) 361 { 362 if (insn_word & 0x800000) 363 outf->fprintf_func (outf->stream, "%-" PREFIX_WIDTH "s%s", "", 364 "RTI"); 365 else 366 outf->fprintf_func (outf->stream, "%-" PREFIX_WIDTH "s%s", "", 367 "RTH"); 368 369 return; 370 } 371 372 src_no = (insn_word >> 19) & REG_MASK; 373 374 src_reg = lookup_reg_name (src_unit, src_no); 375 376 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 377 378 if (dest_unit == UNIT_FX || src_unit == UNIT_FX) 379 print_insn (outf, "F", template->name, buf); 380 else 381 print_insn (outf, "", template->name, buf); 382 } 383 384 /* Print a MOV to port instruction. */ 385 static void 386 print_mov_port (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 387 const insn_template *template, 388 disassemble_info *outf) 389 { 390 unsigned int dest_unit, dest1_no, dest2_no, src_unit, src_no; 391 unsigned int is_movl = MINOR_OPCODE (insn_word) == MOVL_MINOR; 392 char buf[OPERAND_WIDTH]; 393 const char *dest_reg; 394 const char *pair_reg; 395 const char *src_reg; 396 397 if (is_movl) 398 dest_unit = short_unit ((insn_word >> 5) & SHORT_UNIT_MASK); 399 else 400 dest_unit = (insn_word >> 5) & UNIT_MASK; 401 402 dest1_no = (insn_word >> 14) & REG_MASK; 403 dest2_no = (insn_word >> 9) & REG_MASK; 404 405 dest_reg = lookup_reg_name (dest_unit, dest1_no); 406 pair_reg = lookup_pair_reg_name (dest_unit, dest2_no); 407 408 src_unit = UNIT_RD; 409 src_no = 0; 410 411 src_reg = lookup_reg_name (src_unit, src_no); 412 413 if (is_movl) 414 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, pair_reg, src_reg); 415 else 416 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 417 418 if (dest_unit == UNIT_FX) 419 print_insn (outf, "F", template->name, buf); 420 else 421 print_insn (outf, "", template->name, buf); 422 } 423 424 /* Return the number of bits set in rmask. */ 425 static unsigned int hweight (unsigned int rmask) 426 { 427 unsigned int count; 428 429 for (count = 0; rmask; count++) 430 { 431 rmask &= rmask - 1; 432 } 433 434 return count; 435 } 436 437 /* Print a MOVL to TTREC instruction. */ 438 static void 439 print_movl_ttrec (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 440 const insn_template *template, 441 disassemble_info *outf) 442 { 443 unsigned int dest_unit, dest_no, src1_no, src2_no, src_unit; 444 char buf[OPERAND_WIDTH]; 445 const char *dest_reg; 446 const char *src_reg; 447 const char *pair_reg; 448 449 dest_unit = UNIT_TT; 450 dest_no = 3; 451 452 dest_reg = lookup_reg_name (dest_unit, dest_no); 453 454 src1_no = (insn_word >> 19) & REG_MASK; 455 src2_no = (insn_word >> 14) & REG_MASK; 456 457 src_unit = short_unit ((insn_word >> 7) & SHORT_UNIT_MASK); 458 459 src_reg = lookup_reg_name (src_unit, src1_no); 460 pair_reg = lookup_pair_reg_name (src_unit, src2_no); 461 462 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, src_reg, pair_reg); 463 464 print_insn (outf, "", template->name, buf); 465 } 466 467 /* Format a GET or SET address mode string from INSN_WORD into BUF. */ 468 static void 469 get_set_addr_str (char *buf, unsigned int buf_size, unsigned int size, 470 unsigned int insn_word) 471 { 472 const char *base_reg; 473 unsigned int base_unit, base_no; 474 unsigned int imm = (insn_word >> 25) & 1; 475 unsigned int ua = (insn_word >> 7) & 1; 476 unsigned int pp = insn_word & 1; 477 478 base_unit = short_unit ((insn_word >> 5) & SHORT_UNIT_MASK); 479 base_no = (insn_word >> 14) & REG_MASK; 480 481 base_reg = lookup_reg_name (base_unit, base_no); 482 483 if (imm) 484 { 485 int offset = (insn_word >> 8) & GET_SET_IMM_MASK; 486 487 offset = sign_extend (offset, GET_SET_IMM_BITS); 488 489 if (offset == 0) 490 { 491 snprintf (buf, buf_size, "[%s]", base_reg); 492 return; 493 } 494 495 if (offset == 1 && ua) 496 { 497 if (pp) 498 snprintf (buf, buf_size, "[%s++]", base_reg); 499 else 500 snprintf (buf, buf_size, "[++%s]", base_reg); 501 502 return; 503 } 504 else if (offset == -1 && ua) 505 { 506 if (pp) 507 snprintf (buf, buf_size, "[%s--]", base_reg); 508 else 509 snprintf (buf, buf_size, "[--%s]", base_reg); 510 511 return; 512 } 513 514 offset = offset * size; 515 516 if (ua) 517 { 518 if (pp) 519 snprintf (buf, buf_size, "[%s+#%d++]", base_reg, offset); 520 else 521 snprintf (buf, buf_size, "[%s++#%d]", base_reg, offset); 522 } 523 else 524 snprintf (buf, buf_size, "[%s+#%d]", base_reg, offset); 525 } 526 else 527 { 528 const char *offset_reg; 529 unsigned int offset_no; 530 531 offset_no = (insn_word >> 9) & REG_MASK; 532 533 offset_reg = lookup_reg_name (base_unit, offset_no); 534 535 if (ua) 536 { 537 if (pp) 538 snprintf (buf, buf_size, "[%s+%s++]", base_reg, offset_reg); 539 else 540 snprintf (buf, buf_size, "[%s++%s]", base_reg, offset_reg); 541 } 542 else 543 snprintf (buf, buf_size, "[%s+%s]", base_reg, offset_reg); 544 } 545 } 546 547 /* Format an extended GET or SET address mode string from INSN_WORD into BUF. */ 548 static void 549 get_set_ext_addr_str (char *buf, unsigned int buf_size, unsigned int size, 550 unsigned int insn_word) 551 { 552 const char *base_reg; 553 unsigned int base_unit, base_no; 554 int offset; 555 556 base_unit = short_unit ((insn_word >> 5) & SHORT_UNIT_MASK); 557 base_no = insn_word & EXT_BASE_REG_MASK; 558 559 base_reg = lookup_reg_name (base_unit, base_no); 560 561 offset = (insn_word >> 7) & GET_SET_EXT_IMM_MASK; 562 563 offset = sign_extend (offset, GET_SET_EXT_IMM_BITS); 564 565 offset = offset * size; 566 567 if (offset == 0) 568 { 569 snprintf (buf, buf_size, "[%s]", base_reg); 570 } 571 else 572 { 573 snprintf (buf, buf_size, "[%s+#%d]", base_reg, offset); 574 } 575 } 576 577 /* Format an MGET or MSET address mode string from INSN_WORD into BUF. */ 578 static void 579 mget_mset_addr_str (char *buf, unsigned int buf_size, 580 unsigned int insn_word) 581 { 582 const char *base_reg; 583 unsigned int base_unit, base_no; 584 585 base_unit = short_unit ((insn_word >> 5) & SHORT_UNIT_MASK); 586 base_no = (insn_word >> 14) & REG_MASK; 587 588 base_reg = lookup_reg_name (base_unit, base_no); 589 590 snprintf (buf, buf_size, "[%s++]", base_reg); 591 } 592 593 /* Format a conditional SET address mode string from INSN_WORD into BUF. */ 594 static void 595 cond_set_addr_str (char *buf, unsigned int buf_size, 596 unsigned int insn_word) 597 { 598 const char *base_reg; 599 unsigned int base_unit, base_no; 600 601 base_unit = short_unit ((insn_word >> 5) & SHORT_UNIT_MASK); 602 base_no = (insn_word >> 14) & REG_MASK; 603 604 base_reg = lookup_reg_name (base_unit, base_no); 605 606 snprintf (buf, buf_size, "[%s]", base_reg); 607 } 608 609 /* Format a cache instruction address mode string from INSN_WORD into BUF. */ 610 static void 611 cache_addr_str (char *buf, unsigned int buf_size, unsigned int insn_word, 612 int width) 613 { 614 const char *base_reg; 615 unsigned int base_unit, base_no; 616 int offset; 617 618 base_unit = short_unit ((insn_word >> 5) & SHORT_UNIT_MASK); 619 base_no = (insn_word >> 14) & REG_MASK; 620 621 base_reg = lookup_reg_name (base_unit, base_no); 622 623 offset = (insn_word >> 8) & GET_SET_IMM_MASK; 624 625 offset = sign_extend (offset, GET_SET_IMM_BITS); 626 627 offset = offset * width; 628 629 if (offset == 0) 630 { 631 snprintf (buf, buf_size, "[%s]", base_reg); 632 } 633 else 634 { 635 snprintf (buf, buf_size, "[%s+#%d]", base_reg, offset); 636 } 637 } 638 639 /* Format a list of registers starting at REG_UNIT and REG_NO and conforming 640 to RMASK into BUF. */ 641 static void 642 lookup_reg_list (char *reg_buf, size_t buf_len, unsigned int reg_unit, 643 unsigned int reg_no, unsigned int rmask, 644 bfd_boolean is_fpu_64bit) 645 { 646 const char *regs[MGET_MSET_MAX_REGS]; 647 size_t used_regs = 1, i, remaining; 648 649 regs[0] = lookup_reg_name (reg_unit, reg_no); 650 651 for (i = 1; i < MGET_MSET_MAX_REGS; i++) 652 { 653 if (rmask & 1) 654 { 655 if (is_fpu_64bit) 656 regs[used_regs] = lookup_reg_name (reg_unit, reg_no + (i * 2)); 657 else 658 regs[used_regs] = lookup_reg_name (reg_unit, reg_no + i); 659 used_regs++; 660 } 661 rmask = rmask >> 1; 662 } 663 664 remaining = buf_len; 665 666 for (i = 0; i < used_regs; i++) 667 { 668 size_t len; 669 if (i == 0) 670 len = snprintf(reg_buf, remaining, "%s", regs[i]); 671 else 672 len = snprintf(reg_buf, remaining, ",%s", regs[i]); 673 674 reg_buf += len; 675 remaining -= len; 676 } 677 } 678 679 /* Print a GET instruction. */ 680 static void 681 print_get (char *buf, char *addr_buf, unsigned int size, 682 const char *dest_reg, const char *pair_reg, unsigned int reg_unit, 683 const insn_template *template, 684 disassemble_info *outf) 685 { 686 if (size == 8) 687 { 688 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, pair_reg, 689 addr_buf); 690 } 691 else 692 { 693 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, addr_buf); 694 } 695 696 if (reg_unit == UNIT_FX) 697 print_insn (outf, "F", template->name, buf); 698 else 699 print_insn (outf, "", template->name, buf); 700 } 701 702 /* Print a SET instruction. */ 703 static void 704 print_set (char *buf, char *addr_buf, unsigned int size, 705 const char *src_reg, const char *pair_reg, unsigned int reg_unit, 706 const insn_template *template, 707 disassemble_info *outf) 708 { 709 if (size == 8) 710 { 711 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", addr_buf, src_reg, pair_reg); 712 } 713 else 714 { 715 snprintf (buf, OPERAND_WIDTH, "%s,%s", addr_buf, src_reg); 716 } 717 718 if (reg_unit == UNIT_FX) 719 print_insn (outf, "F", template->name, buf); 720 else 721 print_insn (outf, "", template->name, buf); 722 } 723 724 /* Print a GET or SET instruction. */ 725 static void 726 print_get_set (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 727 const insn_template *template, 728 disassemble_info *outf) 729 { 730 bfd_boolean is_get = MAJOR_OPCODE (template->meta_opcode) == OPC_GET; 731 char buf[OPERAND_WIDTH]; 732 char addr_buf[ADDR_WIDTH]; 733 unsigned int reg_unit, reg_no; 734 unsigned int size = metag_get_set_size_bytes (insn_word); 735 const char *reg_name; 736 const char *pair_reg; 737 738 reg_unit = (insn_word >> 1) & UNIT_MASK; 739 reg_no = (insn_word >> 19) & REG_MASK; 740 741 /* SETs should always print RD. */ 742 if (!is_get && reg_unit == UNIT_RD) 743 reg_no = 0; 744 745 reg_name = lookup_reg_name (reg_unit, reg_no); 746 747 pair_reg = lookup_pair_reg_name (reg_unit, reg_no); 748 749 get_set_addr_str (addr_buf, ADDR_WIDTH, size, insn_word); 750 751 if (is_get) 752 { 753 /* RD regs are 64 bits wide so don't use the pair syntax. */ 754 if (reg_unit == UNIT_RD) 755 print_get (buf, addr_buf, 4, reg_name, pair_reg, reg_unit, 756 template, outf); 757 else 758 print_get (buf, addr_buf, size, reg_name, pair_reg, reg_unit, 759 template, outf); 760 } 761 else 762 { 763 /* RD regs are 64 bits wide so don't use the pair syntax. */ 764 if (reg_unit == UNIT_RD) 765 print_set (buf, addr_buf, 4, reg_name, pair_reg, reg_unit, 766 template, outf); 767 else 768 print_set (buf, addr_buf, size, reg_name, pair_reg, reg_unit, 769 template, outf); 770 } 771 } 772 773 /* Print an extended GET or SET instruction. */ 774 static void 775 print_get_set_ext (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 776 const insn_template *template, 777 disassemble_info *outf) 778 { 779 bfd_boolean is_get = MINOR_OPCODE (template->meta_opcode) == GET_EXT_MINOR; 780 bfd_boolean is_mov = MINOR_OPCODE (template->meta_opcode) == MOV_EXT_MINOR; 781 char buf[OPERAND_WIDTH]; 782 char addr_buf[ADDR_WIDTH]; 783 unsigned int reg_unit, reg_no; 784 unsigned int size = metag_get_set_ext_size_bytes (insn_word); 785 const char *reg_name; 786 const char *pair_reg; 787 788 if (is_mov) 789 reg_unit = UNIT_RD; 790 else 791 reg_unit = short_unit ((insn_word >> 3) & SHORT_UNIT_MASK); 792 793 reg_no = (insn_word >> 19) & REG_MASK; 794 795 reg_name = lookup_reg_name (reg_unit, reg_no); 796 797 pair_reg = lookup_pair_reg_name (reg_unit, reg_no); 798 799 get_set_ext_addr_str (addr_buf, ADDR_WIDTH, size, insn_word); 800 801 if (is_get) 802 print_get (buf, addr_buf, size, reg_name, pair_reg, reg_unit, 803 template, outf); 804 else if (is_mov) 805 print_get (buf, addr_buf, 4, reg_name, pair_reg, reg_unit, 806 template, outf); 807 else 808 print_set (buf, addr_buf, size, reg_name, pair_reg, reg_unit, 809 template, outf); 810 } 811 812 /* Print an MGET or MSET instruction. */ 813 static void 814 print_mget_mset (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 815 const insn_template *template, 816 disassemble_info *outf) 817 { 818 bfd_boolean is_get = MAJOR_OPCODE (template->meta_opcode) == OPC_GET; 819 bfd_boolean is_fpu = (MINOR_OPCODE (template->meta_opcode) & 0x6) == 0x6; 820 bfd_boolean is_64bit = (MINOR_OPCODE (template->meta_opcode) & 0x1) == 0x1; 821 char buf[OPERAND_WIDTH]; 822 char addr_buf[ADDR_WIDTH]; 823 char reg_buf[REG_WIDTH]; 824 unsigned int reg_unit, reg_no, rmask; 825 826 if (is_fpu) 827 reg_unit = UNIT_FX; 828 else 829 reg_unit = short_unit ((insn_word >> 3) & SHORT_UNIT_MASK); 830 831 reg_no = (insn_word >> 19) & REG_MASK; 832 rmask = (insn_word >> 7) & RMASK_MASK; 833 834 lookup_reg_list (reg_buf, REG_WIDTH, reg_unit, reg_no, rmask, 835 is_fpu && is_64bit); 836 837 mget_mset_addr_str (addr_buf, ADDR_WIDTH, insn_word); 838 839 if (is_get) 840 snprintf (buf, OPERAND_WIDTH, "%s,%s", reg_buf, addr_buf); 841 else 842 snprintf (buf, OPERAND_WIDTH, "%s,%s", addr_buf, reg_buf); 843 844 if (is_fpu) 845 print_insn (outf, "F", template->name, buf); 846 else 847 print_insn (outf, "", template->name, buf); 848 } 849 850 /* Print a conditional SET instruction. */ 851 static void 852 print_cond_set (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 853 const insn_template *template, 854 disassemble_info *outf) 855 { 856 char buf[OPERAND_WIDTH]; 857 char addr_buf[ADDR_WIDTH]; 858 unsigned int src_unit, src_no; 859 unsigned int size = metag_cond_set_size_bytes (insn_word); 860 const char *src_reg; 861 const char *pair_reg; 862 863 src_unit = (insn_word >> 10) & UNIT_MASK; 864 src_no = (insn_word >> 19) & REG_MASK; 865 866 if (src_unit == UNIT_RD) 867 src_no = 0; 868 869 src_reg = lookup_reg_name (src_unit, src_no); 870 871 pair_reg = lookup_pair_reg_name (src_unit, src_no); 872 873 cond_set_addr_str (addr_buf, ADDR_WIDTH, insn_word); 874 875 if (src_unit == UNIT_RD) 876 print_set (buf, addr_buf, 4, src_reg, pair_reg, src_unit, 877 template, outf); 878 else 879 print_set (buf, addr_buf, size, src_reg, pair_reg, src_unit, 880 template, outf); 881 } 882 883 /* Print a MMOV instruction. */ 884 static void 885 print_mmov (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 886 const insn_template *template, 887 disassemble_info *outf) 888 { 889 unsigned int is_fpu = template->insn_type == INSN_FPU; 890 unsigned int is_prime = ((MINOR_OPCODE (template->meta_opcode) & 0x2) && 891 !is_fpu); 892 unsigned int is_64bit = MINOR_OPCODE (template->meta_opcode) & 0x1; 893 unsigned int is_dsp = template->meta_opcode & 0x1; 894 unsigned int dest_unit, dest_no, rmask; 895 char buf[OPERAND_WIDTH]; 896 char reg_buf[REG_WIDTH]; 897 char addr_buf[ADDR_WIDTH]; 898 899 if (is_fpu) 900 dest_no = (insn_word >> 14) & REG_MASK; 901 else 902 dest_no = (insn_word >> 19) & REG_MASK; 903 904 rmask = (insn_word >> 7) & RMASK_MASK; 905 906 if (is_prime) 907 { 908 const char *dest_reg; 909 const char *base_reg; 910 unsigned int base_unit, base_no; 911 int i, count = hweight (rmask); 912 913 dest_reg = lookup_reg_name (UNIT_RD, dest_no); 914 915 strcpy (reg_buf, dest_reg); 916 917 for (i = 0; i < count; i++) 918 { 919 strcat (reg_buf, ","); 920 strcat (reg_buf, dest_reg); 921 } 922 923 base_unit = short_unit ((insn_word >> 5) & SHORT_UNIT_MASK); 924 base_no = (insn_word >> 14) & REG_MASK; 925 926 base_reg = lookup_reg_name (base_unit, base_no); 927 928 snprintf (addr_buf, ADDR_WIDTH, "[%s++]", base_reg); 929 930 snprintf (buf, OPERAND_WIDTH, "%s,%s", reg_buf, addr_buf); 931 } 932 else 933 { 934 if (is_fpu) 935 dest_unit = UNIT_FX; 936 else 937 dest_unit = short_unit ((insn_word >> 3) & SHORT_UNIT_MASK); 938 939 lookup_reg_list (reg_buf, REG_WIDTH, dest_unit, dest_no, rmask, 940 is_fpu && is_64bit); 941 942 snprintf (buf, OPERAND_WIDTH, "%s,RD", reg_buf); 943 } 944 945 if (is_dsp) 946 { 947 char prefix_buf[10] = {0}; 948 if (is_prime) 949 { 950 if (dest_no == 22 || dest_no == 23) 951 strcpy (prefix_buf, "DB"); 952 else if (dest_no == 24) 953 strcpy (prefix_buf, "DBH"); 954 else if (dest_no == 25) 955 strcpy (prefix_buf, "DWH"); 956 else if (dest_no == 31) 957 strcpy (prefix_buf, "DW"); 958 } 959 else 960 strcpy (prefix_buf, "DW"); 961 print_insn (outf, prefix_buf, template->name, buf); 962 } 963 else if (is_fpu) 964 print_insn (outf, "F", template->name, buf); 965 else 966 print_insn (outf, "", template->name, buf); 967 } 968 969 /* Print an MDRD instruction. */ 970 static void 971 print_mdrd (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 972 const insn_template *template, 973 disassemble_info *outf) 974 { 975 unsigned int rmask, count; 976 char buf[OPERAND_WIDTH]; 977 978 rmask = (insn_word >> 7) & RMASK_MASK; 979 980 count = hweight (rmask); 981 982 snprintf (buf, OPERAND_WIDTH, "#%#x", count + 1); 983 984 print_insn (outf, "", template->name, buf); 985 } 986 987 /* Print an XFR instruction. */ 988 static void 989 print_xfr (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 990 const insn_template *template, 991 disassemble_info *outf) 992 { 993 char buf[OPERAND_WIDTH]; 994 char dest_buf[ADDR_WIDTH]; 995 char src_buf[ADDR_WIDTH]; 996 unsigned int dest_unit, src_unit; 997 unsigned int dest_no, src_no; 998 unsigned int us, ud, pp; 999 const char *dest_base_reg; 1000 const char *dest_offset_reg; 1001 const char *src_base_reg; 1002 const char *src_offset_reg; 1003 1004 src_unit = short_unit ((insn_word >> 2) & SHORT_UNIT_MASK); 1005 src_no = (insn_word >> 19) & REG_MASK; 1006 1007 src_base_reg = lookup_reg_name (src_unit, src_no); 1008 1009 src_no = (insn_word >> 14) & REG_MASK; 1010 1011 src_offset_reg = lookup_reg_name (src_unit, src_no); 1012 1013 dest_unit = short_unit (insn_word & SHORT_UNIT_MASK); 1014 dest_no = (insn_word >> 9) & REG_MASK; 1015 1016 dest_base_reg = lookup_reg_name (dest_unit, dest_no); 1017 1018 dest_no = (insn_word >> 4) & REG_MASK; 1019 1020 dest_offset_reg = lookup_reg_name (dest_unit, dest_no); 1021 1022 us = (insn_word >> 27) & 0x1; 1023 ud = (insn_word >> 26) & 0x1; 1024 pp = (insn_word >> 24) & 0x1; 1025 1026 if (us) 1027 if (pp) 1028 snprintf (src_buf, ADDR_WIDTH, "[%s+%s++]", src_base_reg, 1029 src_offset_reg); 1030 else 1031 snprintf (src_buf, ADDR_WIDTH, "[%s++%s]", src_base_reg, 1032 src_offset_reg); 1033 else 1034 snprintf (src_buf, ADDR_WIDTH, "[%s+%s]", src_base_reg, 1035 src_offset_reg); 1036 1037 if (ud) 1038 if (pp) 1039 snprintf (dest_buf, ADDR_WIDTH, "[%s+%s++]", dest_base_reg, 1040 dest_offset_reg); 1041 else 1042 snprintf (dest_buf, ADDR_WIDTH, "[%s++%s]", dest_base_reg, 1043 dest_offset_reg); 1044 else 1045 snprintf (dest_buf, ADDR_WIDTH, "[%s+%s]", dest_base_reg, 1046 dest_offset_reg); 1047 1048 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_buf, src_buf); 1049 1050 print_insn (outf, "", template->name, buf); 1051 } 1052 1053 /* Print a MOV to control unit instruction. */ 1054 static void 1055 print_mov_ct (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1056 const insn_template *template, 1057 disassemble_info *outf) 1058 { 1059 char buf[OPERAND_WIDTH]; 1060 unsigned int reg_no; 1061 unsigned int se = (insn_word >> 1) & 0x1; 1062 unsigned int is_trace = (insn_word >> 2) & 0x1; 1063 int value; 1064 const char *dest_reg; 1065 1066 reg_no = (insn_word >> 19) & REG_MASK; 1067 1068 if (is_trace) 1069 dest_reg = lookup_reg_name (UNIT_TT, reg_no); 1070 else 1071 dest_reg = lookup_reg_name (UNIT_CT, reg_no); 1072 1073 value = (insn_word >> 3) & IMM16_MASK; 1074 1075 if (se) 1076 { 1077 value = sign_extend (value, IMM16_BITS); 1078 snprintf (buf, OPERAND_WIDTH, "%s,#%d", dest_reg, value); 1079 } 1080 else 1081 { 1082 snprintf (buf, OPERAND_WIDTH, "%s,#%#x", dest_reg, value); 1083 } 1084 1085 print_insn (outf, "", template->name, buf); 1086 } 1087 1088 /* Print a SWAP instruction. */ 1089 static void 1090 print_swap (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1091 const insn_template *template, 1092 disassemble_info *outf) 1093 { 1094 char buf[OPERAND_WIDTH]; 1095 unsigned int dest_no, src_no; 1096 unsigned int dest_unit, src_unit; 1097 const char *dest_reg; 1098 const char *src_reg; 1099 1100 src_unit = (insn_word >> 10) & UNIT_MASK; 1101 src_no = (insn_word >> 19) & REG_MASK; 1102 1103 src_reg = lookup_reg_name (src_unit, src_no); 1104 1105 dest_unit = (insn_word >> 5) & UNIT_MASK; 1106 dest_no = (insn_word >> 14) & REG_MASK; 1107 1108 dest_reg = lookup_reg_name (dest_unit, dest_no); 1109 1110 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 1111 1112 if (dest_unit == UNIT_FX || src_unit == UNIT_FX) 1113 print_insn (outf, "F", template->name, buf); 1114 else 1115 print_insn (outf, "", template->name, buf); 1116 } 1117 1118 /* Print a SWAP instruction. */ 1119 static void 1120 print_jump (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1121 const insn_template *template, 1122 disassemble_info *outf) 1123 { 1124 char buf[OPERAND_WIDTH]; 1125 unsigned int reg_no, reg_unit; 1126 const char *reg_name; 1127 int value; 1128 1129 reg_unit = short_unit (insn_word & SHORT_UNIT_MASK); 1130 reg_no = (insn_word >> 19) & REG_MASK; 1131 1132 reg_name = lookup_reg_name (reg_unit, reg_no); 1133 1134 value = (insn_word >> 3) & IMM16_MASK; 1135 1136 snprintf (buf, OPERAND_WIDTH, "%s,#%#x", reg_name, value); 1137 1138 print_insn (outf, "", template->name, buf); 1139 } 1140 1141 /* Print a CALLR instruction. */ 1142 static void 1143 print_callr (unsigned int insn_word, bfd_vma pc, const insn_template *template, 1144 disassemble_info *outf) 1145 { 1146 char buf[OPERAND_WIDTH]; 1147 unsigned int reg_no, reg_unit; 1148 const char *reg_name; 1149 int value; 1150 1151 reg_unit = short_unit ((insn_word >> 3) & SHORT_UNIT_MASK); 1152 reg_no = insn_word & CALLR_REG_MASK; 1153 1154 reg_name = lookup_reg_name (reg_unit, reg_no); 1155 1156 value = (insn_word >> 5) & IMM19_MASK; 1157 1158 value = sign_extend (value, IMM19_BITS); 1159 1160 value = value * 4; 1161 1162 value += pc; 1163 1164 snprintf (buf, OPERAND_WIDTH, "%s,", reg_name); 1165 1166 print_insn (outf, "", template->name, buf); 1167 1168 outf->print_address_func (value, outf); 1169 } 1170 1171 /* Print a GP ALU instruction. */ 1172 static void 1173 print_alu (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1174 const insn_template *template, 1175 disassemble_info *outf) 1176 { 1177 char buf[OPERAND_WIDTH]; 1178 unsigned int is_addr_op = MAJOR_OPCODE (template->meta_opcode) == OPC_ADDR; 1179 unsigned int is_mul = MAJOR_OPCODE (template->meta_opcode) == OPC_MUL; 1180 unsigned int dest_no, src1_no, src2_no; 1181 unsigned int imm = (insn_word >> 25) & 0x1; 1182 unsigned int cond = (insn_word >> 26) & 0x1; 1183 unsigned int o1z = 0; 1184 unsigned int o2r = insn_word & 0x1; 1185 unsigned int unit_bit = (insn_word >> 24) & 0x1; 1186 unsigned int ca = (insn_word >> 5) & 0x1; 1187 unsigned int se = (insn_word >> 1) & 0x1; 1188 bfd_boolean is_quickrot = template->arg_type & GP_ARGS_QR; 1189 enum metag_unit base_unit; 1190 enum metag_unit dest_unit; 1191 const char *dest_reg; 1192 const char *src1_reg; 1193 const char *src2_reg; 1194 int value; 1195 1196 if ((MAJOR_OPCODE (template->meta_opcode) == OPC_ADDR || 1197 MAJOR_OPCODE (template->meta_opcode) == OPC_ADD || 1198 MAJOR_OPCODE (template->meta_opcode) == OPC_SUB) && 1199 ((insn_word >> 2) & 0x1)) 1200 o1z = 1; 1201 1202 if (is_addr_op) 1203 { 1204 if (unit_bit) 1205 base_unit = UNIT_A1; 1206 else 1207 base_unit = UNIT_A0; 1208 } 1209 else 1210 { 1211 if (unit_bit) 1212 base_unit = UNIT_D1; 1213 else 1214 base_unit = UNIT_D0; 1215 } 1216 1217 dest_no = (insn_word >> 19) & REG_MASK; 1218 src1_no = (insn_word >> 14) & REG_MASK; 1219 src2_no = (insn_word >> 9) & REG_MASK; 1220 1221 dest_unit = base_unit; 1222 1223 if (imm) 1224 { 1225 if (cond) 1226 { 1227 if (ca) 1228 { 1229 dest_unit = (insn_word >> 1) & UNIT_MASK; 1230 dest_reg = lookup_reg_name (dest_unit, dest_no); 1231 } 1232 else 1233 dest_reg = lookup_reg_name (dest_unit, dest_no); 1234 1235 src1_reg = lookup_reg_name (base_unit, src1_no); 1236 1237 value = (insn_word >> 6) & IMM8_MASK; 1238 1239 if (is_quickrot) 1240 { 1241 unsigned int qr_unit = unit_bit ? UNIT_A1 : UNIT_A0; 1242 unsigned int qr_no = 2; 1243 const char *qr_reg = lookup_reg_name (qr_unit, qr_no); 1244 1245 snprintf (buf, OPERAND_WIDTH, "%s,%s,#%#x,%s", dest_reg, 1246 src1_reg, value, qr_reg); 1247 } 1248 else 1249 snprintf (buf, OPERAND_WIDTH, "%s,%s,#%#x", dest_reg, 1250 src1_reg, value); 1251 } 1252 else 1253 { 1254 if (is_addr_op && (dest_no & ~CPC_REG_MASK)) 1255 { 1256 dest_reg = lookup_reg_name (dest_unit, dest_no & CPC_REG_MASK); 1257 src1_reg = lookup_reg_name (base_unit, 0x10); 1258 } 1259 else 1260 { 1261 dest_reg = lookup_reg_name (dest_unit, dest_no); 1262 src1_reg = lookup_reg_name (base_unit, dest_no); 1263 } 1264 1265 value = (insn_word >> 3) & IMM16_MASK; 1266 1267 if (se) 1268 { 1269 value = sign_extend (value, IMM16_BITS); 1270 if (o1z) 1271 { 1272 snprintf (buf, OPERAND_WIDTH, "%s,#%d", dest_reg, value); 1273 } 1274 else 1275 { 1276 snprintf (buf, OPERAND_WIDTH, "%s,%s,#%d", dest_reg, 1277 src1_reg, value); 1278 } 1279 } 1280 else 1281 { 1282 if (o1z) 1283 { 1284 snprintf (buf, OPERAND_WIDTH, "%s,#%#x", dest_reg, value); 1285 } 1286 else 1287 { 1288 snprintf (buf, OPERAND_WIDTH, "%s,%s,#%#x", dest_reg, 1289 src1_reg, value); 1290 } 1291 } 1292 } 1293 } 1294 else 1295 { 1296 src1_reg = lookup_reg_name (base_unit, src1_no); 1297 1298 if (o2r) 1299 src2_reg = lookup_o2r (base_unit, src2_no); 1300 else 1301 src2_reg = lookup_reg_name (base_unit, src2_no); 1302 1303 if (cond) 1304 { 1305 dest_unit = (insn_word >> 5) & UNIT_MASK; 1306 1307 if (is_mul) 1308 { 1309 if (ca) 1310 dest_unit = (insn_word >> 1) & UNIT_MASK; 1311 else 1312 dest_unit = base_unit; 1313 } 1314 1315 dest_reg = lookup_reg_name (dest_unit, dest_no); 1316 1317 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, 1318 src1_reg, src2_reg); 1319 } 1320 else 1321 { 1322 dest_reg = lookup_reg_name (dest_unit, dest_no); 1323 1324 if (is_quickrot) 1325 { 1326 unsigned int qr_unit = unit_bit ? UNIT_A1 : UNIT_A0; 1327 unsigned int qr_no = 2 + ((insn_word >> 7) & 0x1); 1328 const char *qr_reg = lookup_reg_name (qr_unit, qr_no); 1329 1330 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s,%s", dest_reg, 1331 src1_reg, src2_reg, qr_reg); 1332 } 1333 else if (o1z) 1334 { 1335 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src2_reg); 1336 } 1337 else 1338 { 1339 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, 1340 src1_reg, src2_reg); 1341 } 1342 } 1343 } 1344 1345 if (dest_unit == UNIT_FX) 1346 print_insn (outf, "F", template->name, buf); 1347 else 1348 print_insn (outf, "", template->name, buf); 1349 } 1350 1351 /* Print a B instruction. */ 1352 static void 1353 print_branch (unsigned int insn_word, bfd_vma pc, 1354 const insn_template *template, 1355 disassemble_info *outf) 1356 { 1357 int value; 1358 1359 value = (insn_word >> 5) & IMM19_MASK; 1360 1361 value = sign_extend (value, IMM19_BITS); 1362 1363 value = value * 4; 1364 1365 value += pc; 1366 1367 print_insn (outf, "", template->name, ""); 1368 1369 outf->print_address_func (value, outf); 1370 } 1371 1372 /* Print a SWITCH instruction. */ 1373 static void 1374 print_switch (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1375 const insn_template *template, 1376 disassemble_info *outf) 1377 { 1378 char buf[OPERAND_WIDTH]; 1379 unsigned int value; 1380 1381 value = insn_word & IMM24_MASK; 1382 1383 snprintf (buf, OPERAND_WIDTH, "#%#x", value); 1384 1385 print_insn (outf, "", template->name, buf); 1386 } 1387 1388 /* Print a shift instruction. */ 1389 static void 1390 print_shift (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1391 const insn_template *template, 1392 disassemble_info *outf) 1393 { 1394 char buf[OPERAND_WIDTH]; 1395 unsigned int dest_no, src1_no, src2_no; 1396 unsigned int imm = (insn_word >> 25) & 0x1; 1397 unsigned int cond = (insn_word >> 26) & 0x1; 1398 unsigned int unit_bit = (insn_word >> 24) & 0x1; 1399 unsigned int ca = (insn_word >> 5) & 0x1; 1400 enum metag_unit base_unit; 1401 unsigned int dest_unit; 1402 const char *dest_reg; 1403 const char *src1_reg; 1404 const char *src2_reg; 1405 int value; 1406 1407 if (unit_bit) 1408 base_unit = UNIT_D1; 1409 else 1410 base_unit = UNIT_D0; 1411 1412 dest_no = (insn_word >> 19) & REG_MASK; 1413 src1_no = (insn_word >> 14) & REG_MASK; 1414 src2_no = (insn_word >> 9) & REG_MASK; 1415 1416 dest_unit = base_unit; 1417 1418 if (imm) 1419 { 1420 if (cond && ca) 1421 dest_unit = (insn_word >> 1) & UNIT_MASK; 1422 1423 dest_reg = lookup_reg_name (dest_unit, dest_no); 1424 1425 src1_reg = lookup_reg_name (base_unit, src1_no); 1426 1427 value = (insn_word >> 9) & IMM5_MASK; 1428 1429 snprintf (buf, OPERAND_WIDTH, "%s,%s,#%#x", dest_reg, 1430 src1_reg, value); 1431 } 1432 else 1433 { 1434 if (cond && ca) 1435 dest_unit = (insn_word >> 1) & UNIT_MASK; 1436 1437 dest_reg = lookup_reg_name (dest_unit, dest_no); 1438 1439 src1_reg = lookup_reg_name (base_unit, src1_no); 1440 src2_reg = lookup_reg_name (base_unit, src2_no); 1441 1442 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, 1443 src1_reg, src2_reg); 1444 } 1445 1446 if (dest_unit == UNIT_FX) 1447 print_insn (outf, "F", template->name, buf); 1448 else 1449 print_insn (outf, "", template->name, buf); 1450 } 1451 1452 /* Print a MIN or MAX instruction. */ 1453 static void 1454 print_min_max (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1455 const insn_template *template, 1456 disassemble_info *outf) 1457 { 1458 unsigned int base_unit, dest_no, src1_no, src2_no; 1459 char buf[OPERAND_WIDTH]; 1460 const char *dest_reg; 1461 const char *src1_reg; 1462 const char *src2_reg; 1463 1464 if ((insn_word >> 24) & UNIT_MASK) 1465 base_unit = UNIT_D1; 1466 else 1467 base_unit = UNIT_D0; 1468 1469 dest_no = (insn_word >> 19) & REG_MASK; 1470 src1_no = (insn_word >> 14) & REG_MASK; 1471 src2_no = (insn_word >> 9) & REG_MASK; 1472 1473 dest_reg = lookup_reg_name (base_unit, dest_no); 1474 1475 src1_reg = lookup_reg_name (base_unit, src1_no); 1476 src2_reg = lookup_reg_name (base_unit, src2_no); 1477 1478 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, src1_reg, src2_reg); 1479 1480 print_insn (outf, "", template->name, buf); 1481 } 1482 1483 /* Print a bit operation instruction. */ 1484 static void 1485 print_bitop (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1486 const insn_template *template, 1487 disassemble_info *outf) 1488 { 1489 unsigned int swap_inst = MAJOR_OPCODE (template->meta_opcode) == OPC_MISC; 1490 unsigned int base_unit, src_unit, dest_no, src_no; 1491 unsigned int is_bexl = 0; 1492 char buf[OPERAND_WIDTH]; 1493 const char *dest_reg; 1494 const char *src_reg; 1495 1496 if (swap_inst && 1497 ((insn_word >> 1) & 0xb) == 0xa) 1498 is_bexl = 1; 1499 1500 if (swap_inst) 1501 { 1502 if (insn_word & 0x1) 1503 base_unit = UNIT_D1; 1504 else 1505 base_unit = UNIT_D0; 1506 } 1507 else 1508 { 1509 if ((insn_word >> 24) & 0x1) 1510 base_unit = UNIT_D1; 1511 else 1512 base_unit = UNIT_D0; 1513 } 1514 1515 src_unit = base_unit; 1516 1517 if (is_bexl) 1518 base_unit = get_pair_unit (base_unit); 1519 1520 dest_no = (insn_word >> 19) & REG_MASK; 1521 1522 dest_reg = lookup_reg_name (base_unit, dest_no); 1523 1524 src_no = (insn_word >> 14) & REG_MASK; 1525 1526 src_reg = lookup_reg_name (src_unit, src_no); 1527 1528 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 1529 1530 print_insn (outf, "", template->name, buf); 1531 } 1532 1533 /* Print a CMP or TST instruction. */ 1534 static void 1535 print_cmp (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1536 const insn_template *template, 1537 disassemble_info *outf) 1538 { 1539 char buf[OPERAND_WIDTH]; 1540 unsigned int dest_no, src_no; 1541 unsigned int imm = (insn_word >> 25) & 0x1; 1542 unsigned int cond = (insn_word >> 26) & 0x1; 1543 unsigned int o2r = insn_word & 0x1; 1544 unsigned int unit_bit = (insn_word >> 24) & 0x1; 1545 unsigned int se = (insn_word >> 1) & 0x1; 1546 enum metag_unit base_unit; 1547 const char *dest_reg; 1548 const char *src_reg; 1549 int value; 1550 1551 if (unit_bit) 1552 base_unit = UNIT_D1; 1553 else 1554 base_unit = UNIT_D0; 1555 1556 dest_no = (insn_word >> 14) & REG_MASK; 1557 src_no = (insn_word >> 9) & REG_MASK; 1558 1559 dest_reg = lookup_reg_name (base_unit, dest_no); 1560 1561 if (imm) 1562 { 1563 if (cond) 1564 { 1565 value = (insn_word >> 6) & IMM8_MASK; 1566 1567 snprintf (buf, OPERAND_WIDTH, "%s,#%#x", dest_reg, value); 1568 } 1569 else 1570 { 1571 dest_no = (insn_word >> 19) & REG_MASK; 1572 1573 dest_reg = lookup_reg_name (base_unit, dest_no); 1574 1575 value = (insn_word >> 3) & IMM16_MASK; 1576 1577 if (se) 1578 { 1579 value = sign_extend (value, IMM16_BITS); 1580 snprintf (buf, OPERAND_WIDTH, "%s,#%d", dest_reg, value); 1581 } 1582 else 1583 { 1584 snprintf (buf, OPERAND_WIDTH, "%s,#%#x", dest_reg, value); 1585 } 1586 } 1587 } 1588 else 1589 { 1590 if (o2r) 1591 src_reg = lookup_o2r (base_unit, src_no); 1592 else 1593 src_reg = lookup_reg_name (base_unit, src_no); 1594 1595 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 1596 } 1597 1598 print_insn (outf, "", template->name, buf); 1599 } 1600 1601 /* Print a CACHER instruction. */ 1602 static void 1603 print_cacher (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1604 const insn_template *template, 1605 disassemble_info *outf) 1606 { 1607 char buf[OPERAND_WIDTH]; 1608 char addr_buf[ADDR_WIDTH]; 1609 unsigned int reg_unit, reg_no; 1610 unsigned int size = ((insn_word >> 1) & 0x1) ? 8 : 4; 1611 const char *reg_name; 1612 const char *pair_name; 1613 1614 reg_unit = short_unit ((insn_word >> 3) & SHORT_UNIT_MASK); 1615 reg_no = (insn_word >> 19) & REG_MASK; 1616 1617 reg_name = lookup_reg_name (reg_unit, reg_no); 1618 pair_name = lookup_pair_reg_name (reg_unit, reg_no); 1619 1620 cache_addr_str (addr_buf, ADDR_WIDTH, insn_word, size); 1621 1622 if (size == 8) 1623 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", reg_name, pair_name, addr_buf); 1624 else 1625 snprintf (buf, OPERAND_WIDTH, "%s,%s", reg_name, addr_buf); 1626 1627 print_insn (outf, "", template->name, buf); 1628 } 1629 1630 /* Print a CACHEW instruction. */ 1631 static void 1632 print_cachew (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1633 const insn_template *template, 1634 disassemble_info *outf) 1635 { 1636 char buf[OPERAND_WIDTH]; 1637 char addr_buf[ADDR_WIDTH]; 1638 unsigned int reg_unit, reg_no; 1639 unsigned int size = ((insn_word >> 1) & 0x1) ? 8 : 4; 1640 const char *reg_name; 1641 const char *pair_name; 1642 1643 reg_unit = short_unit ((insn_word >> 3) & SHORT_UNIT_MASK); 1644 reg_no = (insn_word >> 19) & REG_MASK; 1645 1646 reg_name = lookup_reg_name (reg_unit, reg_no); 1647 pair_name = lookup_pair_reg_name (reg_unit, reg_no); 1648 1649 cache_addr_str (addr_buf, ADDR_WIDTH, insn_word, 64); 1650 1651 if (size == 8) 1652 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", addr_buf, reg_name, pair_name); 1653 else 1654 snprintf (buf, OPERAND_WIDTH, "%s,%s", addr_buf, reg_name); 1655 1656 print_insn (outf, "", template->name, buf); 1657 } 1658 1659 /* Print an ICACHE instruction. */ 1660 static void 1661 print_icache (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1662 const insn_template *template, 1663 disassemble_info *outf) 1664 { 1665 char buf[OPERAND_WIDTH]; 1666 int offset; 1667 int pfcount; 1668 1669 offset = ((insn_word >> 9) & IMM15_MASK); 1670 pfcount = ((insn_word >> 1) & IMM4_MASK); 1671 1672 offset = sign_extend (offset, IMM15_BITS); 1673 1674 if (pfcount) 1675 snprintf (buf, OPERAND_WIDTH, "#%d,#0x%x", offset, pfcount); 1676 else 1677 snprintf (buf, OPERAND_WIDTH, "#%d,#0", offset); 1678 print_insn (outf, "", template->name, buf); 1679 } 1680 1681 /* Print a LNKGET instruction. */ 1682 static void 1683 print_lnkget (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1684 const insn_template *template, 1685 disassemble_info *outf) 1686 { 1687 char buf[OPERAND_WIDTH]; 1688 char addr_buf[ADDR_WIDTH]; 1689 unsigned int reg_unit, reg_no; 1690 unsigned int size = metag_get_set_ext_size_bytes (insn_word); 1691 const char *reg_name; 1692 const char *pair_name; 1693 1694 reg_unit = short_unit ((insn_word >> 3) & SHORT_UNIT_MASK); 1695 reg_no = (insn_word >> 19) & REG_MASK; 1696 1697 reg_name = lookup_reg_name (reg_unit, reg_no); 1698 pair_name = lookup_pair_reg_name (reg_unit, reg_no); 1699 1700 cache_addr_str (addr_buf, ADDR_WIDTH, insn_word, size); 1701 1702 if (size == 8) 1703 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", reg_name, pair_name, addr_buf); 1704 else 1705 snprintf (buf, OPERAND_WIDTH, "%s,%s", reg_name, addr_buf); 1706 1707 print_insn (outf, "", template->name, buf); 1708 } 1709 1710 /* Print an FPU MOV instruction. */ 1711 static void 1712 print_fmov (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1713 const insn_template *template, 1714 disassemble_info *outf) 1715 { 1716 char buf[OPERAND_WIDTH]; 1717 char prefix_buf[10]; 1718 unsigned int src_no, dest_no; 1719 unsigned int p = (insn_word >> 6) & 0x1; 1720 unsigned int d = (insn_word >> 5) & 0x1; 1721 unsigned int cc = (insn_word >> 1) & CC_MASK; 1722 bfd_boolean show_cond = cc != COND_A && cc != COND_NV; 1723 const char *dest_reg; 1724 const char *src_reg; 1725 const char *cc_flags; 1726 1727 dest_no = (insn_word >> 19) & REG_MASK; 1728 src_no = (insn_word >> 14) & REG_MASK; 1729 1730 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 1731 src_reg = lookup_reg_name (UNIT_FX, src_no); 1732 1733 cc_flags = lookup_fpu_scc_flags (cc); 1734 1735 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 1736 1737 snprintf (prefix_buf, 10, "F%s%s%s", p ? "L" : "", 1738 d ? "D" : "", show_cond ? cc_flags : ""); 1739 1740 print_insn (outf, prefix_buf, template->name, buf); 1741 } 1742 1743 /* Convert an FPU rmask into a compatible form. */ 1744 static unsigned int 1745 convert_fx_rmask (unsigned int rmask) 1746 { 1747 int num_bits = hweight (rmask), i; 1748 unsigned int ret = 0; 1749 1750 for (i = 0; i < num_bits; i++) 1751 { 1752 ret <<= 1; 1753 ret |= 0x1; 1754 } 1755 1756 return ret; 1757 } 1758 1759 /* Print an FPU MMOV instruction. */ 1760 static void 1761 print_fmmov (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1762 const insn_template *template, 1763 disassemble_info *outf) 1764 { 1765 char buf[OPERAND_WIDTH]; 1766 char data_buf[REG_WIDTH]; 1767 char fpu_buf[REG_WIDTH]; 1768 bfd_boolean to_fpu = MAJOR_OPCODE (insn_word) == OPC_GET; 1769 bfd_boolean is_mmovl = MINOR_OPCODE (insn_word) & 0x1; 1770 unsigned int rmask = (insn_word >> 7) & RMASK_MASK; 1771 unsigned int fpu_no, data_no, data_unit; 1772 1773 data_no = (insn_word >> 19) & REG_MASK; 1774 fpu_no = (insn_word >> 14) & REG_MASK; 1775 1776 if (insn_word & 0x1) 1777 data_unit = UNIT_D1; 1778 else 1779 data_unit = UNIT_D0; 1780 1781 lookup_reg_list (data_buf, REG_WIDTH, data_unit, data_no, rmask, FALSE); 1782 lookup_reg_list (fpu_buf, REG_WIDTH, UNIT_FX, fpu_no, 1783 convert_fx_rmask (rmask), is_mmovl); 1784 1785 if (to_fpu) 1786 snprintf (buf, OPERAND_WIDTH, "%s,%s", fpu_buf, data_buf); 1787 else 1788 snprintf (buf, OPERAND_WIDTH, "%s,%s", data_buf, fpu_buf); 1789 1790 print_insn (outf, "F", template->name, buf); 1791 } 1792 1793 /* Print an FPU data unit MOV instruction. */ 1794 static void 1795 print_fmov_data (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1796 const insn_template *template, 1797 disassemble_info *outf) 1798 { 1799 char buf[OPERAND_WIDTH]; 1800 unsigned int src_no, dest_no; 1801 unsigned int to_fpu = ((insn_word >> 7) & 0x1); 1802 unsigned int unit_bit = (insn_word >> 24) & 0x1; 1803 enum metag_unit base_unit; 1804 const char *dest_reg; 1805 const char *src_reg; 1806 1807 dest_no = (insn_word >> 19) & REG_MASK; 1808 src_no = (insn_word >> 9) & REG_MASK; 1809 1810 if (unit_bit) 1811 base_unit = UNIT_D1; 1812 else 1813 base_unit = UNIT_D0; 1814 1815 if (to_fpu) 1816 { 1817 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 1818 src_reg = lookup_reg_name (base_unit, src_no); 1819 } 1820 else 1821 { 1822 dest_reg = lookup_reg_name (base_unit, dest_no); 1823 src_reg = lookup_reg_name (UNIT_FX, src_no); 1824 } 1825 1826 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 1827 1828 print_insn (outf, "F", template->name, buf); 1829 } 1830 1831 /* Print an FPU MOV immediate instruction. */ 1832 static void 1833 print_fmov_i (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1834 const insn_template *template, 1835 disassemble_info *outf) 1836 { 1837 char buf[OPERAND_WIDTH]; 1838 unsigned int dest_no; 1839 unsigned int p = (insn_word >> 2) & 0x1; 1840 unsigned int d = (insn_word >> 1) & 0x1; 1841 const char *dest_reg; 1842 unsigned int value = (insn_word >> 3) & IMM16_MASK; 1843 1844 dest_no = (insn_word >> 19) & REG_MASK; 1845 1846 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 1847 1848 snprintf (buf, OPERAND_WIDTH, "%s,#%#x", dest_reg, value); 1849 1850 if (p) 1851 print_insn (outf, "FL", template->name, buf); 1852 else if (d) 1853 print_insn (outf, "FD", template->name, buf); 1854 else 1855 print_insn (outf, "F", template->name, buf); 1856 } 1857 1858 /* Print an FPU PACK instruction. */ 1859 static void 1860 print_fpack (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1861 const insn_template *template, 1862 disassemble_info *outf) 1863 { 1864 char buf[OPERAND_WIDTH]; 1865 unsigned int src1_no, src2_no, dest_no; 1866 const char *dest_reg; 1867 const char *src1_reg; 1868 const char *src2_reg; 1869 1870 dest_no = (insn_word >> 19) & REG_MASK; 1871 src1_no = (insn_word >> 14) & REG_MASK; 1872 src2_no = (insn_word >> 9) & REG_MASK; 1873 1874 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 1875 src1_reg = lookup_reg_name (UNIT_FX, src1_no); 1876 src2_reg = lookup_reg_name (UNIT_FX, src2_no); 1877 1878 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, src1_reg, src2_reg); 1879 1880 print_insn (outf, "F", template->name, buf); 1881 } 1882 1883 /* Print an FPU SWAP instruction. */ 1884 static void 1885 print_fswap (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1886 const insn_template *template, 1887 disassemble_info *outf) 1888 { 1889 char buf[OPERAND_WIDTH]; 1890 unsigned int src_no, dest_no; 1891 const char *dest_reg; 1892 const char *src_reg; 1893 1894 dest_no = (insn_word >> 19) & REG_MASK; 1895 src_no = (insn_word >> 14) & REG_MASK; 1896 1897 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 1898 src_reg = lookup_reg_name (UNIT_FX, src_no); 1899 1900 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 1901 1902 print_insn (outf, "FL", template->name, buf); 1903 } 1904 1905 /* Print an FPU CMP instruction. */ 1906 static void 1907 print_fcmp (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1908 const insn_template *template, 1909 disassemble_info *outf) 1910 { 1911 char buf[OPERAND_WIDTH]; 1912 char prefix_buf[10]; 1913 unsigned int src_no, dest_no; 1914 unsigned int a = (insn_word >> 19) & 0x1; 1915 unsigned int z = (insn_word >> 8) & 0x1; 1916 unsigned int p = (insn_word >> 6) & 0x1; 1917 unsigned int d = (insn_word >> 5) & 0x1; 1918 unsigned int q = (insn_word >> 7) & 0x1; 1919 unsigned int cc = (insn_word >> 1) & CC_MASK; 1920 bfd_boolean show_cond = cc != COND_A && cc != COND_NV; 1921 const char *dest_reg; 1922 const char *src_reg; 1923 const char *cc_flags; 1924 1925 dest_no = (insn_word >> 14) & REG_MASK; 1926 src_no = (insn_word >> 9) & REG_MASK; 1927 1928 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 1929 src_reg = lookup_reg_name (UNIT_FX, src_no); 1930 1931 cc_flags = lookup_fpu_scc_flags (cc); 1932 1933 if (z) 1934 snprintf (buf, OPERAND_WIDTH, "%s,#0", dest_reg); 1935 else 1936 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 1937 1938 snprintf (prefix_buf, 10, "F%s%s%s%s%s", p ? "L" : "", 1939 d ? "D" : "", a ? "A" : "", q ? "Q" : "", 1940 show_cond ? cc_flags : ""); 1941 1942 print_insn (outf, prefix_buf, template->name, buf); 1943 } 1944 1945 /* Print an FPU MIN or MAX instruction. */ 1946 static void 1947 print_fminmax (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1948 const insn_template *template, 1949 disassemble_info *outf) 1950 { 1951 char buf[OPERAND_WIDTH]; 1952 char prefix_buf[10]; 1953 unsigned int p = (insn_word >> 6) & 0x1; 1954 unsigned int d = (insn_word >> 5) & 0x1; 1955 unsigned int src1_no, src2_no, dest_no; 1956 unsigned int cc = (insn_word >> 1) & CC_MASK; 1957 bfd_boolean show_cond = cc != COND_A && cc != COND_NV; 1958 const char *dest_reg; 1959 const char *src1_reg; 1960 const char *src2_reg; 1961 const char *cc_flags; 1962 1963 dest_no = (insn_word >> 19) & REG_MASK; 1964 src1_no = (insn_word >> 14) & REG_MASK; 1965 src2_no = (insn_word >> 9) & REG_MASK; 1966 1967 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 1968 src1_reg = lookup_reg_name (UNIT_FX, src1_no); 1969 src2_reg = lookup_reg_name (UNIT_FX, src2_no); 1970 1971 cc_flags = lookup_fpu_scc_flags (cc); 1972 1973 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, src1_reg, src2_reg); 1974 1975 snprintf (prefix_buf, 10, "F%s%s%s", p ? "L" : "", 1976 d ? "D" : "", show_cond ? cc_flags : ""); 1977 1978 print_insn (outf, prefix_buf, template->name, buf); 1979 } 1980 1981 /* Print an FPU data conversion instruction. */ 1982 static void 1983 print_fconv (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 1984 const insn_template *template, 1985 disassemble_info *outf) 1986 { 1987 char buf[OPERAND_WIDTH]; 1988 char prefix_buf[10]; 1989 unsigned int p = (insn_word >> 6) & 0x1; 1990 unsigned int z = (insn_word >> 12) & 0x1; 1991 unsigned int src_no, dest_no; 1992 unsigned int cc = (insn_word >> 1) & CC_MASK; 1993 bfd_boolean show_cond = cc != COND_A && cc != COND_NV; 1994 const char *dest_reg; 1995 const char *src_reg; 1996 const char *cc_flags; 1997 1998 dest_no = (insn_word >> 19) & REG_MASK; 1999 src_no = (insn_word >> 14) & REG_MASK; 2000 2001 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 2002 src_reg = lookup_reg_name (UNIT_FX, src_no); 2003 2004 cc_flags = lookup_fpu_scc_flags (cc); 2005 2006 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 2007 2008 snprintf (prefix_buf, 10, "F%s%s%s", p ? "L" : "", 2009 z ? "Z" : "", show_cond ? cc_flags : ""); 2010 2011 print_insn (outf, prefix_buf, template->name, buf); 2012 } 2013 2014 /* Print an FPU extended data conversion instruction. */ 2015 static void 2016 print_fconvx (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 2017 const insn_template *template, 2018 disassemble_info *outf) 2019 { 2020 char buf[OPERAND_WIDTH]; 2021 char prefix_buf[10]; 2022 unsigned int p = (insn_word >> 6) & 0x1; 2023 unsigned int xl = (insn_word >> 7) & 0x1; 2024 unsigned int src_no, dest_no, fraction_bits; 2025 unsigned int cc = (insn_word >> 1) & CC_MASK; 2026 bfd_boolean show_cond = cc != COND_A && cc != COND_NV; 2027 const char *dest_reg; 2028 const char *src_reg; 2029 const char *cc_flags; 2030 2031 dest_no = (insn_word >> 19) & REG_MASK; 2032 src_no = (insn_word >> 14) & REG_MASK; 2033 2034 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 2035 src_reg = lookup_reg_name (UNIT_FX, src_no); 2036 2037 cc_flags = lookup_fpu_scc_flags (cc); 2038 2039 if (xl) 2040 fraction_bits = (insn_word >> 8) & IMM6_MASK; 2041 else 2042 fraction_bits = (insn_word >> 9) & IMM5_MASK; 2043 2044 snprintf (buf, OPERAND_WIDTH, "%s,%s,#%#x", dest_reg, src_reg, 2045 fraction_bits); 2046 2047 snprintf (prefix_buf, 10, "F%s%s", p ? "L" : "", 2048 show_cond ? cc_flags : ""); 2049 2050 print_insn (outf, prefix_buf, template->name, buf); 2051 } 2052 2053 /* Print an FPU basic arithmetic instruction. */ 2054 static void 2055 print_fbarith (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 2056 const insn_template *template, 2057 disassemble_info *outf) 2058 { 2059 char buf[OPERAND_WIDTH]; 2060 char prefix_buf[10]; 2061 unsigned int n = (insn_word >> 7) & 0x1; 2062 unsigned int p = (insn_word >> 6) & 0x1; 2063 unsigned int d = (insn_word >> 5) & 0x1; 2064 unsigned int src1_no, src2_no, dest_no; 2065 unsigned int cc = (insn_word >> 1) & CC_MASK; 2066 bfd_boolean show_cond = cc != COND_A && cc != COND_NV; 2067 const char *dest_reg; 2068 const char *src1_reg; 2069 const char *src2_reg; 2070 const char *cc_flags; 2071 2072 dest_no = (insn_word >> 19) & REG_MASK; 2073 src1_no = (insn_word >> 14) & REG_MASK; 2074 src2_no = (insn_word >> 9) & REG_MASK; 2075 2076 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 2077 src1_reg = lookup_reg_name (UNIT_FX, src1_no); 2078 src2_reg = lookup_reg_name (UNIT_FX, src2_no); 2079 2080 cc_flags = lookup_fpu_scc_flags (cc); 2081 2082 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, src1_reg, src2_reg); 2083 2084 snprintf (prefix_buf, 10, "F%s%s%s%s", p ? "L" : "", 2085 d ? "D" : "", n ? "I" : "", show_cond ? cc_flags : ""); 2086 2087 print_insn (outf, prefix_buf, template->name, buf); 2088 } 2089 2090 /* Print an FPU extended arithmetic instruction. */ 2091 static void 2092 print_fearith (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 2093 const insn_template *template, 2094 disassemble_info *outf) 2095 { 2096 char buf[OPERAND_WIDTH]; 2097 char prefix_buf[10]; 2098 bfd_boolean is_muz = (MINOR_OPCODE (insn_word) == 0x6 && 2099 ((insn_word >> 4) & 0x1)); 2100 bfd_boolean is_mac = (MINOR_OPCODE (insn_word) == 0x6 && 2101 (insn_word & 0x1f) == 0); 2102 bfd_boolean is_maw = (MINOR_OPCODE (insn_word) == 0x6 && 2103 ((insn_word >> 3) & 0x1)); 2104 unsigned int o3o = insn_word & 0x1; 2105 unsigned int q = is_muz && ((insn_word >> 1) & 0x1); 2106 unsigned int n = (insn_word >> 7) & 0x1; 2107 unsigned int p = (insn_word >> 6) & 0x1; 2108 unsigned int d = (insn_word >> 5) & 0x1; 2109 unsigned int cc = (insn_word >> 1) & CC_MASK; 2110 bfd_boolean show_cond = (MINOR_OPCODE (insn_word) == 0x5 && cc != COND_A && 2111 cc != COND_NV); 2112 unsigned int src1_no, src2_no, dest_no; 2113 const char *dest_reg; 2114 const char *src1_reg; 2115 const char *src2_reg; 2116 const char *cc_flags; 2117 2118 dest_no = (insn_word >> 19) & REG_MASK; 2119 src1_no = (insn_word >> 14) & REG_MASK; 2120 src2_no = (insn_word >> 9) & REG_MASK; 2121 2122 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 2123 src1_reg = lookup_reg_name (UNIT_FX, src1_no); 2124 src2_reg = lookup_reg_name (UNIT_FX, src2_no); 2125 2126 cc_flags = lookup_fpu_scc_flags (cc); 2127 2128 if (is_mac) 2129 snprintf (buf, OPERAND_WIDTH, "ACF.0,%s,%s", src1_reg, src2_reg); 2130 else if (o3o && is_maw) 2131 snprintf (buf, OPERAND_WIDTH, "%s,%s", src1_reg, src2_reg); 2132 else 2133 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, src1_reg, src2_reg); 2134 2135 snprintf (prefix_buf, 10, "F%s%s%s%s%s", p ? "L" : "", 2136 d ? "D" : "", n ? "I" : "", q ? "Q" : "", 2137 show_cond ? cc_flags : ""); 2138 2139 print_insn (outf, prefix_buf, template->name, buf); 2140 } 2141 2142 /* Print an FPU RCP or RSQ instruction. */ 2143 static void 2144 print_frec (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 2145 const insn_template *template, 2146 disassemble_info *outf) 2147 { 2148 char buf[OPERAND_WIDTH]; 2149 char prefix_buf[10]; 2150 unsigned int z = (insn_word >> 10) & 0x1; 2151 unsigned int q = (insn_word >> 9) & 0x1; 2152 unsigned int n = (insn_word >> 7) & 0x1; 2153 unsigned int p = (insn_word >> 6) & 0x1; 2154 unsigned int d = (insn_word >> 5) & 0x1; 2155 unsigned int src_no, dest_no; 2156 const char *dest_reg; 2157 const char *src_reg; 2158 2159 dest_no = (insn_word >> 19) & REG_MASK; 2160 src_no = (insn_word >> 14) & REG_MASK; 2161 2162 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 2163 src_reg = lookup_reg_name (UNIT_FX, src_no); 2164 2165 snprintf (buf, OPERAND_WIDTH, "%s,%s", dest_reg, src_reg); 2166 2167 snprintf (prefix_buf, 10, "F%s%s%s%s%s", p ? "L" : "", 2168 d ? "D" : "", n ? "I" : "", q ? "Q" : "", z ? "Z" : ""); 2169 2170 print_insn (outf, prefix_buf, template->name, buf); 2171 } 2172 2173 static void 2174 print_fsimd (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 2175 const insn_template *template, 2176 disassemble_info *outf) 2177 { 2178 char buf[OPERAND_WIDTH]; 2179 unsigned int n = (insn_word >> 7) & 0x1; 2180 unsigned int src1_no, src2_no, dest_no; 2181 const char *dest_reg; 2182 const char *src1_reg; 2183 const char *src2_reg; 2184 2185 dest_no = (insn_word >> 19) & REG_MASK; 2186 src1_no = (insn_word >> 14) & REG_MASK; 2187 src2_no = (insn_word >> 9) & REG_MASK; 2188 2189 dest_reg = lookup_reg_name (UNIT_FX, dest_no); 2190 src1_reg = lookup_reg_name (UNIT_FX, src1_no); 2191 src2_reg = lookup_reg_name (UNIT_FX, src2_no); 2192 2193 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", dest_reg, src1_reg, src2_reg); 2194 2195 if (n) 2196 print_insn (outf, "FLI", template->name, buf); 2197 else 2198 print_insn (outf, "FL", template->name, buf); 2199 } 2200 2201 /* Print an FPU accumulator GET or SET instruction. */ 2202 static void 2203 print_fget_set_acf (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 2204 const insn_template *template, 2205 disassemble_info *outf) 2206 { 2207 bfd_boolean is_get = MAJOR_OPCODE (template->meta_opcode) == OPC_GET; 2208 char buf[OPERAND_WIDTH]; 2209 char addr_buf[ADDR_WIDTH]; 2210 unsigned int part; 2211 const char *reg_name; 2212 2213 part = (insn_word >> 19) & ACF_PART_MASK; 2214 2215 reg_name = lookup_acf_name (part); 2216 2217 mget_mset_addr_str (addr_buf, ADDR_WIDTH, insn_word); 2218 2219 if (is_get) 2220 { 2221 snprintf (buf, OPERAND_WIDTH, "%s,%s", reg_name, addr_buf); 2222 } 2223 else 2224 { 2225 snprintf (buf, OPERAND_WIDTH, "%s,%s", addr_buf, reg_name); 2226 } 2227 print_insn (outf, "F", template->name, buf); 2228 } 2229 2230 /* Return the name of the DSP register or accumulator for NUM and UNIT. */ 2231 static const char * 2232 __lookup_dsp_name (unsigned int num, unsigned int unit) 2233 { 2234 size_t i; 2235 2236 for (i = 0; i < sizeof(metag_dsp_regtab)/sizeof(metag_dsp_regtab[0]); i++) 2237 { 2238 const metag_reg *reg = &metag_dsp_regtab[i]; 2239 2240 if (reg->no == num) 2241 { 2242 if ((reg->unit == UNIT_RAM_D0 || reg->unit == UNIT_ACC_D0) && 2243 unit == UNIT_D0) 2244 return reg->name; 2245 2246 if ((reg->unit == UNIT_RAM_D1 || reg->unit == UNIT_ACC_D1) && 2247 unit == UNIT_D1) 2248 return reg->name; 2249 } 2250 } 2251 return "?.?"; 2252 } 2253 2254 /* Return the name of the DSP register for NUM and UNIT. */ 2255 static const char * 2256 lookup_dsp_name (unsigned int num, unsigned int unit) 2257 { 2258 size_t i; 2259 2260 for (i = 0; i < sizeof(metag_dsp_regtab)/sizeof(metag_dsp_regtab[0]); i++) 2261 { 2262 const metag_reg *reg = &metag_dsp_regtab[i]; 2263 2264 if (reg->no == num && reg->unit == unit) 2265 return reg->name; 2266 } 2267 return "?.?"; 2268 } 2269 2270 /* Return the name of the DSP RAM register for NUM and UNIT. */ 2271 static const char * 2272 lookup_dspram_name (unsigned int num, unsigned int unit, bfd_boolean load) 2273 { 2274 size_t i, nentries; 2275 2276 nentries = sizeof(metag_dsp_tmpl_regtab[load])/sizeof(metag_dsp_tmpl_regtab[load][0]); 2277 2278 for (i = 0; i < nentries; i++) 2279 { 2280 const metag_reg *reg = &metag_dsp_tmpl_regtab[load][i]; 2281 2282 if (reg->no == num && reg->unit == unit) 2283 return reg->name; 2284 } 2285 return "?.?"; 2286 } 2287 2288 /* This lookup function looks up the corresponding name for a register 2289 number in a DSP instruction. SOURCE indicates whether this 2290 register is a source or destination operand. */ 2291 static const char * 2292 lookup_any_reg_name (unsigned int unit, unsigned int num, bfd_boolean source) 2293 { 2294 /* A register with the top bit set (5th bit) indicates a DSPRAM 2295 register. */ 2296 if (num > 15) 2297 { 2298 unsigned int dunit = (unit == UNIT_D0) ? UNIT_RAM_D0 : UNIT_RAM_D1; 2299 return lookup_dspram_name (num, dunit, source); 2300 } 2301 else 2302 return lookup_reg_name (unit, num); 2303 } 2304 2305 /* Return the DSP data unit for UNIT. */ 2306 static inline enum metag_unit 2307 dsp_data_unit_to_sym (unsigned int unit) 2308 { 2309 if (unit == 0) 2310 return UNIT_D0; 2311 else 2312 return UNIT_D1; 2313 } 2314 2315 /* Print a DSP GET or SET instruction. */ 2316 static void 2317 print_dget_set (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 2318 const insn_template *template, 2319 disassemble_info *outf) 2320 { 2321 bfd_boolean is_get = (template->meta_opcode & 0x100); 2322 char buf[OPERAND_WIDTH]; 2323 char addr_buf[ADDR_WIDTH]; 2324 char prefix[DSP_PREFIX_WIDTH]; 2325 unsigned int part; 2326 const char *reg_name[2]; 2327 bfd_boolean is_high = FALSE; 2328 bfd_boolean is_dual = (insn_word & 0x4); 2329 bfd_boolean is_template = (insn_word & 0x2); 2330 const char *base_reg = "?"; 2331 unsigned int addr_unit, base_no, unit; 2332 2333 unit = dsp_data_unit_to_sym (insn_word & 0x1); 2334 2335 /* Is this a load/store to a template table? */ 2336 if (is_template) 2337 { 2338 part = (insn_word >> 19) & 0x1f; 2339 reg_name[0] = lookup_dsp_name (part, UNIT_DT); 2340 } 2341 else 2342 { 2343 part = (insn_word >> 19) & REG_MASK; 2344 is_high = ((part & 0x18) == 0x18); 2345 2346 /* Strip bit high indicator. */ 2347 if (is_high) 2348 part &= 0x17; 2349 2350 reg_name[0] = __lookup_dsp_name (part, unit); 2351 2352 } 2353 2354 /* Is this a dual unit DSP operation? The modulo operator below 2355 makes sure that we print the Rd register in the correct order, 2356 e.g. because there's only one bit in the instruction for the Data 2357 Unit we have to work out what the other data unit number is. 2358 (there's only 2). */ 2359 if (is_dual) 2360 { 2361 unsigned int _unit = insn_word & 0x1; 2362 2363 _unit = ((_unit + 1) % 2); 2364 reg_name[1] = __lookup_dsp_name(part, dsp_data_unit_to_sym (_unit)); 2365 } 2366 else 2367 reg_name[1] = NULL; 2368 2369 addr_unit = ((insn_word >> 18) & 0x1); 2370 if (addr_unit == 0) 2371 addr_unit = UNIT_A0; 2372 else 2373 addr_unit = UNIT_A1; 2374 2375 base_no = (insn_word >> 14) & DSP_REG_MASK; 2376 2377 base_reg = lookup_reg_name (addr_unit, base_no); 2378 2379 /* Check if it's a post-increment/post-decrement. */ 2380 if (insn_word & 0x2000) 2381 { 2382 unsigned int imm = (insn_word >> 9) & DGET_SET_IMM_MASK; 2383 const char *post_op; 2384 2385 switch (imm) 2386 { 2387 case 0x1: 2388 post_op = "++"; 2389 break; 2390 case 0x3: 2391 post_op = "--"; 2392 break; 2393 default: 2394 post_op = ""; 2395 } 2396 2397 snprintf (addr_buf, ADDR_WIDTH, "[%s%s]", base_reg, post_op); 2398 } 2399 else 2400 { 2401 unsigned int offset_part = (insn_word >> 9) & DSP_REG_MASK; 2402 const char *offset_reg = lookup_reg_name (addr_unit, offset_part); 2403 2404 snprintf (addr_buf, ADDR_WIDTH, "[%s+%s++]", base_reg, offset_reg); 2405 } 2406 2407 if (is_get) 2408 { 2409 if (is_dual && !is_template) 2410 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", reg_name[0], 2411 reg_name[1], addr_buf); 2412 else 2413 snprintf (buf, OPERAND_WIDTH, "%s,%s", reg_name[0], addr_buf); 2414 } 2415 else 2416 { 2417 if (is_dual && !is_template) 2418 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s", addr_buf, 2419 reg_name[0], reg_name[1]); 2420 else 2421 snprintf (buf, OPERAND_WIDTH, "%s,%s", addr_buf, reg_name[0]); 2422 } 2423 2424 snprintf (prefix, DSP_PREFIX_WIDTH, "D%s", is_high ? "H" : ""); 2425 print_insn (outf, prefix, template->name, buf); 2426 } 2427 2428 /* Print a DSP template instruction. */ 2429 static void 2430 print_dtemplate (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 2431 const insn_template *template, 2432 disassemble_info *outf) 2433 { 2434 char buf[OPERAND_WIDTH]; 2435 char prefix[DSP_PREFIX_WIDTH]; 2436 unsigned int offset[4]; 2437 bfd_boolean is_half = (MINOR_OPCODE (insn_word) == 0x5); 2438 bfd_boolean daop_only = (MINOR_OPCODE (insn_word) == 0x3); 2439 2440 offset[0] = ((insn_word >> 19) & REG_MASK); 2441 offset[1] = ((insn_word >> 14) & REG_MASK); 2442 offset[2] = ((insn_word >> 9) & REG_MASK); 2443 offset[3] = ((insn_word >> 4) & REG_MASK); 2444 2445 if (daop_only) 2446 snprintf (buf, OPERAND_WIDTH, "#0x%x,#0x%x,#0x%x", offset[0], 2447 offset[1], offset[2]); 2448 else 2449 { 2450 snprintf (buf, OPERAND_WIDTH, "#0x%x,#0x%x,#0x%x,#0x%x", offset[0], 2451 offset[1], offset[2], offset[3]); 2452 } 2453 2454 snprintf (prefix, DSP_PREFIX_WIDTH, "D%s", is_half ? "H" : ""); 2455 print_insn (outf, prefix, template->name, buf); 2456 } 2457 2458 /* Format template definition from INSN_WORD into BUF. */ 2459 static void 2460 decode_template_definition(unsigned int insn_word, char *buf, size_t len) 2461 { 2462 bfd_boolean load = ((insn_word >> 13) & 0x1); 2463 bfd_boolean dspram = (((insn_word >> 17) & 0x3) == 0x3); 2464 const char *template[1]; 2465 unsigned int tidx = ((insn_word >> 9) & TEMPLATE_REGS_MASK); 2466 enum metag_unit au, ram_unit; 2467 unsigned int addr_reg_nums[2]; 2468 const char *addr_reg_names[2]; 2469 const char *post_op = ""; 2470 const char *join_op = ""; 2471 enum metag_unit data_unit = ((insn_word >> 24) & 0x1) ? UNIT_D1 : UNIT_D0; 2472 2473 template[0] = lookup_dsp_name (tidx, UNIT_DT); 2474 2475 addr_reg_names[1] = ""; 2476 2477 if (dspram) 2478 { 2479 ram_unit = (data_unit == UNIT_D0) ? UNIT_RAM_D0 : UNIT_RAM_D1; 2480 addr_reg_nums[0] = ((insn_word >> 19) & REG_MASK); 2481 addr_reg_names[0] = lookup_dspram_name (addr_reg_nums[0], 2482 ram_unit, load); 2483 } 2484 else 2485 { 2486 bfd_boolean im = (((insn_word >> 18) & 0x1) != 0); 2487 2488 au = (((insn_word >> 23) & 0x1) == 0) ? UNIT_A0 : UNIT_A1; 2489 addr_reg_nums[0] = ((insn_word >> 19) & DSP_REG_MASK); 2490 2491 addr_reg_names[0] = lookup_reg_name (au, addr_reg_nums[0]); 2492 2493 if (im) 2494 { 2495 unsigned int im_value = ((insn_word >> 14) & 0x3); 2496 2497 switch (im_value) 2498 { 2499 case 0x1: 2500 post_op = "++"; 2501 break; 2502 case 0x3: 2503 post_op = "--"; 2504 break; 2505 } 2506 } 2507 else 2508 { 2509 addr_reg_nums[1] = ((insn_word >> 14) & DSP_REG_MASK); 2510 addr_reg_names[1] = lookup_reg_name (au, addr_reg_nums[1]); 2511 join_op = "+"; 2512 post_op = "++"; 2513 } 2514 } 2515 2516 if (load) 2517 { 2518 len = snprintf (buf, len, " %s,[%s%s%s%s]", template[0], addr_reg_names[0], 2519 join_op, addr_reg_names[1], post_op); 2520 } 2521 else 2522 { 2523 len = snprintf (buf, len, " [%s%s%s%s],%s", addr_reg_names[0], join_op, 2524 addr_reg_names[1], post_op, template[0]); 2525 } 2526 } 2527 2528 /* Print a DSP ALU instruction. */ 2529 static void 2530 print_dalu (unsigned int insn_word, bfd_vma pc ATTRIBUTE_UNUSED, 2531 const insn_template *template, 2532 disassemble_info *outf) 2533 { 2534 bfd_boolean is_dual = FALSE; 2535 unsigned int data_unit = (((insn_word >> 24) & 0x1) ? UNIT_D1 : UNIT_D0); 2536 const char *reg_names[3]; 2537 unsigned int reg_nums[3]; 2538 bfd_boolean ac = ((insn_word >> 7) & 0x1); 2539 char buf[OPERAND_WIDTH]; 2540 char prefix[DSP_PREFIX_WIDTH]; 2541 size_t len; 2542 bfd_boolean is_mod = FALSE; 2543 bfd_boolean is_overflow = FALSE; 2544 unsigned int reg_brackets[3]; 2545 bfd_boolean is_w_mx = FALSE; 2546 bfd_boolean is_b_mx = FALSE; 2547 bfd_boolean imm = FALSE; 2548 bfd_boolean is_quickrot64 = FALSE; 2549 bfd_boolean conditional = FALSE; 2550 const char *cc_flags = NULL; 2551 bfd_boolean is_unsigned = FALSE; 2552 2553 memset (reg_brackets, 0, sizeof (reg_brackets)); 2554 2555 if (template->arg_type & DSP_ARGS_1) 2556 { 2557 bfd_boolean is_template = FALSE; 2558 const char *addr_reg = NULL; 2559 bfd_boolean qr = FALSE; 2560 bfd_boolean is_acc_add = FALSE; 2561 bfd_boolean is_acc_sub = FALSE; 2562 bfd_boolean is_acc_zero = FALSE; 2563 bfd_boolean is_split8 = (template->arg_type & DSP_ARGS_SPLIT8); 2564 2565 /* Read DU bit. */ 2566 data_unit = ((insn_word >> 24) & 0x1) ? UNIT_D1 : UNIT_D0; 2567 2568 conditional = ((insn_word >> 24) & 0x4); 2569 2570 /* Templates can't be conditional. */ 2571 is_template = (((insn_word & 0x02000002) == 0x2) && !conditional); 2572 2573 if (is_split8) 2574 is_mod = (insn_word & 0x80); 2575 2576 if (template->arg_type & DSP_ARGS_QR) 2577 { 2578 if (!conditional) 2579 is_quickrot64 = ((insn_word >> 5) & 0x1); 2580 } 2581 2582 if (template->arg_type & DSP_ARGS_DACC) 2583 { 2584 is_mod = (insn_word & 0x8); 2585 is_unsigned = (insn_word & 0x40); 2586 } 2587 2588 if (is_template) 2589 { 2590 is_w_mx = (insn_word & 0x1); 2591 is_dual = ((insn_word >> 0x4) & 0x1); 2592 2593 /* De.r,Dx.r,De.r|ACe.r */ 2594 if (template->arg_type & DSP_ARGS_ACC2) 2595 { 2596 is_mod = (insn_word & 0x8); 2597 is_overflow = (insn_word & 0x20); 2598 } 2599 2600 /* ACe.e,ACx.r,ACo.e? */ 2601 if ((template->arg_type & DSP_ARGS_XACC) && 2602 (((insn_word >> 6) & 0x5) == 0x5)) 2603 { 2604 enum metag_unit ac_unit, ao_unit; 2605 2606 ac_unit = (data_unit == UNIT_D0) ? UNIT_ACC_D0 : UNIT_ACC_D1; 2607 2608 if (ac_unit == UNIT_ACC_D0) 2609 ao_unit = UNIT_ACC_D1; 2610 else 2611 ao_unit = UNIT_ACC_D0; 2612 2613 reg_nums[1] = ((insn_word >> 19) & REG_MASK); 2614 2615 /* These are dummy arguments anyway so the register 2616 number does not matter. */ 2617 reg_names[0] = lookup_dsp_name (16, ac_unit); /* ACe.0 */ 2618 reg_names[1] = lookup_dsp_name (16, ac_unit); /* ACx.0 */ 2619 reg_names[2] = lookup_dsp_name (16, ao_unit); /* ACo.0 */ 2620 } 2621 else 2622 { 2623 /* De.r|ACe.r,Dx.r,De.r */ 2624 if (template->arg_type & DSP_ARGS_DACC && 2625 ((insn_word & 0x84) != 0)) 2626 { 2627 enum metag_unit ac_unit; 2628 2629 ac_unit = (data_unit == UNIT_D0) ? UNIT_ACC_D0 : UNIT_ACC_D1; 2630 reg_names[0] = lookup_dsp_name (16, ac_unit); 2631 2632 is_acc_zero = ((insn_word & 0x84) == 0x04); 2633 is_acc_add = ((insn_word & 0x84) == 0x80); 2634 is_acc_sub = ((insn_word & 0x84) == 0x84); 2635 } 2636 else 2637 reg_names[0] = lookup_any_reg_name (data_unit, 0, FALSE); 2638 2639 /* These are dummy arguments anyway so the register 2640 number does not matter. */ 2641 reg_names[1] = lookup_any_reg_name (data_unit, 0, TRUE); 2642 2643 /* De.r,Dx.r,De.r|ACe.r */ 2644 if ((template->arg_type & DSP_ARGS_ACC2) && 2645 ((insn_word & 0x80) == 0x80)) 2646 { 2647 enum metag_unit ac_unit; 2648 2649 ac_unit = (data_unit == UNIT_D0) ? UNIT_ACC_D0 : UNIT_ACC_D1; 2650 reg_names[2] = lookup_dsp_name (16, ac_unit); 2651 } 2652 /* Detection of QUICKRoT and accumulator usage uses the 2653 same bits. They are mutually exclusive. */ 2654 else if (ac && (template->arg_type & DSP_ARGS_ACC2)) 2655 { 2656 reg_nums[2] = ((insn_word >> 9) & REG_MASK); 2657 2658 if (data_unit == UNIT_D0) 2659 reg_names[2] = lookup_dsp_name (reg_nums[2], UNIT_ACC_D0); 2660 else 2661 reg_names[2] = lookup_dsp_name (reg_nums[2], UNIT_ACC_D1); 2662 } 2663 else 2664 { 2665 if ((template->arg_type & DSP_ARGS_QR) && 2666 ((insn_word & 0x40) == 0x40)) 2667 { 2668 enum metag_unit aunit; 2669 int reg_no; 2670 2671 if (conditional) 2672 reg_no = ((insn_word >> 5) & 0x1); 2673 else 2674 reg_no = ((insn_word >> 7) & 0x1); 2675 2676 aunit = (data_unit == UNIT_D0) ? UNIT_A0 : UNIT_A1; 2677 addr_reg = lookup_reg_name (aunit, reg_no + 2); 2678 2679 qr = TRUE; 2680 } 2681 2682 reg_names[2] = lookup_any_reg_name (data_unit, 0, TRUE); 2683 } 2684 } 2685 2686 if (qr) 2687 { 2688 len = snprintf (buf, OPERAND_WIDTH, "%s,%s,%s,%s", 2689 reg_names[0], reg_names[1], reg_names[2], 2690 addr_reg); 2691 } 2692 else 2693 { 2694 len = snprintf (buf, OPERAND_WIDTH, "%s,%s,%s%s%s", 2695 reg_names[0], reg_names[1], 2696 reg_brackets[2] ? "[" : "", 2697 reg_names[2], reg_brackets[2] ? "]" : ""); 2698 } 2699 2700 decode_template_definition (insn_word, buf + len, 2701 OPERAND_WIDTH - len); 2702 } 2703 else /* Not a template definiton. */ 2704 { 2705 reg_nums[0] = ((insn_word >> 19) & REG_MASK); 2706 reg_nums[1] = ((insn_word >> 14) & REG_MASK); 2707 reg_nums[2] = ((insn_word >> 9) & REG_MASK); 2708 2709 imm = (((insn_word >> 24) & 0x2) && (template->arg_type & DSP_ARGS_IMM)); 2710 2711 if (imm) 2712 is_dual = (insn_word & 0x4); 2713 else if (!conditional) 2714 is_dual = (insn_word & 0x10); 2715 else 2716 cc_flags = lookup_scc_flags ((insn_word >> 1) & CC_MASK); 2717 2718 /* De.r,Dx.r,De.r|ACe.r */ 2719 if (template->arg_type & DSP_ARGS_ACC2) 2720 { 2721 is_mod = (insn_word & 0x8); 2722 is_overflow = (insn_word & 0x20); 2723 } 2724 2725 if (template->arg_type & DSP_ARGS_SPLIT8) 2726 { 2727 is_overflow = (insn_word & 0x20); 2728 } 2729 2730 /* ACe.e,ACx.r,ACo.e? */ 2731 if ((template->arg_type & DSP_ARGS_XACC) && 2732 (((insn_word >> 6) & 0x5) == 0x5)) 2733 { 2734 enum metag_unit ac_unit, ao_unit; 2735 2736 ac_unit = (data_unit == UNIT_D0) ? UNIT_ACC_D0 : UNIT_ACC_D1; 2737 2738 if (ac_unit == UNIT_ACC_D0) 2739 ao_unit = UNIT_ACC_D1; 2740 else 2741 ao_unit = UNIT_ACC_D0; 2742 2743 reg_nums[1] = ((insn_word >> 19) & REG_MASK); 2744 reg_names[0] = lookup_dsp_name (reg_nums[1], ac_unit); 2745 reg_names[1] = lookup_dsp_name (reg_nums[1], ac_unit); 2746 reg_names[2] = lookup_dsp_name (reg_nums[1], ao_unit); 2747 } 2748 else 2749 { 2750 bfd_boolean o2r = (insn_word & 0x1); 2751 2752 /* De.r|ACe.r,Dx.r,De.r */ 2753 if ((template->arg_type & DSP_ARGS_DACC) && 2754 ((insn_word & 0x84) != 0)) 2755 { 2756 enum metag_unit ac_unit; 2757 2758 ac_unit = (data_unit == UNIT_D0) ? UNIT_ACC_D0 : UNIT_ACC_D1; 2759 reg_names[0] = lookup_dsp_name (reg_nums[0], ac_unit); 2760 2761 is_acc_zero = ((insn_word & 0x84) == 0x04); 2762 is_acc_add = ((insn_word & 0x84) == 0x80); 2763 is_acc_sub = ((insn_word & 0x84) == 0x84); 2764 } 2765 else if (conditional) 2766 { 2767 reg_names[0] = lookup_reg_name (data_unit, reg_nums[0]); 2768 } 2769 else 2770 { 2771 reg_names[0] = lookup_any_reg_name (data_unit, 2772 reg_nums[0], FALSE); 2773 if (reg_nums[0] > 15) 2774 reg_brackets[0] = 1; 2775 } 2776 2777 if (imm) 2778 { 2779 reg_names[1] = lookup_any_reg_name (data_unit, reg_nums[0], TRUE); 2780 2781 if (reg_brackets[0]) 2782 reg_brackets[1] = 1; 2783 } 2784 else 2785 { 2786 if (is_split8 && is_mod) 2787 { 2788 reg_names[1] = lookup_reg_name (data_unit, reg_nums[1]); 2789 } 2790 else 2791 { 2792 reg_names[1] = lookup_any_reg_name (data_unit, reg_nums[1], TRUE); 2793 2794 if (reg_nums[1] > 15) 2795 reg_brackets[1] = 1; 2796 } 2797 } 2798 2799 /* Detection of QUICKRoT and accumulator usage uses the 2800 same bits. They are mutually exclusive. */ 2801 if (ac && (template->arg_type & DSP_ARGS_ACC2)) 2802 { 2803 if (data_unit == UNIT_D0) 2804 reg_names[2] = lookup_dsp_name (reg_nums[2], UNIT_ACC_D0); 2805 else 2806 reg_names[2] = lookup_dsp_name (reg_nums[2], UNIT_ACC_D1); 2807 } 2808 2809 else 2810 { 2811 if ((template->arg_type & DSP_ARGS_QR) && 2812 ((insn_word & 0x40) == 0x40)) 2813 { 2814 enum metag_unit aunit; 2815 int reg_no; 2816 2817 if (conditional) 2818 reg_no = ((insn_word >> 5) & 0x1); 2819 else 2820 reg_no = ((insn_word >> 7) & 0x1); 2821 2822 aunit = (data_unit == UNIT_D0) ? UNIT_A0 : UNIT_A1; 2823 addr_reg = lookup_reg_name (aunit, reg_no + 2); 2824 2825 qr = TRUE; 2826 } 2827 2828 if (o2r) 2829 reg_names[2] = lookup_o2r (data_unit, reg_nums[2]); 2830 else 2831 { 2832 /* Can't use a DSPRAM reg if both QD and L1 are 2833 set on a QUICKRoT instruction or if we're a 2834 split 8. */ 2835 if (((template->arg_type & DSP_ARGS_QR) 2836 && ((insn_word & 0x30) == 0x30 && !conditional)) || 2837 (is_split8 && is_mod)) 2838 reg_names[2] = lookup_reg_name (data_unit, reg_nums[2]); 2839 else 2840 { 2841 reg_names[2] = lookup_any_reg_name (data_unit, 2842 reg_nums[2], TRUE); 2843 if (reg_nums[2] > 15) 2844 reg_brackets[2] = 1; 2845 } 2846 } 2847 } 2848 } 2849 2850 if (qr) 2851 { 2852 len = snprintf (buf, OPERAND_WIDTH, "%s%s%s,%s%s%s,%s%s%s,%s", 2853 reg_brackets[0] ? "[" : "", 2854 reg_names[0], reg_brackets[0] ? "]" : "", 2855 reg_brackets[1] ? "[" : "", 2856 reg_names[1], reg_brackets[1] ? "]" : "", 2857 reg_brackets[2] ? "[" : "", 2858 reg_names[2], reg_brackets[2] ? "]" : "", 2859 addr_reg); 2860 } 2861 else 2862 { 2863 if (imm) 2864 { 2865 /* Conform to the embedded assembler's policy of 2866 printing negative numbers as decimal and positive 2867 as hex. */ 2868 int value = ((insn_word >> 3) & IMM16_MASK); 2869 2870 if ((value & 0x8000) || value == 0) 2871 { 2872 value = sign_extend (value, IMM16_BITS); 2873 len = snprintf (buf, OPERAND_WIDTH, "%s%s%s,%s%s%s,#%d", 2874 reg_brackets[0] ? "[" : "", 2875 reg_names[0], reg_brackets[0] ? "]" : "", 2876 reg_brackets[1] ? "[" : "", 2877 reg_names[1], reg_brackets[1] ? "]" : "", 2878 value); 2879 } 2880 else 2881 { 2882 len = snprintf (buf, OPERAND_WIDTH, "%s%s%s,%s%s%s,#%#x", 2883 reg_brackets[0] ? "[" : "", 2884 reg_names[0], reg_brackets[0] ? "]" : "", 2885 reg_brackets[1] ? "[" : "", 2886 reg_names[1], reg_brackets[1] ? "]" : "", 2887 value); 2888 } 2889 } 2890 else 2891 { 2892 len = snprintf (buf, OPERAND_WIDTH, "%s%s%s,%s%s%s,%s%s%s", 2893 reg_brackets[0] ? "[" : "", 2894 reg_names[0], reg_brackets[0] ? "]" : "", 2895 reg_brackets[1] ? "[" : "", reg_names[1], 2896 reg_brackets[1] ? "]" : "", 2897 reg_brackets[2] ? "[" : "", 2898 reg_names[2], reg_brackets[2] ? "]" : ""); 2899 } 2900 } 2901 } 2902 2903 snprintf (prefix, DSP_PREFIX_WIDTH, "D%s%s%s%s%s%s%s%s%s%s%s%s", 2904 cc_flags ? cc_flags : "", 2905 is_dual ? "L" : "", 2906 is_quickrot64 ? "Q" : "", 2907 is_unsigned ? "U" : "", 2908 is_mod ? "M" : "", 2909 is_acc_zero ? "Z" : "", 2910 is_acc_add ? "P" : "", is_acc_sub ? "N" : "", 2911 is_overflow ? "O" : "", 2912 is_w_mx ? "W" : "", 2913 is_b_mx ? "B" : "", 2914 is_template ? "T" : ""); 2915 } 2916 else if (template->arg_type & DSP_ARGS_2) /* Group 2. */ 2917 { 2918 bfd_boolean is_template; 2919 bfd_boolean o2r = FALSE; 2920 int major = MAJOR_OPCODE (template->meta_opcode); 2921 bfd_boolean is_neg_or_mov = (major == OPC_ADD || major == OPC_SUB); 2922 bfd_boolean is_cmp_tst = ((major == OPC_CMP) && 2923 ((insn_word & 0x0000002c) == 0)); 2924 bfd_boolean is_fpu_mov = template->insn_type == INSN_DSP_FPU; 2925 bfd_boolean to_fpu = (template->meta_opcode >> 7) & 0x1; 2926 2927 if (major == OPC_9) 2928 imm = (insn_word & 0x2); 2929 else if (template->arg_type & DSP_ARGS_IMM) 2930 imm = ((insn_word >> 25) & 0x1); 2931 2932 is_template = (((insn_word & 0x02000002) == 0x2) && 2933 major != OPC_9); 2934 2935 if (imm) 2936 is_dual = ((insn_word >> 0x2) & 0x1); 2937 else 2938 is_dual = ((insn_word >> 0x4) & 0x1); 2939 2940 /* MOV and XSD[BW] do not have o2r. */ 2941 if (major != OPC_9 && major != OPC_MISC) 2942 o2r = (insn_word & 0x1); 2943 2944 if (is_neg_or_mov) 2945 { 2946 is_mod = (insn_word & 0x8); 2947 is_overflow = (insn_word & 0x20); 2948 } 2949 2950 /* XSD */ 2951 if (major == OPC_MISC) 2952 data_unit = (insn_word & 0x1) ? UNIT_D1 : UNIT_D0; 2953 else 2954 data_unit = ((insn_word >> 24) & 0x1) ? UNIT_D1 : UNIT_D0; 2955 2956 /* Check for NEG,MOV,ABS,FFB, etc. */ 2957 if (is_neg_or_mov || !is_cmp_tst || imm || 2958 MAJOR_OPCODE (insn_word) == OPC_9 || 2959 MAJOR_OPCODE (insn_word) == OPC_MISC) 2960 reg_nums[0] = ((insn_word >> 19) & REG_MASK); 2961 else 2962 reg_nums[0] = ((insn_word >> 14) & REG_MASK); 2963 2964 if (is_template) 2965 { 2966 is_w_mx = (insn_word & 0x1); 2967 2968 /* These are dummy arguments anyway so the register number 2969 does not matter. */ 2970 if (is_fpu_mov) 2971 { 2972 if (to_fpu) 2973 { 2974 reg_names[0] = lookup_reg_name (UNIT_FX, 0); 2975 reg_names[1] = lookup_reg_name (data_unit, 0); 2976 } 2977 else 2978 { 2979 reg_names[0] = lookup_reg_name (data_unit, 0); 2980 reg_names[1] = lookup_reg_name (UNIT_FX, 0); 2981 } 2982 } 2983 else 2984 { 2985 reg_names[0] = lookup_reg_name (data_unit, 0); 2986 reg_names[1] = lookup_reg_name (data_unit, 0); 2987 } 2988 2989 len = snprintf (buf, OPERAND_WIDTH, "%s,%s", 2990 reg_names[0], reg_names[1]); 2991 2992 decode_template_definition (insn_word, buf + len, 2993 OPERAND_WIDTH - len); 2994 } 2995 else 2996 { 2997 if (imm) 2998 { 2999 /* Conform to the embedded assembler's policy of 3000 printing negative numbers as decimal and positive as 3001 hex. */ 3002 unsigned int value = ((insn_word >> 3) & IMM16_MASK); 3003 3004 if (major == OPC_9) 3005 { 3006 data_unit = (insn_word & 0x1) ? UNIT_D1 : UNIT_D0; 3007 is_dual = (insn_word & 0x4); 3008 3009 reg_names[0] = __lookup_dsp_name (reg_nums[0], data_unit); 3010 } 3011 else 3012 { 3013 reg_names[0] = lookup_any_reg_name (data_unit, reg_nums[0], TRUE); 3014 if (reg_nums[0] > 15) 3015 reg_brackets[0] = 1; 3016 } 3017 3018 if ((value & 0x8000) || value == 0) 3019 { 3020 value = sign_extend (value, IMM16_BITS); 3021 snprintf (buf, OPERAND_WIDTH, "%s%s%s,#%d", 3022 reg_brackets[0] ? "[" : "", 3023 reg_names[0], reg_brackets[0] ? "]" : "", 3024 value); 3025 } 3026 else 3027 { 3028 snprintf (buf, OPERAND_WIDTH, "%s%s%s,#0x%x", 3029 reg_brackets[0] ? "[" : "", 3030 reg_names[0], reg_brackets[0] ? "]" : "", 3031 value); 3032 } 3033 } 3034 else 3035 { 3036 if (is_neg_or_mov || is_cmp_tst) 3037 reg_nums[1] = ((insn_word >> 9) & REG_MASK); 3038 else 3039 reg_nums[1] = ((insn_word >> 14) & REG_MASK); 3040 3041 if (major == OPC_9) 3042 { 3043 is_dual = (insn_word & 0x4); 3044 data_unit = (insn_word & 0x1) ? UNIT_D1 : UNIT_D0; 3045 3046 if (MINOR_OPCODE (template->meta_opcode) == 0x1) 3047 reg_names[0] = __lookup_dsp_name (reg_nums[0], data_unit); 3048 else 3049 reg_names[0] = lookup_reg_name (data_unit, reg_nums[0]); 3050 } 3051 else 3052 { 3053 unsigned int reg0_unit = data_unit; 3054 3055 if (is_fpu_mov && to_fpu) 3056 reg0_unit = UNIT_FX; 3057 3058 reg_names[0] = lookup_any_reg_name (reg0_unit, reg_nums[0], 3059 (!is_neg_or_mov && is_cmp_tst)); 3060 if (reg_nums[0] > 15) 3061 reg_brackets[0] = 1; 3062 } 3063 3064 if (o2r) 3065 reg_names[1] = lookup_o2r (data_unit, reg_nums[1]); 3066 else 3067 { 3068 /* Check for accumulator argument. */ 3069 if (is_neg_or_mov && ((insn_word & 0x80) == 0x80)) 3070 { 3071 if (data_unit == UNIT_D0) 3072 reg_names[1] = lookup_dsp_name (reg_nums[1], UNIT_ACC_D0); 3073 else 3074 reg_names[1] = lookup_dsp_name (reg_nums[1], UNIT_ACC_D1); 3075 } 3076 else 3077 { 3078 if (major == OPC_9) 3079 { 3080 if (MINOR_OPCODE (template->meta_opcode) == 0x1) 3081 { 3082 reg_names[1] = lookup_reg_name (data_unit, reg_nums[1]); 3083 } 3084 else 3085 { 3086 enum metag_unit u; 3087 3088 u = (insn_word & 0x1) ? UNIT_RAM_D1 : UNIT_RAM_D0; 3089 reg_names[1] = lookup_dsp_name (reg_nums[1], u); 3090 } 3091 } 3092 else 3093 { 3094 reg_names[1] = lookup_any_reg_name (data_unit, 3095 reg_nums[1], TRUE); 3096 if (reg_nums[1] > 15) 3097 reg_brackets[1] = 1; 3098 } 3099 } 3100 } 3101 3102 snprintf (buf, OPERAND_WIDTH, "%s%s%s,%s%s%s", 3103 reg_brackets[0] ? "[" : "", reg_names[0], 3104 reg_brackets[0] ? "]" : "", 3105 reg_brackets[1] ? "[" : "", reg_names[1], 3106 reg_brackets[1] ? "]" : ""); 3107 } 3108 } 3109 3110 snprintf (prefix, DSP_PREFIX_WIDTH, "D%s%s%s%s%s%s", 3111 is_fpu_mov ? "F" : "", 3112 is_dual ? "L" : "", 3113 is_mod ? "M" : "", is_overflow ? "O" : "", 3114 is_w_mx ? "W" : "", 3115 is_template ? "T" : ""); 3116 } 3117 else /* Group 3. */ 3118 { 3119 /* If both the C and CA bits are set, then the Rd register can 3120 be in any unit. Figure out which unit from the Ud field. */ 3121 bfd_boolean all_units = (((insn_word) & 0x04000020) == 0x04000020); 3122 enum metag_unit ud_unit = ((insn_word >> 1) & UNIT_MASK); 3123 enum metag_unit ram_unit, acc_unit; 3124 bfd_boolean round = FALSE; 3125 bfd_boolean clamp9 = FALSE; 3126 bfd_boolean clamp8 = FALSE; 3127 bfd_boolean is_template = ((insn_word & 0x04000002) == 0x2); 3128 3129 imm = ((insn_word >> 25) & 0x1); 3130 ac = (insn_word & 0x1); 3131 3132 conditional = (MINOR_OPCODE (insn_word) & 0x4); 3133 3134 /* Check for conditional and not Condition Always. */ 3135 if (conditional && !(insn_word & 0x20)) 3136 cc_flags = lookup_scc_flags ((insn_word >> 1) & CC_MASK); 3137 else if (!(conditional && (insn_word & 0x20))) 3138 is_dual = ((insn_word >> 0x4) & 0x1); 3139 3140 /* Conditional instructions don't have the L1 or RSPP fields. */ 3141 if ((insn_word & 0x04000000) == 0) 3142 { 3143 round = (((insn_word >> 2) & 0x3) == 0x1); 3144 clamp9 = (((insn_word >> 2) & 0x3) == 0x2); 3145 clamp8 = (((insn_word >> 2) & 0x3) == 0x3); 3146 } 3147 3148 /* Read DU bit. */ 3149 data_unit = ((insn_word >> 24) & 0x1) ? UNIT_D1 : UNIT_D0; 3150 reg_nums[0] = ((insn_word >> 19) & REG_MASK); 3151 reg_nums[1] = ((insn_word >> 14) & REG_MASK); 3152 3153 ram_unit = (data_unit == UNIT_D0) ? UNIT_RAM_D0 : UNIT_RAM_D1; 3154 acc_unit = (data_unit == UNIT_D0) ? UNIT_ACC_D0 : UNIT_ACC_D1; 3155 3156 if (all_units) 3157 reg_names[0] = lookup_reg_name (ud_unit, reg_nums[0]); 3158 else 3159 { 3160 if (conditional) 3161 reg_names[0] = lookup_reg_name (data_unit, reg_nums[0]); 3162 else 3163 { 3164 reg_names[0] = lookup_any_reg_name (data_unit, reg_nums[0], FALSE); 3165 if (reg_nums[0] > 15) 3166 reg_brackets[0] = 1; 3167 } 3168 } 3169 3170 if (ac) 3171 { 3172 reg_names[1] = lookup_dsp_name (reg_nums[1], acc_unit); 3173 } 3174 else 3175 { 3176 reg_names[1] = lookup_any_reg_name (data_unit, reg_nums[1], TRUE); 3177 if (reg_nums[1] > 15) 3178 reg_brackets[1] = 1; 3179 } 3180 3181 if (imm) 3182 { 3183 snprintf (buf, OPERAND_WIDTH, "%s%s%s,%s%s%s,#%#x", 3184 reg_brackets[0] ? "[" : "", 3185 reg_names[0], reg_brackets[0] ? "]" : "", 3186 reg_brackets[1] ? "[" : "", 3187 reg_names[1], reg_brackets[1] ? "]" : "", 3188 ((insn_word >> 9) & IMM5_MASK)); 3189 } 3190 else 3191 { 3192 reg_nums[2] = ((insn_word >> 9) & REG_MASK); 3193 3194 reg_names[2] = lookup_any_reg_name (data_unit, reg_nums[2], TRUE); 3195 3196 if (reg_nums[2] > 15) 3197 reg_brackets[2] = 1; 3198 3199 if (is_template) 3200 { 3201 bfd_boolean load = ((insn_word >> 13) & 0x1); 3202 bfd_boolean dspram = (((insn_word >> 17) & 0x3) == 0x3); 3203 const char *tname[1]; 3204 unsigned int tidx = ((insn_word >> 9) & TEMPLATE_REGS_MASK); 3205 enum metag_unit au; 3206 unsigned int addr_reg_nums[2]; 3207 const char *addr_reg_names[2]; 3208 const char *post_op = ""; 3209 const char *join_op = ""; 3210 3211 is_w_mx = ((insn_word >> 5) & 0x1); 3212 3213 tname[0] = lookup_dsp_name (tidx, UNIT_DT); 3214 3215 /* These are dummy arguments anyway */ 3216 reg_names[0] = lookup_reg_name (data_unit, 0); 3217 if (ac) 3218 reg_names[1] = lookup_dsp_name (16, acc_unit); 3219 else 3220 reg_names[1] = lookup_reg_name (data_unit, 0); 3221 reg_names[2] = lookup_reg_name (data_unit, 0); 3222 3223 addr_reg_names[1] = ""; 3224 3225 if (dspram) 3226 { 3227 ram_unit = (data_unit == UNIT_D0) ? UNIT_RAM_D0 : UNIT_RAM_D1; 3228 addr_reg_nums[0] = ((insn_word >> 19) & REG_MASK); 3229 addr_reg_names[0] = lookup_dspram_name (addr_reg_nums[0], 3230 ram_unit, load); 3231 } 3232 else 3233 { 3234 bfd_boolean im = (((insn_word >> 18) & 0x1) != 0); 3235 3236 au = (((insn_word >> 23) & 0x1) == 0) ? UNIT_A0 : UNIT_A1; 3237 addr_reg_nums[0] = ((insn_word >> 19) & DSP_REG_MASK); 3238 3239 addr_reg_names[0] = lookup_reg_name (au, addr_reg_nums[0]); 3240 3241 if (im) 3242 { 3243 unsigned int im_value = ((insn_word >> 14) & 0x3); 3244 3245 switch (im_value) 3246 { 3247 case 0x1: 3248 post_op = "++"; 3249 break; 3250 case 0x3: 3251 post_op = "--"; 3252 break; 3253 } 3254 } 3255 else 3256 { 3257 addr_reg_nums[1] = ((insn_word >> 14) & DSP_REG_MASK); 3258 addr_reg_names[1] = lookup_reg_name (au, addr_reg_nums[1]); 3259 join_op = "+"; 3260 post_op = "++"; 3261 } 3262 } 3263 3264 if (load) 3265 { 3266 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s %s,[%s%s%s%s]", 3267 reg_names[0], reg_names[1], reg_names[2], 3268 tname[0], addr_reg_names[0], join_op, 3269 addr_reg_names[1], post_op); 3270 } 3271 else 3272 { 3273 snprintf (buf, OPERAND_WIDTH, "%s,%s,%s [%s%s%s%s],%s", 3274 reg_names[0], reg_names[1], reg_names[2], 3275 addr_reg_names[0], join_op, addr_reg_names[1], 3276 post_op, tname[0]); 3277 } 3278 } 3279 else 3280 { 3281 snprintf (buf, OPERAND_WIDTH, "%s%s%s,%s%s%s,%s%s%s", 3282 reg_brackets[0] ? "[" : "", 3283 reg_names[0], reg_brackets[0] ? "]" : "", 3284 reg_brackets[1] ? "[" : "", 3285 reg_names[1], reg_brackets[1] ? "]" : "", 3286 reg_brackets[2] ? "[" : "", 3287 reg_names[2], reg_brackets[2] ? "]" : ""); 3288 } 3289 } 3290 3291 snprintf (prefix, DSP_PREFIX_WIDTH, "D%s%s%s%s%s%s%s", 3292 cc_flags ? cc_flags : "", 3293 is_dual ? "L" : "", clamp9 ? "G" : "", 3294 clamp8 ? "B" : "", round ? "R" : "", 3295 is_w_mx ? "W" : "", 3296 is_template ? "T" : ""); 3297 } 3298 3299 print_insn (outf, prefix, template->name, buf); 3300 3301 } 3302 3303 typedef void (*insn_printer)(unsigned int, bfd_vma, const insn_template *, 3304 disassemble_info *); 3305 3306 /* Printer table. */ 3307 static const insn_printer insn_printers[ENC_MAX] = 3308 { 3309 [ENC_NONE] = print_none, 3310 [ENC_MOV_U2U] = print_mov_u2u, 3311 [ENC_MOV_PORT] = print_mov_port, 3312 [ENC_MMOV] = print_mmov, 3313 [ENC_MDRD] = print_mdrd, 3314 [ENC_MOVL_TTREC] = print_movl_ttrec, 3315 [ENC_GET_SET] = print_get_set, 3316 [ENC_GET_SET_EXT] = print_get_set_ext, 3317 [ENC_MGET_MSET] = print_mget_mset, 3318 [ENC_COND_SET] = print_cond_set, 3319 [ENC_XFR] = print_xfr, 3320 [ENC_MOV_CT] = print_mov_ct, 3321 [ENC_SWAP] = print_swap, 3322 [ENC_JUMP] = print_jump, 3323 [ENC_CALLR] = print_callr, 3324 [ENC_ALU] = print_alu, 3325 [ENC_SHIFT] = print_shift, 3326 [ENC_MIN_MAX] = print_min_max, 3327 [ENC_BITOP] = print_bitop, 3328 [ENC_CMP] = print_cmp, 3329 [ENC_BRANCH] = print_branch, 3330 [ENC_KICK] = print_mov_u2u, 3331 [ENC_SWITCH] = print_switch, 3332 [ENC_CACHER] = print_cacher, 3333 [ENC_CACHEW] = print_cachew, 3334 [ENC_ICACHE] = print_icache, 3335 [ENC_LNKGET] = print_lnkget, 3336 [ENC_FMOV] = print_fmov, 3337 [ENC_FMMOV] = print_fmmov, 3338 [ENC_FMOV_DATA] = print_fmov_data, 3339 [ENC_FMOV_I] = print_fmov_i, 3340 [ENC_FPACK] = print_fpack, 3341 [ENC_FSWAP] = print_fswap, 3342 [ENC_FCMP] = print_fcmp, 3343 [ENC_FMINMAX] = print_fminmax, 3344 [ENC_FCONV] = print_fconv, 3345 [ENC_FCONVX] = print_fconvx, 3346 [ENC_FBARITH] = print_fbarith, 3347 [ENC_FEARITH] = print_fearith, 3348 [ENC_FREC] = print_frec, 3349 [ENC_FSIMD] = print_fsimd, 3350 [ENC_FGET_SET_ACF] = print_fget_set_acf, 3351 [ENC_DGET_SET] = print_dget_set, 3352 [ENC_DTEMPLATE] = print_dtemplate, 3353 [ENC_DALU] = print_dalu, 3354 }; 3355 3356 /* Entry point for instruction printing. */ 3357 int 3358 print_insn_metag (bfd_vma pc, disassemble_info *outf) 3359 { 3360 bfd_byte buf[4]; 3361 unsigned int insn_word; 3362 size_t i; 3363 outf->bytes_per_chunk = 4; 3364 3365 (*outf->read_memory_func) (pc & ~0x03, buf, 4, outf); 3366 insn_word = bfd_getl32 (buf); 3367 3368 for (i = 0; i < sizeof(metag_optab)/sizeof(metag_optab[0]); i++) 3369 { 3370 const insn_template *template = &metag_optab[i]; 3371 3372 if ((insn_word & template->meta_mask) == template->meta_opcode) 3373 { 3374 enum insn_encoding encoding = template->encoding; 3375 insn_printer printer = insn_printers[encoding]; 3376 3377 if (printer) 3378 printer (insn_word, pc, template, outf); 3379 3380 return 4; 3381 } 3382 } 3383 3384 return 4; 3385 } 3386
