binutils/m68k-pinsn.c

   1 /* Print m68k instructions for objdump
   2    Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
   3
   4
   5 This file is part of the binutils.
   6
   7 The binutils are free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 The binutils are distributed in the hope that they will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with the binutils; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include <stdio.h>
  25 #include "opcode/m68k.h"
  26
  27 /* Sign-extend an (unsigned char). */
  28 #if __STDC__ == 1
  29 #define COERCE_SIGNED_CHAR(ch) ((signed char)(ch))
  30 #else
  31 #define COERCE_SIGNED_CHAR(ch) ((int)(((ch) ^ 0x80) & 0xFF) - 128)
  32 #endif
  33
  34 extern void print_address();
  35
  36 /* 68k instructions are never longer than this many bytes.  */
  37 #define MAXLEN 22
  38
  39 /* Number of elements in the opcode table.  */
  40 #define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
  41
  42 extern char *reg_names[];
  43 char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
  44                      "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
  45
  46 char *reg_names[] = {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", "ps", "pc"};
  47 static unsigned char *print_insn_arg ();
  48 static unsigned char *print_indexed ();
  49 static void print_base ();
  50 static int fetch_arg ();
  51
  52 #define NEXTBYTE(p)  (p += 2, COERCE_SIGNED_CHAR(p[-1]))
  53
  54 #define NEXTWORD(p)  \
  55   (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
  56
  57 #define NEXTLONG(p)  \
  58   (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
  59
  60 #define NEXTSINGLE(p) \
  61   (p += 4, *((float *)(p - 4)))
  62
  63 #define NEXTDOUBLE(p) \
  64   (p += 8, *((double *)(p - 8)))
  65
  66 #define NEXTEXTEND(p) \
  67   (p += 12, 0.0)        /* Need a function to convert from extended to double
  68                            precision... */
  69
  70 #define NEXTPACKED(p) \
  71   (p += 12, 0.0)        /* Need a function to convert from packed to double
  72                            precision.   Actually, it's easier to print a
  73                            packed number than a double anyway, so maybe
  74                            there should be a special case to handle this... */
  75 \f
  76 /* Print the m68k instruction at address MEMADDR in debugged memory,
  77    on STREAM.  Returns length of the instruction, in bytes.  */
  78
  79 int
  80 print_insn_m68k(addr, buffer, stream)
  81      bfd_vma addr;
  82 unsigned    char *buffer;
  83      FILE *stream;
  84 {
  85   register unsigned int i;
  86   register unsigned char *p;
  87   register char *d;
  88   register unsigned int bestmask;
  89   int best;
  90
  91
  92
  93   bestmask = 0;
  94   best = -1;
  95   for (i = 0; i < NOPCODES; i++)
  96     {
  97       register unsigned int opcode = m68k_opcodes[i].opcode;
  98       register unsigned int match = m68k_opcodes[i].match;
  99       if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
 100           && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
 101           && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
 102           && ((0xff & buffer[3] & match) == (0xff & opcode)))
 103         {
 104           /* Don't use for printout the variants of divul and divsl
 105              that have the same register number in two places.
 106              The more general variants will match instead.  */
 107           for (d = m68k_opcodes[i].args; *d; d += 2)
 108             if (d[1] == 'D')
 109               break;
 110
 111           /* Don't use for printout the variants of most floating
 112              point coprocessor instructions which use the same
 113              register number in two places, as above. */
 114           if (*d == 0)
 115             for (d = m68k_opcodes[i].args; *d; d += 2)
 116               if (d[1] == 't')
 117                 break;
 118
 119           if (*d == 0 && match > bestmask)
 120             {
 121               best = i;
 122               bestmask = match;
 123             }
 124         }
 125     }
 126
 127   /* Handle undefined instructions.  */
 128   if (best < 0)
 129     {
 130       fprintf (stream, "0%o", (unsigned) (buffer[0] << 8) + buffer[1]);
 131       return 2;
 132     }
 133
 134   fprintf (stream, "%s", m68k_opcodes[best].name);
 135
 136   /* Point at first word of argument data,
 137      and at descriptor for first argument.  */
 138   p = buffer + 2;
 139
 140   /* Why do this this way? -MelloN */
 141   for (d = m68k_opcodes[best].args; *d; d += 2)
 142     {
 143       if (d[0] == '#')
 144         {
 145           if (d[1] == 'l' && p - buffer < 6)
 146             p = buffer + 6;
 147           else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
 148             p = buffer + 4;
 149         }
 150       if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
 151         p = buffer + 4;
 152       if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
 153         p = buffer + 6;
 154       if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4)
 155         p = buffer + 4;
 156     }
 157
 158   d = m68k_opcodes[best].args;
 159
 160   if (*d)
 161     fputs (" ", stream);
 162
 163   while (*d)
 164     {
 165       p = print_insn_arg (d, buffer, p, addr + p - buffer, stream);
 166       d += 2;
 167       if (*d && *(d - 2) != 'I' && *d != 'k')
 168         fputs (",", stream);
 169     }
 170   return p - buffer;
 171 }
 172
 173 static unsigned char *
 174 print_insn_arg (d, buffer, p, addr, stream)
 175      char *d;
 176      unsigned char *buffer;
 177      register unsigned char *p;
 178  bfd_vma addr;          /* PC for this arg to be relative to */
 179      FILE *stream;
 180 {
 181   register int val = 0;
 182   register int place = d[1];
 183   int regno;
 184   register char *regname;
 185   register unsigned char *p1;
 186   register double flval = 0;
 187   int flt_p;
 188
 189   switch (*d)
 190     {
 191     case 'C':
 192       fprintf (stream, "ccr");
 193       break;
 194
 195     case 'S':
 196       fprintf (stream, "sr");
 197       break;
 198
 199     case 'U':
 200       fprintf (stream, "usp");
 201       break;
 202
 203     case 'J':
 204       {
 205         static struct { char *name; int value; } names[]
 206           = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
 207              {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
 208              {"msp", 0x803}, {"isp", 0x804}};
 209
 210         val = fetch_arg (buffer, place, 12);
 211         for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
 212           if (names[regno].value == val)
 213             {
 214               fprintf (stream, names[regno].name);
 215               break;
 216             }
 217         if (regno < 0)
 218           fprintf (stream, "%d", val);
 219       }
 220       break;
 221
 222     case 'Q':
 223       val = fetch_arg (buffer, place, 3);
 224       if (val == 0) val = 8;
 225       fprintf (stream, "#%d", val);
 226       break;
 227
 228     case 'M':
 229       val = fetch_arg (buffer, place, 8);
 230       if (val & 0x80)
 231         val = val - 0x100;
 232       fprintf (stream, "#%d", val);
 233       break;
 234
 235     case 'T':
 236       val = fetch_arg (buffer, place, 4);
 237       fprintf (stream, "#%d", val);
 238       break;
 239
 240     case 'D':
 241       fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
 242       break;
 243
 244     case 'A':
 245       fprintf (stream, "%s",
 246                         reg_names[fetch_arg (buffer, place, 3) + 010]);
 247       break;
 248
 249     case 'R':
 250       fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
 251       break;
 252
 253     case 'F':
 254       fprintf (stream, "fp%d", fetch_arg (buffer, place, 3));
 255       break;
 256
 257     case 'O':
 258       val = fetch_arg (buffer, place, 6);
 259       if (val & 0x20)
 260         fprintf (stream, "%s", reg_names [val & 7]);
 261       else
 262         fprintf (stream, "%d", val);
 263       break;
 264
 265     case '+':
 266       fprintf (stream, "%s@+",
 267                         reg_names[fetch_arg (buffer, place, 3) + 8]);
 268       break;
 269
 270     case '-':
 271       fprintf (stream, "%s@-",
 272                reg_names[fetch_arg (buffer, place, 3) + 8]);
 273       break;
 274
 275     case 'k':
 276       if (place == 'k')
 277         fprintf (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
 278       else if (place == 'C')
 279         {
 280           val = fetch_arg (buffer, place, 7);
 281           if ( val > 63 )               /* This is a signed constant. */
 282             val -= 128;
 283           fprintf (stream, "{#%d}", val);
 284         }
 285       else
 286         fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
 287                *d, place);
 288       break;
 289
 290     case '#':
 291     case '^':
 292       p1 = buffer + (*d == '#' ? 2 : 4);
 293       if (place == 's')
 294         val = fetch_arg (buffer, place, 4);
 295       else if (place == 'C')
 296         val = fetch_arg (buffer, place, 7);
 297       else if (place == '8')
 298         val = fetch_arg (buffer, place, 3);
 299       else if (place == '3')
 300         val = fetch_arg (buffer, place, 8);
 301       else if (place == 'b')
 302         val = NEXTBYTE (p1);
 303       else if (place == 'w')
 304         val = NEXTWORD (p1);
 305       else if (place == 'l')
 306         val = NEXTLONG (p1);
 307       else
 308         fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
 309                *d, place);
 310       fprintf (stream, "#%d", val);
 311       break;
 312
 313     case 'B':
 314       if (place == 'b')
 315         val = NEXTBYTE (p);
 316       else if (place == 'B')
 317         val = COERCE_SIGNED_CHAR(buffer[1]);
 318       else if (place == 'w' || place == 'W')
 319         val = NEXTWORD (p);
 320       else if (place == 'l' || place == 'L')
 321         val = NEXTLONG (p);
 322       else if (place == 'g')
 323         {
 324           val = ((char *)buffer)[1];
 325           if (val == 0)
 326             val = NEXTWORD (p);
 327           else if (val == -1)
 328             val = NEXTLONG (p);
 329         }
 330       else if (place == 'c')
 331         {
 332           if (buffer[1] & 0x40)         /* If bit six is one, long offset */
 333             val = NEXTLONG (p);
 334           else
 335             val = NEXTWORD (p);
 336         }
 337       else
 338         fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
 339                *d, place);
 340       print_address (addr + val, stream);
 341       break;
 342
 343     case 'd':
 344       val = NEXTWORD (p);
 345       fprintf (stream, "%s@(%d)",
 346                         reg_names[fetch_arg (buffer, place, 3)], val);
 347       break;
 348
 349     case 's':
 350       fprintf (stream, "%s",
 351                         fpcr_names[fetch_arg (buffer, place, 3)]);
 352       break;
 353
 354     case 'I':
 355       val = fetch_arg (buffer, 'd', 3);           /* Get coprocessor ID... */
 356       if (val != 1)                             /* Unusual coprocessor ID? */
 357         fprintf (stream, "(cpid=%d) ", val);
 358       if (place == 'i')
 359         p += 2;                      /* Skip coprocessor extended operands */
 360       break;
 361
 362     case '*':
 363     case '~':
 364     case '%':
 365     case ';':
 366     case '@':
 367     case '!':
 368     case '$':
 369     case '?':
 370     case '/':
 371     case '&':
 372
 373       if (place == 'd')
 374         {
 375           val = fetch_arg (buffer, 'x', 6);
 376           val = ((val & 7) << 3) + ((val >> 3) & 7);
 377         }
 378       else
 379         val = fetch_arg (buffer, 's', 6);
 380
 381       /* Get register number assuming address register.  */
 382       regno = (val & 7) + 8;
 383       regname = reg_names[regno];
 384       switch (val >> 3)
 385         {
 386         case 0:
 387           fprintf (stream, "%s", reg_names[val]);
 388           break;
 389
 390         case 1:
 391           fprintf (stream, "%s", regname);
 392           break;
 393
 394         case 2:
 395           fprintf (stream, "%s@", regname);
 396           break;
 397
 398         case 3:
 399           fprintf (stream, "%s@+", regname);
 400           break;
 401
 402         case 4:
 403           fprintf (stream, "%s@-", regname);
 404           break;
 405
 406         case 5:
 407           val = NEXTWORD (p);
 408           fprintf (stream, "%s@(%d)", regname, val);
 409           break;
 410
 411         case 6:
 412           p = print_indexed (regno, p, addr, stream);
 413           break;
 414
 415         case 7:
 416           switch (val & 7)
 417             {
 418             case 0:
 419               val = NEXTWORD (p);
 420               fprintf (stream, "@#");
 421               print_address (val, stream);
 422               break;
 423
 424             case 1:
 425               val = NEXTLONG (p);
 426               fprintf (stream, "@#");
 427               print_address (val, stream);
 428               break;
 429
 430             case 2:
 431               val = NEXTWORD (p);
 432               print_address (addr + val, stream);
 433               break;
 434
 435             case 3:
 436               p = print_indexed (-1, p, addr, stream);
 437               break;
 438
 439             case 4:
 440               flt_p = 1;        /* Assume it's a float... */
 441               switch( place )
 442               {
 443                 case 'b':
 444                   val = NEXTBYTE (p);
 445                   flt_p = 0;
 446                   break;
 447
 448                 case 'w':
 449                   val = NEXTWORD (p);
 450                   flt_p = 0;
 451                   break;
 452
 453                 case 'l':
 454                   val = NEXTLONG (p);
 455                   flt_p = 0;
 456                   break;
 457
 458                 case 'f':
 459                   flval = NEXTSINGLE(p);
 460                   break;
 461
 462                 case 'F':
 463                   flval = NEXTDOUBLE(p);
 464                   break;
 465
 466                 case 'x':
 467                   flval = NEXTEXTEND(p);
 468                   break;
 469
 470                 case 'p':
 471                   flval = NEXTPACKED(p);
 472                   break;
 473
 474                 default:
 475                   fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
 476                        *d, place);
 477               }
 478               if ( flt_p )      /* Print a float? */
 479                 fprintf (stream, "#%g", flval);
 480               else
 481                 fprintf (stream, "#%d", val);
 482               break;
 483
 484             default:
 485               fprintf (stream, "<invalid address mode 0%o>", (unsigned) val);
 486             }
 487         }
 488       break;
 489
 490     case 'L':
 491     case 'l':
 492         if (place == 'w')
 493           {
 494             char doneany;
 495             p1 = buffer + 2;
 496             val = NEXTWORD (p1);
 497             /* Move the pointer ahead if this point is farther ahead
 498                than the last.  */
 499             p = p1 > p ? p1 : p;
 500             if (val == 0)
 501               {
 502                 fputs ("#0", stream);
 503                 break;
 504               }
 505             if (*d == 'l')
 506               {
 507                 register int newval = 0;
 508                 for (regno = 0; regno < 16; ++regno)
 509                   if (val & (0x8000 >> regno))
 510                     newval |= 1 << regno;
 511                 val = newval;
 512               }
 513             val &= 0xffff;
 514             doneany = 0;
 515             for (regno = 0; regno < 16; ++regno)
 516               if (val & (1 << regno))
 517                 {
 518                   int first_regno;
 519                   if (doneany)
 520                     fputs ("/", stream);
 521                   doneany = 1;
 522                   fprintf (stream, "%s", reg_names[regno]);
 523                   first_regno = regno;
 524                   while (val & (1 << (regno + 1)))
 525                     ++regno;
 526                   if (regno > first_regno)
 527                     fprintf (stream, "-%s", reg_names[regno]);
 528                 }
 529           }
 530         else if (place == '3')
 531           {
 532             /* `fmovem' insn.  */
 533             char doneany;
 534             val = fetch_arg (buffer, place, 8);
 535             if (val == 0)
 536               {
 537                 fputs ("#0", stream);
 538                 break;
 539               }
 540             if (*d == 'l')
 541               {
 542                 register int newval = 0;
 543                 for (regno = 0; regno < 8; ++regno)
 544                   if (val & (0x80 >> regno))
 545                     newval |= 1 << regno;
 546                 val = newval;
 547               }
 548             val &= 0xff;
 549             doneany = 0;
 550             for (regno = 0; regno < 8; ++regno)
 551               if (val & (1 << regno))
 552                 {
 553                   int first_regno;
 554                   if (doneany)
 555                     fputs ("/", stream);
 556                   doneany = 1;
 557                   fprintf (stream, "fp%d", regno);
 558                   first_regno = regno;
 559                   while (val & (1 << (regno + 1)))
 560                     ++regno;
 561                   if (regno > first_regno)
 562                     fprintf (stream, "-fp%d", regno);
 563                 }
 564           }
 565         else
 566           abort ();
 567       break;
 568
 569     default:
 570       fprintf(stderr, "Invalid arg format in opcode table: \"%c\".", *d);
 571     }
 572
 573   return (unsigned char *) p;
 574 }
 575
 576 /* Fetch BITS bits from a position in the instruction specified by CODE.
 577    CODE is a "place to put an argument", or 'x' for a destination
 578    that is a general address (mode and register).
 579    BUFFER contains the instruction.  */
 580
 581 static int
 582 fetch_arg (buffer, code, bits)
 583      unsigned char *buffer;
 584      char code;
 585      int bits;
 586 {
 587   register int val = 0;
 588   switch (code)
 589     {
 590     case 's':
 591       val = buffer[1];
 592       break;
 593
 594     case 'd':                   /* Destination, for register or quick.  */
 595       val = (buffer[0] << 8) + buffer[1];
 596       val >>= 9;
 597       break;
 598
 599     case 'x':                   /* Destination, for general arg */
 600       val = (buffer[0] << 8) + buffer[1];
 601       val >>= 6;
 602       break;
 603
 604     case 'k':
 605       val = (buffer[3] >> 4);
 606       break;
 607
 608     case 'C':
 609       val = buffer[3];
 610       break;
 611
 612     case '1':
 613       val = (buffer[2] << 8) + buffer[3];
 614       val >>= 12;
 615       break;
 616
 617     case '2':
 618       val = (buffer[2] << 8) + buffer[3];
 619       val >>= 6;
 620       break;
 621
 622     case '3':
 623     case 'j':
 624       val = (buffer[2] << 8) + buffer[3];
 625       break;
 626
 627     case '4':
 628       val = (buffer[4] << 8) + buffer[5];
 629       val >>= 12;
 630       break;
 631
 632     case '5':
 633       val = (buffer[4] << 8) + buffer[5];
 634       val >>= 6;
 635       break;
 636
 637     case '6':
 638       val = (buffer[4] << 8) + buffer[5];
 639       break;
 640
 641     case '7':
 642       val = (buffer[2] << 8) + buffer[3];
 643       val >>= 7;
 644       break;
 645
 646     case '8':
 647       val = (buffer[2] << 8) + buffer[3];
 648       val >>= 10;
 649       break;
 650
 651     default:
 652       abort ();
 653     }
 654
 655   switch (bits)
 656     {
 657     case 3:
 658       return val & 7;
 659     case 4:
 660       return val & 017;
 661     case 5:
 662       return val & 037;
 663     case 6:
 664       return val & 077;
 665     case 7:
 666       return val & 0177;
 667     case 8:
 668       return val & 0377;
 669     case 12:
 670       return val & 07777;
 671     default:
 672       abort ();
 673       return(0);
 674     }
 675 } /* fetch_arg() */
 676
 677 /* Print an indexed argument.  The base register is BASEREG (-1 for pc).
 678    P points to extension word, in buffer.
 679    ADDR is the nominal core address of that extension word.  */
 680
 681 static unsigned char *
 682 print_indexed (basereg, p, addr, stream)
 683      int basereg;
 684      unsigned char *p;
 685      FILE *stream;
 686 bfd_vma addr;
 687 {
 688   register int word;
 689   static char *scales[] = {"", "*2", "*4", "*8"};
 690   register int base_disp;
 691   register int outer_disp;
 692   char buf[40];
 693
 694   word = NEXTWORD (p);
 695
 696   /* Generate the text for the index register.
 697      Where this will be output is not yet determined.  */
 698   sprintf (buf, "[%s.%c%s]",
 699            reg_names[(word >> 12) & 0xf],
 700            (word & 0x800) ? 'l' : 'w',
 701            scales[(word >> 9) & 3]);
 702
 703   /* Handle the 68000 style of indexing.  */
 704
 705   if ((word & 0x100) == 0)
 706     {
 707       print_base (basereg,
 708                   ((word & 0x80) ? word | 0xff00 : word & 0xff)
 709                   + ((basereg == -1) ? addr : 0),
 710                   stream);
 711       fputs (buf, stream);
 712       return p;
 713     }
 714
 715   /* Handle the generalized kind.  */
 716   /* First, compute the displacement to add to the base register.  */
 717
 718   if (word & 0200)
 719     basereg = -2;
 720   if (word & 0100)
 721     buf[0] = 0;
 722   base_disp = 0;
 723   switch ((word >> 4) & 3)
 724     {
 725     case 2:
 726       base_disp = NEXTWORD (p);
 727       break;
 728     case 3:
 729       base_disp = NEXTLONG (p);
 730     }
 731   if (basereg == -1)
 732     base_disp += addr;
 733
 734   /* Handle single-level case (not indirect) */
 735
 736   if ((word & 7) == 0)
 737     {
 738       print_base (basereg, base_disp, stream);
 739       fputs (buf, stream);
 740       return p;
 741     }
 742
 743   /* Two level.  Compute displacement to add after indirection.  */
 744
 745   outer_disp = 0;
 746   switch (word & 3)
 747     {
 748     case 2:
 749       outer_disp = NEXTWORD (p);
 750       break;
 751     case 3:
 752       outer_disp = NEXTLONG (p);
 753     }
 754
 755   fprintf (stream, "%d(", outer_disp);
 756   print_base (basereg, base_disp, stream);
 757
 758   /* If postindexed, print the closeparen before the index.  */
 759   if (word & 4)
 760     fprintf (stream, ")%s", buf);
 761   /* If preindexed, print the closeparen after the index.  */
 762   else
 763     fprintf (stream, "%s)", buf);
 764
 765   return p;
 766 }
 767
 768 /* Print a base register REGNO and displacement DISP, on STREAM.
 769    REGNO = -1 for pc, -2 for none (suppressed).  */
 770
 771 static void
 772 print_base (regno, disp, stream)
 773      int regno;
 774      int disp;
 775      FILE *stream;
 776 {
 777   if (regno == -2)
 778     fprintf (stream, "%d", disp);
 779   else if (regno == -1)
 780     fprintf (stream, "0x%x", (unsigned) disp);
 781   else
 782     fprintf (stream, "%d(%s)", disp, reg_names[regno]);
 783 }