binutils/m68k-pinsn.c

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