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