gdb/m68k-pinsn.c

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