1 /* Disassemble MSP430 instructions. 2 Copyright (C) 2002-2024 Free Software Foundation, Inc. 3 4 Contributed by Dmitry Diky <diwil@mail.ru> 5 6 This file is part of the GNU opcodes library. 7 8 This library is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 It is distributed in the hope that it will be useful, but WITHOUT 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 16 License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 #include "sysdep.h" 24 #include <stdio.h> 25 #include <ctype.h> 26 #include <sys/types.h> 27 #include <errno.h> 28 29 #include "disassemble.h" 30 #include "opintl.h" 31 #include "libiberty.h" 32 33 #define DASM_SECTION 34 #include "opcode/msp430.h" 35 #undef DASM_SECTION 36 37 38 #define PS(x) (0xffff & (x)) 39 40 static bool 41 msp430dis_read_two_bytes (bfd_vma addr, 42 disassemble_info * info, 43 bfd_byte * buffer, 44 char * comm) 45 { 46 int status; 47 48 status = info->read_memory_func (addr, buffer, 2, info); 49 if (status == 0) 50 return true; 51 52 /* PR 20150: A status of EIO means that there were no more bytes left 53 to read in the current section. This can happen when disassembling 54 interrupt vectors for example. Avoid cluttering the output with 55 unhelpful error messages in this case. */ 56 if (status == EIO) 57 { 58 if (comm) 59 sprintf (comm, _("Warning: disassembly unreliable - not enough bytes available")); 60 } 61 else 62 { 63 info->memory_error_func (status, addr, info); 64 if (comm) 65 sprintf (comm, _("Error: read from memory failed")); 66 } 67 68 return false; 69 } 70 71 static bool 72 msp430dis_opcode_unsigned (bfd_vma addr, 73 disassemble_info * info, 74 unsigned short * return_val, 75 char * comm) 76 { 77 bfd_byte buffer[2]; 78 79 if (msp430dis_read_two_bytes (addr, info, buffer, comm)) 80 { 81 * return_val = bfd_getl16 (buffer); 82 return true; 83 } 84 else 85 { 86 * return_val = 0; 87 return false; 88 } 89 } 90 91 static bool 92 msp430dis_opcode_signed (bfd_vma addr, 93 disassemble_info * info, 94 signed int * return_val, 95 char * comm) 96 { 97 bfd_byte buffer[2]; 98 99 if (msp430dis_read_two_bytes (addr, info, buffer, comm)) 100 { 101 int status; 102 103 status = bfd_getl_signed_16 (buffer); 104 if (status & 0x8000) 105 status |= -1U << 16; 106 * return_val = status; 107 return true; 108 } 109 else 110 { 111 * return_val = 0; 112 return false; 113 } 114 } 115 116 static int 117 msp430_nooperands (struct msp430_opcode_s *opcode, 118 bfd_vma addr ATTRIBUTE_UNUSED, 119 unsigned short insn ATTRIBUTE_UNUSED, 120 char *comm, 121 int *cycles) 122 { 123 /* Pop with constant. */ 124 if (insn == 0x43b2) 125 return 0; 126 if (insn == opcode->bin_opcode) 127 return 2; 128 129 if (opcode->fmt == 0) 130 { 131 if ((insn & 0x0f00) != 0x0300 || (insn & 0x0f00) != 0x0200) 132 return 0; 133 134 strcpy (comm, "emulated..."); 135 *cycles = 1; 136 } 137 else 138 { 139 strcpy (comm, "return from interupt"); 140 *cycles = 5; 141 } 142 143 return 2; 144 } 145 146 static int 147 print_as2_reg_name (int regno, char * op1, char * comm1, 148 int c2, int c3, int cd) 149 { 150 switch (regno) 151 { 152 case 2: 153 sprintf (op1, "#4"); 154 sprintf (comm1, "r2 As==10"); 155 return c2; 156 157 case 3: 158 sprintf (op1, "#2"); 159 sprintf (comm1, "r3 As==10"); 160 return c3; 161 162 default: 163 /* Indexed register mode @Rn. */ 164 sprintf (op1, "@r%d", regno); 165 return cd; 166 } 167 } 168 169 static int 170 print_as3_reg_name (int regno, char * op1, char * comm1, 171 int c2, int c3, int cd) 172 { 173 switch (regno) 174 { 175 case 2: 176 sprintf (op1, "#8"); 177 sprintf (comm1, "r2 As==11"); 178 return c2; 179 180 case 3: 181 sprintf (op1, "#-1"); 182 sprintf (comm1, "r3 As==11"); 183 return c3; 184 185 default: 186 /* Post incremented @Rn+. */ 187 sprintf (op1, "@r%d+", regno); 188 return cd; 189 } 190 } 191 192 static int 193 msp430_singleoperand (disassemble_info *info, 194 struct msp430_opcode_s *opcode, 195 bfd_vma addr, 196 unsigned short insn, 197 char *op, 198 char *comm, 199 unsigned short extension_word, 200 int *cycles) 201 { 202 int regs = 0, regd = 0; 203 int ad = 0, as = 0; 204 int where = 0; 205 int cmd_len = 2; 206 int dst = 0; 207 int fmt; 208 int extended_dst = extension_word & 0xf; 209 210 regd = insn & 0x0f; 211 regs = (insn & 0x0f00) >> 8; 212 as = (insn & 0x0030) >> 4; 213 ad = (insn & 0x0080) >> 7; 214 215 if (opcode->fmt < 0) 216 fmt = (- opcode->fmt) - 1; 217 else 218 fmt = opcode->fmt; 219 220 switch (fmt) 221 { 222 case 0: /* Emulated work with dst register. */ 223 if (regs != 2 && regs != 3 && regs != 1) 224 return 0; 225 226 /* Check if not clr insn. */ 227 if (opcode->bin_opcode == 0x4300 && (ad || as)) 228 return 0; 229 230 /* Check if really inc, incd insns. */ 231 if ((opcode->bin_opcode & 0xff00) == 0x5300 && as == 3) 232 return 0; 233 234 if (ad == 0) 235 { 236 *cycles = 1; 237 238 /* Register. */ 239 if (regd == 0) 240 { 241 *cycles += 1; 242 sprintf (op, "r0"); 243 } 244 else if (regd == 1) 245 sprintf (op, "r1"); 246 247 else if (regd == 2) 248 sprintf (op, "r2"); 249 250 else 251 sprintf (op, "r%d", regd); 252 } 253 else /* ad == 1 msp430dis_opcode. */ 254 { 255 if (regd == 0) 256 { 257 /* PC relative. */ 258 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm)) 259 { 260 cmd_len += 2; 261 *cycles = 4; 262 sprintf (op, "0x%04x", dst); 263 sprintf (comm, "PC rel. abs addr 0x%04x", 264 PS ((short) (addr + 2) + dst)); 265 if (extended_dst) 266 { 267 dst |= extended_dst << 16; 268 sprintf (op, "0x%05x", dst); 269 sprintf (comm, "PC rel. abs addr 0x%05lx", 270 (long)((addr + 2 + dst) & 0xfffff)); 271 } 272 } 273 else 274 return -1; 275 } 276 else if (regd == 2) 277 { 278 /* Absolute. */ 279 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm)) 280 { 281 cmd_len += 2; 282 *cycles = 4; 283 sprintf (op, "&0x%04x", PS (dst)); 284 if (extended_dst) 285 { 286 dst |= extended_dst << 16; 287 sprintf (op, "&0x%05x", dst & 0xfffff); 288 } 289 } 290 else 291 return -1; 292 } 293 else 294 { 295 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm)) 296 { 297 cmd_len += 2; 298 *cycles = 4; 299 if (extended_dst) 300 { 301 dst |= extended_dst << 16; 302 if (dst & 0x80000) 303 dst |= -1U << 20; 304 } 305 sprintf (op, "%d(r%d)", dst, regd); 306 } 307 else 308 return -1; 309 } 310 } 311 break; 312 313 case 2: /* rrc, push, call, swpb, rra, sxt, push, call, reti etc... */ 314 if (as == 0) 315 { 316 if (regd == 3) 317 { 318 /* Constsnts. */ 319 sprintf (op, "#0"); 320 sprintf (comm, "r3 As==00"); 321 } 322 else 323 { 324 /* Register. */ 325 sprintf (op, "r%d", regd); 326 } 327 *cycles = 1; 328 } 329 else if (as == 2) 330 { 331 * cycles = print_as2_reg_name (regd, op, comm, 1, 1, 3); 332 } 333 else if (as == 3) 334 { 335 if (regd == 0) 336 { 337 *cycles = 3; 338 /* absolute. @pc+ */ 339 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm)) 340 { 341 cmd_len += 2; 342 sprintf (op, "#%d", dst); 343 if (dst > 9 || dst < 0) 344 sprintf (comm, "#0x%04x", PS (dst)); 345 if (extended_dst) 346 { 347 dst |= extended_dst << 16; 348 if (dst & 0x80000) 349 dst |= -1U << 20; 350 sprintf (op, "#%d", dst); 351 if (dst > 9 || dst < 0) 352 sprintf (comm, "#0x%05x", dst); 353 } 354 } 355 else 356 return -1; 357 } 358 else 359 * cycles = print_as3_reg_name (regd, op, comm, 1, 1, 3); 360 } 361 else if (as == 1) 362 { 363 *cycles = 4; 364 if (regd == 0) 365 { 366 /* PC relative. */ 367 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm)) 368 { 369 cmd_len += 2; 370 sprintf (op, "0x%04x", PS (dst)); 371 sprintf (comm, "PC rel. 0x%04x", 372 PS ((short) addr + 2 + dst)); 373 if (extended_dst) 374 { 375 dst |= extended_dst << 16; 376 sprintf (op, "0x%05x", dst & 0xffff); 377 sprintf (comm, "PC rel. 0x%05lx", 378 (long)((addr + 2 + dst) & 0xfffff)); 379 } 380 } 381 else 382 return -1; 383 } 384 else if (regd == 2) 385 { 386 /* Absolute. */ 387 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm)) 388 { 389 cmd_len += 2; 390 sprintf (op, "&0x%04x", PS (dst)); 391 if (extended_dst) 392 { 393 dst |= extended_dst << 16; 394 sprintf (op, "&0x%05x", dst & 0xfffff); 395 } 396 } 397 else 398 return -1; 399 } 400 else if (regd == 3) 401 { 402 *cycles = 1; 403 sprintf (op, "#1"); 404 sprintf (comm, "r3 As==01"); 405 } 406 else 407 { 408 /* Indexed. */ 409 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm)) 410 { 411 cmd_len += 2; 412 if (extended_dst) 413 { 414 dst |= extended_dst << 16; 415 if (dst & 0x80000) 416 dst |= -1U << 20; 417 } 418 sprintf (op, "%d(r%d)", dst, regd); 419 if (dst > 9 || dst < 0) 420 sprintf (comm, "%05x", dst); 421 } 422 else 423 return -1; 424 } 425 } 426 break; 427 428 case 3: /* Jumps. */ 429 where = insn & 0x03ff; 430 if (where & 0x200) 431 where |= ~0x03ff; 432 if (where > 512 || where < -511) 433 return 0; 434 435 where *= 2; 436 sprintf (op, "$%+-8d", where + 2); 437 sprintf (comm, "abs 0x%lx", (long) (addr + 2 + where)); 438 *cycles = 2; 439 return 2; 440 break; 441 442 default: 443 cmd_len = 0; 444 } 445 446 return cmd_len; 447 } 448 449 static int 450 msp430_doubleoperand (disassemble_info *info, 451 struct msp430_opcode_s *opcode, 452 bfd_vma addr, 453 unsigned short insn, 454 char *op1, 455 char *op2, 456 char *comm1, 457 char *comm2, 458 unsigned short extension_word, 459 int *cycles) 460 { 461 int regs = 0, regd = 0; 462 int ad = 0, as = 0; 463 int cmd_len = 2; 464 int dst = 0; 465 int fmt; 466 int extended_dst = extension_word & 0xf; 467 int extended_src = (extension_word >> 7) & 0xf; 468 469 regd = insn & 0x0f; 470 regs = (insn & 0x0f00) >> 8; 471 as = (insn & 0x0030) >> 4; 472 ad = (insn & 0x0080) >> 7; 473 474 if (opcode->fmt < 0) 475 fmt = (- opcode->fmt) - 1; 476 else 477 fmt = opcode->fmt; 478 479 if (fmt == 0) 480 { 481 /* Special case: rla and rlc are the only 2 emulated instructions that 482 fall into two operand instructions. */ 483 /* With dst, there are only: 484 Rm Register, 485 x(Rm) Indexed, 486 0xXXXX Relative, 487 &0xXXXX Absolute 488 emulated_ins dst 489 basic_ins dst, dst. */ 490 491 if (regd != regs || as != ad) 492 return 0; /* May be 'data' section. */ 493 494 if (ad == 0) 495 { 496 /* Register mode. */ 497 if (regd == 3) 498 { 499 strcpy (comm1, _("Warning: illegal as emulation instr")); 500 return -1; 501 } 502 503 sprintf (op1, "r%d", regd); 504 *cycles = 1; 505 } 506 else /* ad == 1 */ 507 { 508 if (regd == 0) 509 { 510 /* PC relative, Symbolic. */ 511 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 512 { 513 cmd_len += 4; 514 *cycles = 6; 515 sprintf (op1, "0x%04x", PS (dst)); 516 sprintf (comm1, "PC rel. 0x%04x", 517 PS ((short) addr + 2 + dst)); 518 if (extension_word) 519 { 520 dst |= extended_dst << 16; 521 if (dst & 0x80000) 522 dst |= -1U << 20; 523 sprintf (op1, "0x%05x", dst & 0xfffff); 524 sprintf (comm1, "PC rel. 0x%05lx", 525 (long)((addr + 2 + dst) & 0xfffff)); 526 } 527 } 528 else 529 return -1; 530 } 531 else if (regd == 2) 532 { 533 /* Absolute. */ 534 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 535 { 536 int src; 537 538 /* If the 'src' field is not the same as the dst 539 then this is not an rla instruction. */ 540 if (msp430dis_opcode_signed (addr + 4, info, &src, comm2)) 541 { 542 if (src != dst) 543 return 0; 544 } 545 else 546 return -1; 547 cmd_len += 4; 548 *cycles = 6; 549 sprintf (op1, "&0x%04x", PS (dst)); 550 if (extension_word) 551 { 552 dst |= extended_dst << 16; 553 sprintf (op1, "&0x%05x", dst & 0xfffff); 554 } 555 } 556 else 557 return -1; 558 } 559 else 560 { 561 /* Indexed. */ 562 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 563 { 564 if (extension_word) 565 { 566 dst |= extended_dst << 16; 567 if (dst & 0x80000) 568 dst |= -1U << 20; 569 } 570 cmd_len += 4; 571 *cycles = 6; 572 sprintf (op1, "%d(r%d)", dst, regd); 573 if (dst > 9 || dst < -9) 574 sprintf (comm1, "#0x%05x", dst); 575 } 576 else 577 return -1; 578 } 579 } 580 581 *op2 = 0; 582 *comm2 = 0; 583 584 return cmd_len; 585 } 586 587 /* Two operands exactly. */ 588 if (ad == 0 && regd == 3) 589 { 590 /* R2/R3 are illegal as dest: may be data section. */ 591 strcpy (comm1, _("Warning: illegal as 2-op instr")); 592 return -1; 593 } 594 595 /* Source. */ 596 if (as == 0) 597 { 598 *cycles = 1; 599 if (regs == 3) 600 { 601 /* Constants. */ 602 sprintf (op1, "#0"); 603 sprintf (comm1, "r3 As==00"); 604 } 605 else 606 { 607 /* Register. */ 608 sprintf (op1, "r%d", regs); 609 } 610 } 611 else if (as == 2) 612 { 613 * cycles = print_as2_reg_name (regs, op1, comm1, 1, 1, regs == 0 ? 3 : 2); 614 } 615 else if (as == 3) 616 { 617 if (regs == 0) 618 { 619 *cycles = 3; 620 /* Absolute. @pc+. */ 621 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 622 { 623 cmd_len += 2; 624 sprintf (op1, "#%d", dst); 625 if (dst > 9 || dst < 0) 626 sprintf (comm1, "#0x%04x", PS (dst)); 627 if (extension_word) 628 { 629 dst &= 0xffff; 630 dst |= extended_src << 16; 631 if (dst & 0x80000) 632 dst |= -1U << 20; 633 sprintf (op1, "#%d", dst); 634 if (dst > 9 || dst < 0) 635 sprintf (comm1, "0x%05x", dst & 0xfffff); 636 } 637 } 638 else 639 return -1; 640 } 641 else 642 * cycles = print_as3_reg_name (regs, op1, comm1, 1, 1, 2); 643 } 644 else if (as == 1) 645 { 646 if (regs == 0) 647 { 648 *cycles = 4; 649 /* PC relative. */ 650 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 651 { 652 cmd_len += 2; 653 sprintf (op1, "0x%04x", PS (dst)); 654 sprintf (comm1, "PC rel. 0x%04x", 655 PS ((short) addr + 2 + dst)); 656 if (extension_word) 657 { 658 dst &= 0xffff; 659 dst |= extended_src << 16; 660 if (dst & 0x80000) 661 dst |= -1U << 20; 662 sprintf (op1, "0x%05x", dst & 0xfffff); 663 sprintf (comm1, "PC rel. 0x%05lx", 664 (long) ((addr + 2 + dst) & 0xfffff)); 665 } 666 } 667 else 668 return -1; 669 } 670 else if (regs == 2) 671 { 672 *cycles = 2; 673 /* Absolute. */ 674 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 675 { 676 cmd_len += 2; 677 sprintf (op1, "&0x%04x", PS (dst)); 678 sprintf (comm1, "0x%04x", PS (dst)); 679 if (extension_word) 680 { 681 dst &= 0xffff; 682 dst |= extended_src << 16; 683 sprintf (op1, "&0x%05x", dst & 0xfffff); 684 * comm1 = 0; 685 } 686 } 687 else 688 return -1; 689 } 690 else if (regs == 3) 691 { 692 *cycles = 1; 693 sprintf (op1, "#1"); 694 sprintf (comm1, "r3 As==01"); 695 } 696 else 697 { 698 *cycles = 3; 699 /* Indexed. */ 700 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 701 { 702 cmd_len += 2; 703 if (extension_word) 704 { 705 dst &= 0xffff; 706 dst |= extended_src << 16; 707 if (dst & 0x80000) 708 dst |= -1U << 20; 709 } 710 sprintf (op1, "%d(r%d)", dst, regs); 711 if (dst > 9 || dst < -9) 712 sprintf (comm1, "0x%05x", dst); 713 } 714 else 715 return -1; 716 } 717 } 718 719 /* Destination. Special care needed on addr + XXXX. */ 720 721 if (ad == 0) 722 { 723 /* Register. */ 724 if (regd == 0) 725 { 726 *cycles += 1; 727 sprintf (op2, "r0"); 728 } 729 else if (regd == 1) 730 sprintf (op2, "r1"); 731 732 else if (regd == 2) 733 sprintf (op2, "r2"); 734 735 else 736 sprintf (op2, "r%d", regd); 737 } 738 else /* ad == 1. */ 739 { 740 * cycles += 3; 741 742 if (regd == 0) 743 { 744 /* PC relative. */ 745 *cycles += 1; 746 if (msp430dis_opcode_signed (addr + cmd_len, info, &dst, comm2)) 747 { 748 sprintf (op2, "0x%04x", PS (dst)); 749 sprintf (comm2, "PC rel. 0x%04x", 750 PS ((short) addr + cmd_len + dst)); 751 if (extension_word) 752 { 753 dst |= extended_dst << 16; 754 if (dst & 0x80000) 755 dst |= -1U << 20; 756 sprintf (op2, "0x%05x", dst & 0xfffff); 757 sprintf (comm2, "PC rel. 0x%05lx", 758 (long)((addr + cmd_len + dst) & 0xfffff)); 759 } 760 } 761 else 762 return -1; 763 cmd_len += 2; 764 } 765 else if (regd == 2) 766 { 767 /* Absolute. */ 768 if (msp430dis_opcode_signed (addr + cmd_len, info, &dst, comm2)) 769 { 770 cmd_len += 2; 771 sprintf (op2, "&0x%04x", PS (dst)); 772 if (extension_word) 773 { 774 dst |= extended_dst << 16; 775 sprintf (op2, "&0x%05x", dst & 0xfffff); 776 } 777 } 778 else 779 return -1; 780 } 781 else 782 { 783 if (msp430dis_opcode_signed (addr + cmd_len, info, &dst, comm2)) 784 { 785 cmd_len += 2; 786 if (dst > 9 || dst < 0) 787 sprintf (comm2, "0x%04x", PS (dst)); 788 if (extension_word) 789 { 790 dst |= extended_dst << 16; 791 if (dst & 0x80000) 792 dst |= -1U << 20; 793 if (dst > 9 || dst < 0) 794 sprintf (comm2, "0x%05x", dst & 0xfffff); 795 } 796 sprintf (op2, "%d(r%d)", dst, regd); 797 } 798 else 799 return -1; 800 } 801 } 802 803 return cmd_len; 804 } 805 806 static int 807 msp430_branchinstr (disassemble_info *info, 808 struct msp430_opcode_s *opcode ATTRIBUTE_UNUSED, 809 bfd_vma addr ATTRIBUTE_UNUSED, 810 unsigned short insn, 811 char *op1, 812 char *comm1, 813 int *cycles) 814 { 815 int regs = 0, regd = 0; 816 int as = 0; 817 int cmd_len = 2; 818 int dst = 0; 819 unsigned short udst = 0; 820 821 regd = insn & 0x0f; 822 regs = (insn & 0x0f00) >> 8; 823 as = (insn & 0x0030) >> 4; 824 825 if (regd != 0) /* Destination register is not a PC. */ 826 return 0; 827 828 /* dst is a source register. */ 829 if (as == 0) 830 { 831 /* Constants. */ 832 if (regs == 3) 833 { 834 *cycles = 1; 835 sprintf (op1, "#0"); 836 sprintf (comm1, "r3 As==00"); 837 } 838 else 839 { 840 /* Register. */ 841 *cycles = 1; 842 sprintf (op1, "r%d", regs); 843 } 844 } 845 else if (as == 2) 846 { 847 * cycles = print_as2_reg_name (regs, op1, comm1, 2, 1, 2); 848 } 849 else if (as == 3) 850 { 851 if (regs == 0) 852 { 853 /* Absolute. @pc+ */ 854 *cycles = 3; 855 if (msp430dis_opcode_unsigned (addr + 2, info, &udst, comm1)) 856 { 857 cmd_len += 2; 858 sprintf (op1, "#0x%04x", PS (udst)); 859 } 860 else 861 return -1; 862 } 863 else 864 * cycles = print_as3_reg_name (regs, op1, comm1, 1, 1, 2); 865 } 866 else if (as == 1) 867 { 868 * cycles = 3; 869 870 if (regs == 0) 871 { 872 /* PC relative. */ 873 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 874 { 875 cmd_len += 2; 876 (*cycles)++; 877 sprintf (op1, "0x%04x", PS (dst)); 878 sprintf (comm1, "PC rel. 0x%04x", 879 PS ((short) addr + 2 + dst)); 880 } 881 else 882 return -1; 883 } 884 else if (regs == 2) 885 { 886 /* Absolute. */ 887 if (msp430dis_opcode_unsigned (addr + 2, info, &udst, comm1)) 888 { 889 cmd_len += 2; 890 sprintf (op1, "&0x%04x", PS (udst)); 891 } 892 else 893 return -1; 894 } 895 else if (regs == 3) 896 { 897 (*cycles)--; 898 sprintf (op1, "#1"); 899 sprintf (comm1, "r3 As==01"); 900 } 901 else 902 { 903 /* Indexed. */ 904 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 905 { 906 cmd_len += 2; 907 sprintf (op1, "%d(r%d)", dst, regs); 908 } 909 else 910 return -1; 911 } 912 } 913 914 return cmd_len; 915 } 916 917 static int 918 msp430x_calla_instr (disassemble_info * info, 919 bfd_vma addr, 920 unsigned short insn, 921 char * op1, 922 char * comm1, 923 int * cycles) 924 { 925 unsigned int ureg = insn & 0xf; 926 int reg = insn & 0xf; 927 int am = (insn & 0xf0) >> 4; 928 int cmd_len = 2; 929 unsigned short udst = 0; 930 int dst = 0; 931 932 switch (am) 933 { 934 case 4: /* CALLA Rdst */ 935 *cycles = 1; 936 sprintf (op1, "r%d", reg); 937 break; 938 939 case 5: /* CALLA x(Rdst) */ 940 *cycles = 3; 941 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 942 { 943 cmd_len += 2; 944 sprintf (op1, "%d(r%d)", dst, reg); 945 if (reg == 0) 946 sprintf (comm1, "PC rel. 0x%05lx", (long) (addr + 2 + dst)); 947 else 948 sprintf (comm1, "0x%05x", dst); 949 } 950 else 951 return -1; 952 break; 953 954 case 6: /* CALLA @Rdst */ 955 *cycles = 2; 956 sprintf (op1, "@r%d", reg); 957 break; 958 959 case 7: /* CALLA @Rdst+ */ 960 *cycles = 2; 961 sprintf (op1, "@r%d+", reg); 962 break; 963 964 case 8: /* CALLA &abs20 */ 965 if (msp430dis_opcode_unsigned (addr + 2, info, &udst, comm1)) 966 { 967 cmd_len += 2; 968 *cycles = 4; 969 sprintf (op1, "&%d", (ureg << 16) + udst); 970 sprintf (comm1, "0x%05x", (ureg << 16) + udst); 971 } 972 else 973 return -1; 974 break; 975 976 case 9: /* CALLA pcrel-sym */ 977 if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1)) 978 { 979 cmd_len += 2; 980 *cycles = 4; 981 sprintf (op1, "%d(PC)", (reg << 16) + dst); 982 sprintf (comm1, "PC rel. 0x%05lx", 983 (long) (addr + 2 + dst + (reg << 16))); 984 } 985 else 986 return -1; 987 break; 988 989 case 11: /* CALLA #imm20 */ 990 if (msp430dis_opcode_unsigned (addr + 2, info, &udst, comm1)) 991 { 992 cmd_len += 2; 993 *cycles = 4; 994 sprintf (op1, "#%d", (ureg << 16) + udst); 995 sprintf (comm1, "0x%05x", (ureg << 16) + udst); 996 } 997 else 998 return -1; 999 break; 1000 1001 default: 1002 strcpy (comm1, _("Warning: unrecognised CALLA addressing mode")); 1003 return -1; 1004 } 1005 1006 return cmd_len; 1007 } 1008 1009 int 1010 print_insn_msp430 (bfd_vma addr, disassemble_info *info) 1011 { 1012 void *stream = info->stream; 1013 fprintf_ftype prin = info->fprintf_func; 1014 struct msp430_opcode_s *opcode; 1015 char op1[32], op2[32], comm1[64], comm2[64]; 1016 int cmd_len = 0; 1017 unsigned short insn; 1018 int cycles = 0; 1019 char *bc = ""; 1020 unsigned short extension_word = 0; 1021 unsigned short bits; 1022 1023 if (! msp430dis_opcode_unsigned (addr, info, &insn, NULL)) 1024 return -1; 1025 1026 if (((int) addr & 0xffff) > 0xffdf) 1027 { 1028 (*prin) (stream, "interrupt service routine at 0x%04x", 0xffff & insn); 1029 return 2; 1030 } 1031 1032 *comm1 = 0; 1033 *comm2 = 0; 1034 1035 /* Check for an extension word. */ 1036 if ((insn & 0xf800) == 0x1800) 1037 { 1038 extension_word = insn; 1039 addr += 2; 1040 if (! msp430dis_opcode_unsigned (addr, info, &insn, NULL)) 1041 return -1; 1042 } 1043 1044 for (opcode = msp430_opcodes; opcode->name; opcode++) 1045 { 1046 if ((insn & opcode->bin_mask) == opcode->bin_opcode 1047 && opcode->bin_opcode != 0x9300) 1048 { 1049 *op1 = 0; 1050 *op2 = 0; 1051 *comm1 = 0; 1052 *comm2 = 0; 1053 1054 /* r0 as destination. Ad should be zero. */ 1055 if (opcode->insn_opnumb == 3 1056 && (insn & 0x000f) == 0 1057 && (insn & 0x0080) == 0) 1058 { 1059 int ret = 1060 msp430_branchinstr (info, opcode, addr, insn, op1, comm1, 1061 &cycles); 1062 1063 if (ret == -1) 1064 return -1; 1065 cmd_len += ret; 1066 if (cmd_len) 1067 break; 1068 } 1069 1070 switch (opcode->insn_opnumb) 1071 { 1072 int n; 1073 int reg; 1074 int ret; 1075 1076 case 4: 1077 ret = msp430x_calla_instr (info, addr, insn, 1078 op1, comm1, & cycles); 1079 if (ret == -1) 1080 return -1; 1081 cmd_len += ret; 1082 break; 1083 1084 case 5: /* PUSHM/POPM */ 1085 n = (insn & 0xf0) >> 4; 1086 reg = (insn & 0xf); 1087 1088 sprintf (op1, "#%d", n + 1); 1089 if (opcode->bin_opcode == 0x1400) 1090 /* PUSHM */ 1091 sprintf (op2, "r%d", reg); 1092 else 1093 /* POPM */ 1094 sprintf (op2, "r%d", reg + n); 1095 if (insn & 0x100) 1096 sprintf (comm1, "16-bit words"); 1097 else 1098 { 1099 sprintf (comm1, "20-bit words"); 1100 bc =".a"; 1101 } 1102 1103 cycles = 2; /*FIXME*/ 1104 cmd_len = 2; 1105 break; 1106 1107 case 6: /* RRAM, RRCM, RRUM, RLAM. */ 1108 n = ((insn >> 10) & 0x3) + 1; 1109 reg = (insn & 0xf); 1110 if ((insn & 0x10) == 0) 1111 bc =".a"; 1112 sprintf (op1, "#%d", n); 1113 sprintf (op2, "r%d", reg); 1114 cycles = 2; /*FIXME*/ 1115 cmd_len = 2; 1116 break; 1117 1118 case 8: /* ADDA, CMPA, SUBA. */ 1119 reg = (insn & 0xf); 1120 n = (insn >> 8) & 0xf; 1121 if (insn & 0x40) 1122 { 1123 sprintf (op1, "r%d", n); 1124 cmd_len = 2; 1125 } 1126 else 1127 { 1128 n <<= 16; 1129 if (msp430dis_opcode_unsigned (addr + 2, info, &bits, comm1)) 1130 { 1131 n |= bits; 1132 sprintf (op1, "#%d", n); 1133 if (n > 9 || n < 0) 1134 sprintf (comm1, "0x%05x", n); 1135 } 1136 else 1137 return -1; 1138 cmd_len = 4; 1139 } 1140 sprintf (op2, "r%d", reg); 1141 cycles = 2; /*FIXME*/ 1142 break; 1143 1144 case 9: /* MOVA */ 1145 reg = (insn & 0xf); 1146 n = (insn >> 8) & 0xf; 1147 switch ((insn >> 4) & 0xf) 1148 { 1149 case 0: /* MOVA @Rsrc, Rdst */ 1150 cmd_len = 2; 1151 sprintf (op1, "@r%d", n); 1152 if (strcmp (opcode->name, "bra") != 0) 1153 sprintf (op2, "r%d", reg); 1154 break; 1155 1156 case 1: /* MOVA @Rsrc+, Rdst */ 1157 cmd_len = 2; 1158 if (strcmp (opcode->name, "reta") != 0) 1159 { 1160 sprintf (op1, "@r%d+", n); 1161 if (strcmp (opcode->name, "bra") != 0) 1162 sprintf (op2, "r%d", reg); 1163 } 1164 break; 1165 1166 case 2: /* MOVA &abs20, Rdst */ 1167 cmd_len = 4; 1168 n <<= 16; 1169 if (msp430dis_opcode_unsigned (addr + 2, info, &bits, comm1)) 1170 { 1171 n |= bits; 1172 sprintf (op1, "&%d", n); 1173 if (n > 9 || n < 0) 1174 sprintf (comm1, "0x%05x", n); 1175 if (strcmp (opcode->name, "bra") != 0) 1176 sprintf (op2, "r%d", reg); 1177 } 1178 else 1179 return -1; 1180 break; 1181 1182 case 3: /* MOVA x(Rsrc), Rdst */ 1183 cmd_len = 4; 1184 if (strcmp (opcode->name, "bra") != 0) 1185 sprintf (op2, "r%d", reg); 1186 reg = n; 1187 if (msp430dis_opcode_signed (addr + 2, info, &n, comm1)) 1188 { 1189 sprintf (op1, "%d(r%d)", n, reg); 1190 if (n > 9 || n < 0) 1191 { 1192 if (reg == 0) 1193 sprintf (comm1, "PC rel. 0x%05lx", 1194 (long) (addr + 2 + n)); 1195 else 1196 sprintf (comm1, "0x%05x", n); 1197 } 1198 } 1199 else 1200 return -1; 1201 break; 1202 1203 case 6: /* MOVA Rsrc, &abs20 */ 1204 cmd_len = 4; 1205 reg <<= 16; 1206 if (msp430dis_opcode_unsigned (addr + 2, info, &bits, comm2)) 1207 { 1208 reg |= bits; 1209 sprintf (op1, "r%d", n); 1210 sprintf (op2, "&%d", reg); 1211 if (reg > 9 || reg < 0) 1212 sprintf (comm2, "0x%05x", reg); 1213 } 1214 else 1215 return -1; 1216 break; 1217 1218 case 7: /* MOVA Rsrc, x(Rdst) */ 1219 cmd_len = 4; 1220 sprintf (op1, "r%d", n); 1221 if (msp430dis_opcode_signed (addr + 2, info, &n, comm2)) 1222 { 1223 sprintf (op2, "%d(r%d)", n, reg); 1224 if (n > 9 || n < 0) 1225 { 1226 if (reg == 0) 1227 sprintf (comm2, "PC rel. 0x%05lx", 1228 (long) (addr + 2 + n)); 1229 else 1230 sprintf (comm2, "0x%05x", n); 1231 } 1232 } 1233 else 1234 return -1; 1235 break; 1236 1237 case 8: /* MOVA #imm20, Rdst */ 1238 cmd_len = 4; 1239 n <<= 16; 1240 if (msp430dis_opcode_unsigned (addr + 2, info, &bits, comm1)) 1241 { 1242 n |= bits; 1243 if (n & 0x80000) 1244 n |= -1U << 20; 1245 sprintf (op1, "#%d", n); 1246 if (n > 9 || n < 0) 1247 sprintf (comm1, "0x%05x", n); 1248 if (strcmp (opcode->name, "bra") != 0) 1249 sprintf (op2, "r%d", reg); 1250 } 1251 else 1252 return -1; 1253 break; 1254 1255 case 12: /* MOVA Rsrc, Rdst */ 1256 cmd_len = 2; 1257 sprintf (op1, "r%d", n); 1258 if (strcmp (opcode->name, "bra") != 0) 1259 sprintf (op2, "r%d", reg); 1260 break; 1261 1262 default: 1263 break; 1264 } 1265 cycles = 2; /* FIXME */ 1266 break; 1267 } 1268 1269 if (cmd_len) 1270 break; 1271 1272 switch (opcode->insn_opnumb) 1273 { 1274 int ret; 1275 1276 case 0: 1277 cmd_len += msp430_nooperands (opcode, addr, insn, comm1, &cycles); 1278 break; 1279 case 2: 1280 ret = 1281 msp430_doubleoperand (info, opcode, addr, insn, op1, op2, 1282 comm1, comm2, 1283 extension_word, 1284 &cycles); 1285 1286 if (ret == -1) 1287 return -1; 1288 cmd_len += ret; 1289 if (insn & BYTE_OPERATION) 1290 { 1291 if (extension_word != 0 && ((extension_word & BYTE_OPERATION) == 0)) 1292 bc = ".a"; 1293 else 1294 bc = ".b"; 1295 } 1296 else if (extension_word) 1297 { 1298 if (extension_word & BYTE_OPERATION) 1299 bc = ".w"; 1300 else 1301 { 1302 bc = ".?"; 1303 sprintf (comm2, _("Warning: reserved use of A/L and B/W bits detected")); 1304 } 1305 } 1306 1307 break; 1308 case 1: 1309 ret = 1310 msp430_singleoperand (info, opcode, addr, insn, op1, comm1, 1311 extension_word, 1312 &cycles); 1313 1314 if (ret == -1) 1315 return -1; 1316 cmd_len += ret; 1317 if (extension_word 1318 && (strcmp (opcode->name, "swpb") == 0 1319 || strcmp (opcode->name, "sxt") == 0)) 1320 { 1321 if (insn & BYTE_OPERATION) 1322 { 1323 bc = ".?"; 1324 sprintf (comm2, _("Warning: reserved use of A/L and B/W bits detected")); 1325 } 1326 else if (extension_word & BYTE_OPERATION) 1327 bc = ".w"; 1328 else 1329 bc = ".a"; 1330 } 1331 else if (insn & BYTE_OPERATION && opcode->fmt != 3) 1332 { 1333 if (extension_word != 0 && ((extension_word & BYTE_OPERATION) == 0)) 1334 bc = ".a"; 1335 else 1336 bc = ".b"; 1337 } 1338 else if (extension_word) 1339 { 1340 if (extension_word & (1 << 6)) 1341 bc = ".w"; 1342 else 1343 { 1344 bc = ".?"; 1345 sprintf (comm2, _("Warning: reserved use of A/L and B/W bits detected")); 1346 } 1347 } 1348 break; 1349 default: 1350 break; 1351 } 1352 } 1353 1354 if (cmd_len) 1355 break; 1356 } 1357 1358 if (cmd_len < 1) 1359 { 1360 /* Unknown opcode, or invalid combination of operands. */ 1361 if (extension_word) 1362 { 1363 prin (stream, ".word 0x%04x, 0x%04x; ????", extension_word, PS (insn)); 1364 if (*comm1) 1365 prin (stream, "\t %s", comm1); 1366 return 4; 1367 } 1368 (*prin) (stream, ".word 0x%04x; ????", PS (insn)); 1369 return 2; 1370 } 1371 1372 /* Display the repeat count (if set) for extended register mode. */ 1373 if (cmd_len == 2 && ((extension_word & 0xf) != 0)) 1374 { 1375 if (extension_word & (1 << 7)) 1376 prin (stream, "rpt r%d { ", extension_word & 0xf); 1377 else 1378 prin (stream, "rpt #%d { ", (extension_word & 0xf) + 1); 1379 } 1380 1381 /* Special case: RRC with an extension word and the ZC bit set is actually RRU. */ 1382 if (extension_word 1383 && (extension_word & IGNORE_CARRY_BIT) 1384 && strcmp (opcode->name, "rrc") == 0) 1385 (*prin) (stream, "rrux%s", bc); 1386 else if (extension_word && opcode->name[strlen (opcode->name) - 1] != 'x') 1387 (*prin) (stream, "%sx%s", opcode->name, bc); 1388 else 1389 (*prin) (stream, "%s%s", opcode->name, bc); 1390 1391 if (*op1) 1392 (*prin) (stream, "\t%s", op1); 1393 if (*op2) 1394 (*prin) (stream, ","); 1395 1396 if (strlen (op1) < 7) 1397 (*prin) (stream, "\t"); 1398 if (!strlen (op1)) 1399 (*prin) (stream, "\t"); 1400 1401 if (*op2) 1402 (*prin) (stream, "%s", op2); 1403 if (strlen (op2) < 8) 1404 (*prin) (stream, "\t"); 1405 1406 if (*comm1 || *comm2) 1407 (*prin) (stream, ";"); 1408 else if (cycles) 1409 { 1410 if (*op2) 1411 (*prin) (stream, ";"); 1412 else 1413 { 1414 if (strlen (op1) < 7) 1415 (*prin) (stream, ";"); 1416 else 1417 (*prin) (stream, "\t;"); 1418 } 1419 } 1420 if (*comm1) 1421 (*prin) (stream, "%s", comm1); 1422 if (*comm1 && *comm2) 1423 (*prin) (stream, ","); 1424 if (*comm2) 1425 (*prin) (stream, " %s", comm2); 1426 1427 if (extension_word) 1428 cmd_len += 2; 1429 1430 return cmd_len; 1431 } 1432