gdb/m68k-pinsn.c

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