1 /* Print Motorola 68k instructions. 2 Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 98, 1999 3 Free Software Foundation, Inc. 4 5 This file 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 2 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 18 19 #include "sysdep.h" 20 #include "dis-asm.h" 21 #include "floatformat.h" 22 #include <libiberty.h> 23 #include "opintl.h" 24 25 #include "opcode/m68k.h" 26 27 /* Local function prototypes */ 28 29 static int 30 fetch_data PARAMS ((struct disassemble_info *, bfd_byte *)); 31 32 static void 33 dummy_print_address PARAMS ((bfd_vma, struct disassemble_info *)); 34 35 static int 36 fetch_arg PARAMS ((unsigned char *, int, int, disassemble_info *)); 37 38 static void 39 print_base PARAMS ((int, bfd_vma, disassemble_info*)); 40 41 static unsigned char * 42 print_indexed PARAMS ((int, unsigned char *, bfd_vma, disassemble_info *)); 43 44 static int 45 print_insn_arg PARAMS ((const char *, unsigned char *, unsigned char *, 46 bfd_vma, disassemble_info *)); 47 48 CONST char * CONST fpcr_names[] = { 49 "", "%fpiar", "%fpsr", "%fpiar/%fpsr", "%fpcr", 50 "%fpiar/%fpcr", "%fpsr/%fpcr", "%fpiar/%fpsr/%fpcr"}; 51 52 static char *const reg_names[] = { 53 "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7", 54 "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%fp", "%sp", 55 "%ps", "%pc"}; 56 57 /* Sign-extend an (unsigned char). */ 58 #if __STDC__ == 1 59 #define COERCE_SIGNED_CHAR(ch) ((signed char)(ch)) 60 #else 61 #define COERCE_SIGNED_CHAR(ch) ((int)(((ch) ^ 0x80) & 0xFF) - 128) 62 #endif 63 64 /* Get a 1 byte signed integer. */ 65 #define NEXTBYTE(p) (p += 2, FETCH_DATA (info, p), COERCE_SIGNED_CHAR(p[-1])) 66 67 /* Get a 2 byte signed integer. */ 68 #define COERCE16(x) ((int) (((x) ^ 0x8000) - 0x8000)) 69 #define NEXTWORD(p) \ 70 (p += 2, FETCH_DATA (info, p), \ 71 COERCE16 ((p[-2] << 8) + p[-1])) 72 73 /* Get a 4 byte signed integer. */ 74 #define COERCE32(x) ((bfd_signed_vma) ((x) ^ 0x80000000) - 0x80000000) 75 #define NEXTLONG(p) \ 76 (p += 4, FETCH_DATA (info, p), \ 77 (COERCE32 ((((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1]))) 78 79 /* Get a 4 byte unsigned integer. */ 80 #define NEXTULONG(p) \ 81 (p += 4, FETCH_DATA (info, p), \ 82 (unsigned int) ((((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])) 83 84 /* Get a single precision float. */ 85 #define NEXTSINGLE(val, p) \ 86 (p += 4, FETCH_DATA (info, p), \ 87 floatformat_to_double (&floatformat_ieee_single_big, (char *) p - 4, &val)) 88 89 /* Get a double precision float. */ 90 #define NEXTDOUBLE(val, p) \ 91 (p += 8, FETCH_DATA (info, p), \ 92 floatformat_to_double (&floatformat_ieee_double_big, (char *) p - 8, &val)) 93 94 /* Get an extended precision float. */ 95 #define NEXTEXTEND(val, p) \ 96 (p += 12, FETCH_DATA (info, p), \ 97 floatformat_to_double (&floatformat_m68881_ext, (char *) p - 12, &val)) 98 99 /* Need a function to convert from packed to double 100 precision. Actually, it's easier to print a 101 packed number than a double anyway, so maybe 102 there should be a special case to handle this... */ 103 #define NEXTPACKED(p) \ 104 (p += 12, FETCH_DATA (info, p), 0.0) 105 106 107 /* Maximum length of an instruction. */ 108 #define MAXLEN 22 109 110 #include <setjmp.h> 111 112 struct private 113 { 114 /* Points to first byte not fetched. */ 115 bfd_byte *max_fetched; 116 bfd_byte the_buffer[MAXLEN]; 117 bfd_vma insn_start; 118 jmp_buf bailout; 119 }; 120 121 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive) 122 to ADDR (exclusive) are valid. Returns 1 for success, longjmps 123 on error. */ 124 #define FETCH_DATA(info, addr) \ 125 ((addr) <= ((struct private *)(info->private_data))->max_fetched \ 126 ? 1 : fetch_data ((info), (addr))) 127 128 static int 129 fetch_data (info, addr) 130 struct disassemble_info *info; 131 bfd_byte *addr; 132 { 133 int status; 134 struct private *priv = (struct private *)info->private_data; 135 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); 136 137 status = (*info->read_memory_func) (start, 138 priv->max_fetched, 139 addr - priv->max_fetched, 140 info); 141 if (status != 0) 142 { 143 (*info->memory_error_func) (status, start, info); 144 longjmp (priv->bailout, 1); 145 } 146 else 147 priv->max_fetched = addr; 148 return 1; 149 } 150 151 /* This function is used to print to the bit-bucket. */ 152 static int 153 #ifdef __STDC__ 154 dummy_printer (FILE * file, const char * format, ...) 155 #else 156 dummy_printer (file) FILE *file; 157 #endif 158 { return 0; } 159 160 static void 161 dummy_print_address (vma, info) 162 bfd_vma vma; 163 struct disassemble_info *info; 164 { 165 } 166 167 /* Print the m68k instruction at address MEMADDR in debugged memory, 168 on INFO->STREAM. Returns length of the instruction, in bytes. */ 169 170 int 171 print_insn_m68k (memaddr, info) 172 bfd_vma memaddr; 173 disassemble_info *info; 174 { 175 register int i; 176 register unsigned char *p; 177 unsigned char *save_p; 178 register const char *d; 179 register unsigned long bestmask; 180 const struct m68k_opcode *best = 0; 181 unsigned int arch_mask; 182 struct private priv; 183 bfd_byte *buffer = priv.the_buffer; 184 fprintf_ftype save_printer = info->fprintf_func; 185 void (*save_print_address) PARAMS((bfd_vma, struct disassemble_info*)) 186 = info->print_address_func; 187 int major_opcode; 188 static int numopcodes[16]; 189 static const struct m68k_opcode **opcodes[16]; 190 191 if (!opcodes[0]) 192 { 193 /* Speed up the matching by sorting the opcode table on the upper 194 four bits of the opcode. */ 195 const struct m68k_opcode **opc_pointer[16]; 196 197 /* First count how many opcodes are in each of the sixteen buckets. */ 198 for (i = 0; i < m68k_numopcodes; i++) 199 numopcodes[(m68k_opcodes[i].opcode >> 28) & 15]++; 200 201 /* Then create a sorted table of pointers that point into the 202 unsorted table. */ 203 opc_pointer[0] = ((const struct m68k_opcode **) 204 xmalloc (sizeof (struct m68k_opcode *) 205 * m68k_numopcodes)); 206 opcodes[0] = opc_pointer[0]; 207 for (i = 1; i < 16; i++) 208 { 209 opc_pointer[i] = opc_pointer[i - 1] + numopcodes[i - 1]; 210 opcodes[i] = opc_pointer[i]; 211 } 212 213 for (i = 0; i < m68k_numopcodes; i++) 214 *opc_pointer[(m68k_opcodes[i].opcode >> 28) & 15]++ = &m68k_opcodes[i]; 215 216 } 217 218 info->private_data = (PTR) &priv; 219 /* Tell objdump to use two bytes per chunk and six bytes per line for 220 displaying raw data. */ 221 info->bytes_per_chunk = 2; 222 info->bytes_per_line = 6; 223 info->display_endian = BFD_ENDIAN_BIG; 224 priv.max_fetched = priv.the_buffer; 225 priv.insn_start = memaddr; 226 if (setjmp (priv.bailout) != 0) 227 /* Error return. */ 228 return -1; 229 230 switch (info->mach) 231 { 232 default: 233 case 0: 234 arch_mask = (unsigned int) -1; 235 break; 236 case bfd_mach_m68000: 237 arch_mask = m68000; 238 break; 239 case bfd_mach_m68008: 240 arch_mask = m68008; 241 break; 242 case bfd_mach_m68010: 243 arch_mask = m68010; 244 break; 245 case bfd_mach_m68020: 246 arch_mask = m68020; 247 break; 248 case bfd_mach_m68030: 249 arch_mask = m68030; 250 break; 251 case bfd_mach_m68040: 252 arch_mask = m68040; 253 break; 254 case bfd_mach_m68060: 255 arch_mask = m68060; 256 break; 257 } 258 259 arch_mask |= m68881 | m68851; 260 261 bestmask = 0; 262 FETCH_DATA (info, buffer + 2); 263 major_opcode = (buffer[0] >> 4) & 15; 264 for (i = 0; i < numopcodes[major_opcode]; i++) 265 { 266 const struct m68k_opcode *opc = opcodes[major_opcode][i]; 267 unsigned long opcode = opc->opcode; 268 unsigned long match = opc->match; 269 270 if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24))) 271 && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16))) 272 /* Only fetch the next two bytes if we need to. */ 273 && (((0xffff & match) == 0) 274 || 275 (FETCH_DATA (info, buffer + 4) 276 && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8))) 277 && ((0xff & buffer[3] & match) == (0xff & opcode))) 278 ) 279 && (opc->arch & arch_mask) != 0) 280 { 281 /* Don't use for printout the variants of divul and divsl 282 that have the same register number in two places. 283 The more general variants will match instead. */ 284 for (d = opc->args; *d; d += 2) 285 if (d[1] == 'D') 286 break; 287 288 /* Don't use for printout the variants of most floating 289 point coprocessor instructions which use the same 290 register number in two places, as above. */ 291 if (*d == '\0') 292 for (d = opc->args; *d; d += 2) 293 if (d[1] == 't') 294 break; 295 296 /* Don't match fmovel with more than one register; wait for 297 fmoveml. */ 298 if (*d == '\0') 299 { 300 for (d = opc->args; *d; d += 2) 301 { 302 if (d[0] == 's' && d[1] == '8') 303 { 304 int val; 305 306 val = fetch_arg (buffer, d[1], 3, info); 307 if ((val & (val - 1)) != 0) 308 break; 309 } 310 } 311 } 312 313 if (*d == '\0' && match > bestmask) 314 { 315 best = opc; 316 bestmask = match; 317 } 318 } 319 } 320 321 if (best == 0) 322 goto invalid; 323 324 /* Point at first word of argument data, 325 and at descriptor for first argument. */ 326 p = buffer + 2; 327 328 /* Figure out how long the fixed-size portion of the instruction is. 329 The only place this is stored in the opcode table is 330 in the arguments--look for arguments which specify fields in the 2nd 331 or 3rd words of the instruction. */ 332 for (d = best->args; *d; d += 2) 333 { 334 /* I don't think it is necessary to be checking d[0] here; I suspect 335 all this could be moved to the case statement below. */ 336 if (d[0] == '#') 337 { 338 if (d[1] == 'l' && p - buffer < 6) 339 p = buffer + 6; 340 else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' ) 341 p = buffer + 4; 342 } 343 if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4) 344 p = buffer + 4; 345 switch (d[1]) 346 { 347 case '1': 348 case '2': 349 case '3': 350 case '7': 351 case '8': 352 case '9': 353 case 'i': 354 if (p - buffer < 4) 355 p = buffer + 4; 356 break; 357 case '4': 358 case '5': 359 case '6': 360 if (p - buffer < 6) 361 p = buffer + 6; 362 break; 363 default: 364 break; 365 } 366 } 367 368 /* pflusha is an exceptions. It takes no arguments but is two words 369 long. Recognize it by looking at the lower 16 bits of the mask. */ 370 if (p - buffer < 4 && (best->match & 0xFFFF) != 0) 371 p = buffer + 4; 372 373 /* lpstop is another exception. It takes a one word argument but is 374 three words long. */ 375 if (p - buffer < 6 376 && (best->match & 0xffff) == 0xffff 377 && best->args[0] == '#' 378 && best->args[1] == 'w') 379 { 380 /* Copy the one word argument into the usual location for a one 381 word argument, to simplify printing it. We can get away with 382 this because we know exactly what the second word is, and we 383 aren't going to print anything based on it. */ 384 p = buffer + 6; 385 FETCH_DATA (info, p); 386 buffer[2] = buffer[4]; 387 buffer[3] = buffer[5]; 388 } 389 390 FETCH_DATA (info, p); 391 392 d = best->args; 393 394 /* We can the operands twice. The first time we don't print anything, 395 but look for errors. */ 396 397 save_p = p; 398 info->print_address_func = dummy_print_address; 399 info->fprintf_func = (fprintf_ftype)dummy_printer; 400 for ( ; *d; d += 2) 401 { 402 int eaten = print_insn_arg (d, buffer, p, memaddr + (p - buffer), info); 403 if (eaten >= 0) 404 p += eaten; 405 else if (eaten == -1) 406 goto invalid; 407 else 408 { 409 (*info->fprintf_func)(info->stream, 410 /* xgettext:c-format */ 411 _("<internal error in opcode table: %s %s>\n"), 412 best->name, 413 best->args); 414 goto invalid; 415 } 416 417 } 418 p = save_p; 419 info->fprintf_func = save_printer; 420 info->print_address_func = save_print_address; 421 422 d = best->args; 423 424 (*info->fprintf_func) (info->stream, "%s", best->name); 425 426 if (*d) 427 (*info->fprintf_func) (info->stream, " "); 428 429 while (*d) 430 { 431 p += print_insn_arg (d, buffer, p, memaddr + (p - buffer), info); 432 d += 2; 433 if (*d && *(d - 2) != 'I' && *d != 'k') 434 (*info->fprintf_func) (info->stream, ","); 435 } 436 return p - buffer; 437 438 invalid: 439 /* Handle undefined instructions. */ 440 info->fprintf_func = save_printer; 441 info->print_address_func = save_print_address; 442 (*info->fprintf_func) (info->stream, "0%o", 443 (buffer[0] << 8) + buffer[1]); 444 return 2; 445 } 446 447 /* Returns number of bytes "eaten" by the operand, or 448 return -1 if an invalid operand was found, or -2 if 449 an opcode tabe error was found. */ 450 451 static int 452 print_insn_arg (d, buffer, p0, addr, info) 453 const char *d; 454 unsigned char *buffer; 455 unsigned char *p0; 456 bfd_vma addr; /* PC for this arg to be relative to */ 457 disassemble_info *info; 458 { 459 register int val = 0; 460 register int place = d[1]; 461 register unsigned char *p = p0; 462 int regno; 463 register CONST char *regname; 464 register unsigned char *p1; 465 double flval; 466 int flt_p; 467 bfd_signed_vma disp; 468 unsigned int uval; 469 470 switch (*d) 471 { 472 case 'c': /* cache identifier */ 473 { 474 static char *const cacheFieldName[] = { "nc", "dc", "ic", "bc" }; 475 val = fetch_arg (buffer, place, 2, info); 476 (*info->fprintf_func) (info->stream, cacheFieldName[val]); 477 break; 478 } 479 480 case 'a': /* address register indirect only. Cf. case '+'. */ 481 { 482 (*info->fprintf_func) 483 (info->stream, 484 "%s@", 485 reg_names [fetch_arg (buffer, place, 3, info) + 8]); 486 break; 487 } 488 489 case '_': /* 32-bit absolute address for move16. */ 490 { 491 uval = NEXTULONG (p); 492 (*info->print_address_func) (uval, info); 493 break; 494 } 495 496 case 'C': 497 (*info->fprintf_func) (info->stream, "%%ccr"); 498 break; 499 500 case 'S': 501 (*info->fprintf_func) (info->stream, "%%sr"); 502 break; 503 504 case 'U': 505 (*info->fprintf_func) (info->stream, "%%usp"); 506 break; 507 508 case 'E': 509 (*info->fprintf_func) (info->stream, "%%acc"); 510 break; 511 512 case 'G': 513 (*info->fprintf_func) (info->stream, "%%macsr"); 514 break; 515 516 case 'H': 517 (*info->fprintf_func) (info->stream, "%%mask"); 518 break; 519 520 case 'J': 521 { 522 static const struct { char *name; int value; } names[] 523 = {{"%sfc", 0x000}, {"%dfc", 0x001}, {"%cacr", 0x002}, 524 {"%tc", 0x003}, {"%itt0",0x004}, {"%itt1", 0x005}, 525 {"%dtt0",0x006}, {"%dtt1",0x007}, {"%buscr",0x008}, 526 {"%usp", 0x800}, {"%vbr", 0x801}, {"%caar", 0x802}, 527 {"%msp", 0x803}, {"%isp", 0x804}, 528 529 /* Should we be calling this psr like we do in case 'Y'? */ 530 {"%mmusr",0x805}, 531 532 {"%urp", 0x806}, {"%srp", 0x807}, {"%pcr", 0x808}}; 533 534 val = fetch_arg (buffer, place, 12, info); 535 for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--) 536 if (names[regno].value == val) 537 { 538 (*info->fprintf_func) (info->stream, "%s", names[regno].name); 539 break; 540 } 541 if (regno < 0) 542 (*info->fprintf_func) (info->stream, "%d", val); 543 } 544 break; 545 546 case 'Q': 547 val = fetch_arg (buffer, place, 3, info); 548 /* 0 means 8, except for the bkpt instruction... */ 549 if (val == 0 && d[1] != 's') 550 val = 8; 551 (*info->fprintf_func) (info->stream, "#%d", val); 552 break; 553 554 case 'M': 555 if (place == 'h') 556 { 557 static char *const scalefactor_name[] = { "<<", ">>" }; 558 val = fetch_arg (buffer, place, 1, info); 559 (*info->fprintf_func) (info->stream, scalefactor_name[val]); 560 } 561 else 562 { 563 val = fetch_arg (buffer, place, 8, info); 564 if (val & 0x80) 565 val = val - 0x100; 566 (*info->fprintf_func) (info->stream, "#%d", val); 567 } 568 break; 569 570 case 'T': 571 val = fetch_arg (buffer, place, 4, info); 572 (*info->fprintf_func) (info->stream, "#%d", val); 573 break; 574 575 case 'D': 576 (*info->fprintf_func) (info->stream, "%s", 577 reg_names[fetch_arg (buffer, place, 3, info)]); 578 break; 579 580 case 'A': 581 (*info->fprintf_func) 582 (info->stream, "%s", 583 reg_names[fetch_arg (buffer, place, 3, info) + 010]); 584 break; 585 586 case 'R': 587 (*info->fprintf_func) 588 (info->stream, "%s", 589 reg_names[fetch_arg (buffer, place, 4, info)]); 590 break; 591 592 case 'r': 593 regno = fetch_arg (buffer, place, 4, info); 594 if (regno > 7) 595 (*info->fprintf_func) (info->stream, "%s@", reg_names[regno]); 596 else 597 (*info->fprintf_func) (info->stream, "@(%s)", reg_names[regno]); 598 break; 599 600 case 'F': 601 (*info->fprintf_func) 602 (info->stream, "%%fp%d", 603 fetch_arg (buffer, place, 3, info)); 604 break; 605 606 case 'O': 607 val = fetch_arg (buffer, place, 6, info); 608 if (val & 0x20) 609 (*info->fprintf_func) (info->stream, "%s", reg_names [val & 7]); 610 else 611 (*info->fprintf_func) (info->stream, "%d", val); 612 break; 613 614 case '+': 615 (*info->fprintf_func) 616 (info->stream, "%s@+", 617 reg_names[fetch_arg (buffer, place, 3, info) + 8]); 618 break; 619 620 case '-': 621 (*info->fprintf_func) 622 (info->stream, "%s@-", 623 reg_names[fetch_arg (buffer, place, 3, info) + 8]); 624 break; 625 626 case 'k': 627 if (place == 'k') 628 (*info->fprintf_func) 629 (info->stream, "{%s}", 630 reg_names[fetch_arg (buffer, place, 3, info)]); 631 else if (place == 'C') 632 { 633 val = fetch_arg (buffer, place, 7, info); 634 if ( val > 63 ) /* This is a signed constant. */ 635 val -= 128; 636 (*info->fprintf_func) (info->stream, "{#%d}", val); 637 } 638 else 639 return -2; 640 break; 641 642 case '#': 643 case '^': 644 p1 = buffer + (*d == '#' ? 2 : 4); 645 if (place == 's') 646 val = fetch_arg (buffer, place, 4, info); 647 else if (place == 'C') 648 val = fetch_arg (buffer, place, 7, info); 649 else if (place == '8') 650 val = fetch_arg (buffer, place, 3, info); 651 else if (place == '3') 652 val = fetch_arg (buffer, place, 8, info); 653 else if (place == 'b') 654 val = NEXTBYTE (p1); 655 else if (place == 'w' || place == 'W') 656 val = NEXTWORD (p1); 657 else if (place == 'l') 658 val = NEXTLONG (p1); 659 else 660 return -2; 661 (*info->fprintf_func) (info->stream, "#%d", val); 662 break; 663 664 case 'B': 665 if (place == 'b') 666 disp = NEXTBYTE (p); 667 else if (place == 'B') 668 disp = COERCE_SIGNED_CHAR(buffer[1]); 669 else if (place == 'w' || place == 'W') 670 disp = NEXTWORD (p); 671 else if (place == 'l' || place == 'L' || place == 'C') 672 disp = NEXTLONG (p); 673 else if (place == 'g') 674 { 675 disp = NEXTBYTE (buffer); 676 if (disp == 0) 677 disp = NEXTWORD (p); 678 else if (disp == -1) 679 disp = NEXTLONG (p); 680 } 681 else if (place == 'c') 682 { 683 if (buffer[1] & 0x40) /* If bit six is one, long offset */ 684 disp = NEXTLONG (p); 685 else 686 disp = NEXTWORD (p); 687 } 688 else 689 return -2; 690 691 (*info->print_address_func) (addr + disp, info); 692 break; 693 694 case 'd': 695 val = NEXTWORD (p); 696 (*info->fprintf_func) 697 (info->stream, "%s@(%d)", 698 reg_names[fetch_arg (buffer, place, 3, info) + 8], val); 699 break; 700 701 case 's': 702 (*info->fprintf_func) (info->stream, "%s", 703 fpcr_names[fetch_arg (buffer, place, 3, info)]); 704 break; 705 706 case 'I': 707 /* Get coprocessor ID... */ 708 val = fetch_arg (buffer, 'd', 3, info); 709 710 if (val != 1) /* Unusual coprocessor ID? */ 711 (*info->fprintf_func) (info->stream, "(cpid=%d) ", val); 712 break; 713 714 case '*': 715 case '~': 716 case '%': 717 case ';': 718 case '@': 719 case '!': 720 case '$': 721 case '?': 722 case '/': 723 case '&': 724 case '|': 725 case '<': 726 case '>': 727 case 'm': 728 case 'n': 729 case 'o': 730 case 'p': 731 case 'q': 732 case 'v': 733 734 if (place == 'd') 735 { 736 val = fetch_arg (buffer, 'x', 6, info); 737 val = ((val & 7) << 3) + ((val >> 3) & 7); 738 } 739 else 740 val = fetch_arg (buffer, 's', 6, info); 741 742 /* Get register number assuming address register. */ 743 regno = (val & 7) + 8; 744 regname = reg_names[regno]; 745 switch (val >> 3) 746 { 747 case 0: 748 (*info->fprintf_func) (info->stream, "%s", reg_names[val]); 749 break; 750 751 case 1: 752 (*info->fprintf_func) (info->stream, "%s", regname); 753 break; 754 755 case 2: 756 (*info->fprintf_func) (info->stream, "%s@", regname); 757 break; 758 759 case 3: 760 (*info->fprintf_func) (info->stream, "%s@+", regname); 761 break; 762 763 case 4: 764 (*info->fprintf_func) (info->stream, "%s@-", regname); 765 break; 766 767 case 5: 768 val = NEXTWORD (p); 769 (*info->fprintf_func) (info->stream, "%s@(%d)", regname, val); 770 break; 771 772 case 6: 773 p = print_indexed (regno, p, addr, info); 774 break; 775 776 case 7: 777 switch (val & 7) 778 { 779 case 0: 780 val = NEXTWORD (p); 781 (*info->print_address_func) (val, info); 782 break; 783 784 case 1: 785 uval = NEXTULONG (p); 786 (*info->print_address_func) (uval, info); 787 break; 788 789 case 2: 790 val = NEXTWORD (p); 791 (*info->fprintf_func) (info->stream, "%%pc@("); 792 (*info->print_address_func) (addr + val, info); 793 (*info->fprintf_func) (info->stream, ")"); 794 break; 795 796 case 3: 797 p = print_indexed (-1, p, addr, info); 798 break; 799 800 case 4: 801 flt_p = 1; /* Assume it's a float... */ 802 switch( place ) 803 { 804 case 'b': 805 val = NEXTBYTE (p); 806 flt_p = 0; 807 break; 808 809 case 'w': 810 val = NEXTWORD (p); 811 flt_p = 0; 812 break; 813 814 case 'l': 815 val = NEXTLONG (p); 816 flt_p = 0; 817 break; 818 819 case 'f': 820 NEXTSINGLE(flval, p); 821 break; 822 823 case 'F': 824 NEXTDOUBLE(flval, p); 825 break; 826 827 case 'x': 828 NEXTEXTEND(flval, p); 829 break; 830 831 case 'p': 832 flval = NEXTPACKED(p); 833 break; 834 835 default: 836 return -1; 837 } 838 if ( flt_p ) /* Print a float? */ 839 (*info->fprintf_func) (info->stream, "#%g", flval); 840 else 841 (*info->fprintf_func) (info->stream, "#%d", val); 842 break; 843 844 default: 845 return -1; 846 } 847 } 848 break; 849 850 case 'L': 851 case 'l': 852 if (place == 'w') 853 { 854 char doneany; 855 p1 = buffer + 2; 856 val = NEXTWORD (p1); 857 /* Move the pointer ahead if this point is farther ahead 858 than the last. */ 859 p = p1 > p ? p1 : p; 860 if (val == 0) 861 { 862 (*info->fprintf_func) (info->stream, "#0"); 863 break; 864 } 865 if (*d == 'l') 866 { 867 register int newval = 0; 868 for (regno = 0; regno < 16; ++regno) 869 if (val & (0x8000 >> regno)) 870 newval |= 1 << regno; 871 val = newval; 872 } 873 val &= 0xffff; 874 doneany = 0; 875 for (regno = 0; regno < 16; ++regno) 876 if (val & (1 << regno)) 877 { 878 int first_regno; 879 if (doneany) 880 (*info->fprintf_func) (info->stream, "/"); 881 doneany = 1; 882 (*info->fprintf_func) (info->stream, "%s", reg_names[regno]); 883 first_regno = regno; 884 while (val & (1 << (regno + 1))) 885 ++regno; 886 if (regno > first_regno) 887 (*info->fprintf_func) (info->stream, "-%s", 888 reg_names[regno]); 889 } 890 } 891 else if (place == '3') 892 { 893 /* `fmovem' insn. */ 894 char doneany; 895 val = fetch_arg (buffer, place, 8, info); 896 if (val == 0) 897 { 898 (*info->fprintf_func) (info->stream, "#0"); 899 break; 900 } 901 if (*d == 'l') 902 { 903 register int newval = 0; 904 for (regno = 0; regno < 8; ++regno) 905 if (val & (0x80 >> regno)) 906 newval |= 1 << regno; 907 val = newval; 908 } 909 val &= 0xff; 910 doneany = 0; 911 for (regno = 0; regno < 8; ++regno) 912 if (val & (1 << regno)) 913 { 914 int first_regno; 915 if (doneany) 916 (*info->fprintf_func) (info->stream, "/"); 917 doneany = 1; 918 (*info->fprintf_func) (info->stream, "%%fp%d", regno); 919 first_regno = regno; 920 while (val & (1 << (regno + 1))) 921 ++regno; 922 if (regno > first_regno) 923 (*info->fprintf_func) (info->stream, "-%%fp%d", regno); 924 } 925 } 926 else if (place == '8') 927 { 928 /* fmoveml for FP status registers */ 929 (*info->fprintf_func) (info->stream, "%s", 930 fpcr_names[fetch_arg (buffer, place, 3, 931 info)]); 932 } 933 else 934 return -2; 935 break; 936 937 case 'X': 938 place = '8'; 939 case 'Y': 940 case 'Z': 941 case 'W': 942 case '0': 943 case '1': 944 case '2': 945 case '3': 946 { 947 int val = fetch_arg (buffer, place, 5, info); 948 char *name = 0; 949 switch (val) 950 { 951 case 2: name = "%tt0"; break; 952 case 3: name = "%tt1"; break; 953 case 0x10: name = "%tc"; break; 954 case 0x11: name = "%drp"; break; 955 case 0x12: name = "%srp"; break; 956 case 0x13: name = "%crp"; break; 957 case 0x14: name = "%cal"; break; 958 case 0x15: name = "%val"; break; 959 case 0x16: name = "%scc"; break; 960 case 0x17: name = "%ac"; break; 961 case 0x18: name = "%psr"; break; 962 case 0x19: name = "%pcsr"; break; 963 case 0x1c: 964 case 0x1d: 965 { 966 int break_reg = ((buffer[3] >> 2) & 7); 967 (*info->fprintf_func) 968 (info->stream, val == 0x1c ? "%%bad%d" : "%%bac%d", 969 break_reg); 970 } 971 break; 972 default: 973 (*info->fprintf_func) (info->stream, "<mmu register %d>", val); 974 } 975 if (name) 976 (*info->fprintf_func) (info->stream, "%s", name); 977 } 978 break; 979 980 case 'f': 981 { 982 int fc = fetch_arg (buffer, place, 5, info); 983 if (fc == 1) 984 (*info->fprintf_func) (info->stream, "%%dfc"); 985 else if (fc == 0) 986 (*info->fprintf_func) (info->stream, "%%sfc"); 987 else 988 /* xgettext:c-format */ 989 (*info->fprintf_func) (info->stream, _("<function code %d>"), fc); 990 } 991 break; 992 993 case 'V': 994 (*info->fprintf_func) (info->stream, "%%val"); 995 break; 996 997 case 't': 998 { 999 int level = fetch_arg (buffer, place, 3, info); 1000 (*info->fprintf_func) (info->stream, "%d", level); 1001 } 1002 break; 1003 1004 case 'u': 1005 { 1006 short is_upper = 0; 1007 int reg = fetch_arg (buffer, place, 5, info); 1008 1009 if (reg & 0x10) 1010 { 1011 is_upper = 1; 1012 reg &= 0xf; 1013 } 1014 (*info->fprintf_func) (info->stream, "%s%s", 1015 reg_names[reg], 1016 is_upper ? "u" : "l"); 1017 } 1018 break; 1019 1020 default: 1021 return -2; 1022 } 1023 1024 return p - p0; 1025 } 1026 1027 /* Fetch BITS bits from a position in the instruction specified by CODE. 1028 CODE is a "place to put an argument", or 'x' for a destination 1029 that is a general address (mode and register). 1030 BUFFER contains the instruction. */ 1031 1032 static int 1033 fetch_arg (buffer, code, bits, info) 1034 unsigned char *buffer; 1035 int code; 1036 int bits; 1037 disassemble_info *info; 1038 { 1039 register int val = 0; 1040 switch (code) 1041 { 1042 case 's': 1043 val = buffer[1]; 1044 break; 1045 1046 case 'd': /* Destination, for register or quick. */ 1047 val = (buffer[0] << 8) + buffer[1]; 1048 val >>= 9; 1049 break; 1050 1051 case 'x': /* Destination, for general arg */ 1052 val = (buffer[0] << 8) + buffer[1]; 1053 val >>= 6; 1054 break; 1055 1056 case 'k': 1057 FETCH_DATA (info, buffer + 3); 1058 val = (buffer[3] >> 4); 1059 break; 1060 1061 case 'C': 1062 FETCH_DATA (info, buffer + 3); 1063 val = buffer[3]; 1064 break; 1065 1066 case '1': 1067 FETCH_DATA (info, buffer + 3); 1068 val = (buffer[2] << 8) + buffer[3]; 1069 val >>= 12; 1070 break; 1071 1072 case '2': 1073 FETCH_DATA (info, buffer + 3); 1074 val = (buffer[2] << 8) + buffer[3]; 1075 val >>= 6; 1076 break; 1077 1078 case '3': 1079 case 'j': 1080 FETCH_DATA (info, buffer + 3); 1081 val = (buffer[2] << 8) + buffer[3]; 1082 break; 1083 1084 case '4': 1085 FETCH_DATA (info, buffer + 5); 1086 val = (buffer[4] << 8) + buffer[5]; 1087 val >>= 12; 1088 break; 1089 1090 case '5': 1091 FETCH_DATA (info, buffer + 5); 1092 val = (buffer[4] << 8) + buffer[5]; 1093 val >>= 6; 1094 break; 1095 1096 case '6': 1097 FETCH_DATA (info, buffer + 5); 1098 val = (buffer[4] << 8) + buffer[5]; 1099 break; 1100 1101 case '7': 1102 FETCH_DATA (info, buffer + 3); 1103 val = (buffer[2] << 8) + buffer[3]; 1104 val >>= 7; 1105 break; 1106 1107 case '8': 1108 FETCH_DATA (info, buffer + 3); 1109 val = (buffer[2] << 8) + buffer[3]; 1110 val >>= 10; 1111 break; 1112 1113 case '9': 1114 FETCH_DATA (info, buffer + 3); 1115 val = (buffer[2] << 8) + buffer[3]; 1116 val >>= 5; 1117 break; 1118 1119 case 'e': 1120 val = (buffer[1] >> 6); 1121 break; 1122 1123 case 'm': 1124 val = (buffer[1] & 0x40 ? 0x8 : 0) 1125 | ((buffer[0] >> 1) & 0x7) 1126 | (buffer[3] & 0x80 ? 0x10 : 0); 1127 break; 1128 1129 case 'n': 1130 val = (buffer[1] & 0x40 ? 0x8 : 0) | ((buffer[0] >> 1) & 0x7); 1131 break; 1132 1133 case 'o': 1134 val = (buffer[2] >> 4) | (buffer[3] & 0x80 ? 0x10 : 0); 1135 break; 1136 1137 case 'M': 1138 val = buffer[1] | (buffer[3] & 0x40 ? 0x10 : 0); 1139 break; 1140 1141 case 'N': 1142 val = buffer[3] | (buffer[3] & 0x40 ? 0x10 : 0); 1143 break; 1144 1145 case 'h': 1146 val = buffer[2] >> 2; 1147 break; 1148 1149 default: 1150 abort (); 1151 } 1152 1153 switch (bits) 1154 { 1155 case 1: 1156 return val & 1; 1157 case 2: 1158 return val & 3; 1159 case 3: 1160 return val & 7; 1161 case 4: 1162 return val & 017; 1163 case 5: 1164 return val & 037; 1165 case 6: 1166 return val & 077; 1167 case 7: 1168 return val & 0177; 1169 case 8: 1170 return val & 0377; 1171 case 12: 1172 return val & 07777; 1173 default: 1174 abort (); 1175 } 1176 } 1177 1178 /* Print an indexed argument. The base register is BASEREG (-1 for pc). 1179 P points to extension word, in buffer. 1180 ADDR is the nominal core address of that extension word. */ 1181 1182 static unsigned char * 1183 print_indexed (basereg, p, addr, info) 1184 int basereg; 1185 unsigned char *p; 1186 bfd_vma addr; 1187 disassemble_info *info; 1188 { 1189 register int word; 1190 static char *const scales[] = {"", ":2", ":4", ":8"}; 1191 bfd_vma base_disp; 1192 bfd_vma outer_disp; 1193 char buf[40]; 1194 char vmabuf[50]; 1195 1196 word = NEXTWORD (p); 1197 1198 /* Generate the text for the index register. 1199 Where this will be output is not yet determined. */ 1200 sprintf (buf, "%s:%c%s", 1201 reg_names[(word >> 12) & 0xf], 1202 (word & 0x800) ? 'l' : 'w', 1203 scales[(word >> 9) & 3]); 1204 1205 /* Handle the 68000 style of indexing. */ 1206 1207 if ((word & 0x100) == 0) 1208 { 1209 base_disp = word & 0xff; 1210 if ((base_disp & 0x80) != 0) 1211 base_disp -= 0x100; 1212 if (basereg == -1) 1213 base_disp += addr; 1214 print_base (basereg, base_disp, info); 1215 (*info->fprintf_func) (info->stream, ",%s)", buf); 1216 return p; 1217 } 1218 1219 /* Handle the generalized kind. */ 1220 /* First, compute the displacement to add to the base register. */ 1221 1222 if (word & 0200) 1223 { 1224 if (basereg == -1) 1225 basereg = -3; 1226 else 1227 basereg = -2; 1228 } 1229 if (word & 0100) 1230 buf[0] = '\0'; 1231 base_disp = 0; 1232 switch ((word >> 4) & 3) 1233 { 1234 case 2: 1235 base_disp = NEXTWORD (p); 1236 break; 1237 case 3: 1238 base_disp = NEXTLONG (p); 1239 } 1240 if (basereg == -1) 1241 base_disp += addr; 1242 1243 /* Handle single-level case (not indirect) */ 1244 1245 if ((word & 7) == 0) 1246 { 1247 print_base (basereg, base_disp, info); 1248 if (buf[0] != '\0') 1249 (*info->fprintf_func) (info->stream, ",%s", buf); 1250 (*info->fprintf_func) (info->stream, ")"); 1251 return p; 1252 } 1253 1254 /* Two level. Compute displacement to add after indirection. */ 1255 1256 outer_disp = 0; 1257 switch (word & 3) 1258 { 1259 case 2: 1260 outer_disp = NEXTWORD (p); 1261 break; 1262 case 3: 1263 outer_disp = NEXTLONG (p); 1264 } 1265 1266 print_base (basereg, base_disp, info); 1267 if ((word & 4) == 0 && buf[0] != '\0') 1268 { 1269 (*info->fprintf_func) (info->stream, ",%s", buf); 1270 buf[0] = '\0'; 1271 } 1272 sprintf_vma (vmabuf, outer_disp); 1273 (*info->fprintf_func) (info->stream, ")@(%s", vmabuf); 1274 if (buf[0] != '\0') 1275 (*info->fprintf_func) (info->stream, ",%s", buf); 1276 (*info->fprintf_func) (info->stream, ")"); 1277 1278 return p; 1279 } 1280 1281 /* Print a base register REGNO and displacement DISP, on INFO->STREAM. 1282 REGNO = -1 for pc, -2 for none (suppressed). */ 1283 1284 static void 1285 print_base (regno, disp, info) 1286 int regno; 1287 bfd_vma disp; 1288 disassemble_info *info; 1289 { 1290 if (regno == -1) 1291 { 1292 (*info->fprintf_func) (info->stream, "%%pc@("); 1293 (*info->print_address_func) (disp, info); 1294 } 1295 else 1296 { 1297 char buf[50]; 1298 1299 if (regno == -2) 1300 (*info->fprintf_func) (info->stream, "@("); 1301 else if (regno == -3) 1302 (*info->fprintf_func) (info->stream, "%%zpc@("); 1303 else 1304 (*info->fprintf_func) (info->stream, "%s@(", reg_names[regno]); 1305 1306 sprintf_vma (buf, disp); 1307 (*info->fprintf_func) (info->stream, "%s", buf); 1308 } 1309 } 1310