gdb/m68k-pinsn.c

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