opcodes/ns32k-dis.c

   1 /* Print National Semiconductor 32000 instructions.
   2    Copyright (c) 1986, 88, 91, 92, 94, 95, 1998 Free Software Foundation, Inc.
   3
   4 This file is part of opcodes library.
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "dis-asm.h"
  24 #if !defined(const) && !defined(__STDC__)
  25 #define const
  26 #endif
  27 #include "opcode/ns32k.h"
  28 #include "opintl.h"
  29
  30 static disassemble_info *dis_info;
  31
  32 /*
  33  * Hacks to get it to compile <= READ THESE AS FIXES NEEDED
  34  */
  35 #define INVALID_FLOAT(val, size) invalid_float((char *)val, size)
  36
  37 static int print_insn_arg
  38   PARAMS ((int, int, int *, char *, bfd_vma, char *, int));
  39 static int get_displacement PARAMS ((char *, int *));
  40 static int invalid_float PARAMS ((char *, int));
  41
  42 static long read_memory_integer(addr, nr)
  43      unsigned char *addr;
  44      int nr;
  45 {
  46   long val;
  47   int i;
  48   for (val = 0, i = nr - 1; i >= 0; i--) {
  49     val =  (val << 8);
  50     val |= (0xff & *(addr + i));
  51   }
  52   return val;
  53 }
  54
  55 /* 32000 instructions are never longer than this.  */
  56 #define MAXLEN 62
  57
  58
  59 #include <setjmp.h>
  60
  61 struct private
  62 {
  63   /* Points to first byte not fetched.  */
  64   bfd_byte *max_fetched;
  65   bfd_byte the_buffer[MAXLEN];
  66   bfd_vma insn_start;
  67   jmp_buf bailout;
  68 };
  69
  70
  71 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
  72    to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
  73    on error.  */
  74 #define FETCH_DATA(info, addr) \
  75   ((addr) <= ((struct private *)(info->private_data))->max_fetched \
  76    ? 1 : fetch_data ((info), (addr)))
  77
  78 static int
  79 fetch_data (info, addr)
  80      struct disassemble_info *info;
  81      bfd_byte *addr;
  82 {
  83   int status;
  84   struct private *priv = (struct private *)info->private_data;
  85   bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
  86
  87   status = (*info->read_memory_func) (start,
  88                                       priv->max_fetched,
  89                                       addr - priv->max_fetched,
  90                                       info);
  91   if (status != 0)
  92     {
  93       (*info->memory_error_func) (status, start, info);
  94       longjmp (priv->bailout, 1);
  95     }
  96   else
  97     priv->max_fetched = addr;
  98   return 1;
  99 }
 100 /* Number of elements in the opcode table.  */
 101 #define NOPCODES (sizeof ns32k_opcodes / sizeof ns32k_opcodes[0])
 102
 103 #define NEXT_IS_ADDR    '|'
 104
 105 \f
 106 struct ns32k_option {
 107   char *pattern;                /* the option itself */
 108   unsigned long value;          /* binary value of the option */
 109   unsigned long match;          /* these bits must match */
 110 };
 111
 112 \f
 113 static const struct ns32k_option opt_u[]= /* restore, exit */
 114 {
 115   { "r0",       0x80,   0x80    },
 116   { "r1",       0x40,   0x40    },
 117   { "r2",       0x20,   0x20    },
 118   { "r3",       0x10,   0x10    },
 119   { "r4",       0x08,   0x08    },
 120   { "r5",       0x04,   0x04    },
 121   { "r6",       0x02,   0x02    },
 122   { "r7",       0x01,   0x01    },
 123   {  0 ,        0x00,   0x00    }
 124 };
 125
 126 static const struct ns32k_option opt_U[]= /* save, enter */
 127 {
 128   { "r0",       0x01,   0x01    },
 129   { "r1",       0x02,   0x02    },
 130   { "r2",       0x04,   0x04    },
 131   { "r3",       0x08,   0x08    },
 132   { "r4",       0x10,   0x10    },
 133   { "r5",       0x20,   0x20    },
 134   { "r6",       0x40,   0x40    },
 135   { "r7",       0x80,   0x80    },
 136   {  0 ,        0x00,   0x00    }
 137 };
 138
 139 static const struct ns32k_option opt_O[]= /* setcfg */
 140 {
 141   { "c",        0x8,    0x8     },
 142   { "m",        0x4,    0x4     },
 143   { "f",        0x2,    0x2     },
 144   { "i",        0x1,    0x1     },
 145   {  0 ,        0x0,    0x0     }
 146 };
 147
 148 static const struct ns32k_option opt_C[]= /* cinv */
 149 {
 150   { "a",        0x4,    0x4     },
 151   { "i",        0x2,    0x2     },
 152   { "d",        0x1,    0x1     },
 153   {  0 ,        0x0,    0x0     }
 154 };
 155
 156 static const struct ns32k_option opt_S[]= /* string inst */
 157 {
 158   { "b",        0x1,    0x1     },
 159   { "u",        0x6,    0x6     },
 160   { "w",        0x2,    0x2     },
 161   {  0 ,        0x0,    0x0     }
 162 };
 163
 164 static const struct ns32k_option list_P532[]= /* lpr spr */
 165 {
 166   { "us",       0x0,    0xf     },
 167   { "dcr",      0x1,    0xf     },
 168   { "bpc",      0x2,    0xf     },
 169   { "dsr",      0x3,    0xf     },
 170   { "car",      0x4,    0xf     },
 171   { "fp",       0x8,    0xf     },
 172   { "sp",       0x9,    0xf     },
 173   { "sb",       0xa,    0xf     },
 174   { "usp",      0xb,    0xf     },
 175   { "cfg",      0xc,    0xf     },
 176   { "psr",      0xd,    0xf     },
 177   { "intbase",  0xe,    0xf     },
 178   { "mod",      0xf,    0xf     },
 179   {  0 ,        0x00,   0xf     }
 180 };
 181
 182 static const struct ns32k_option list_M532[]= /* lmr smr */
 183 {
 184   { "mcr",      0x9,    0xf     },
 185   { "msr",      0xa,    0xf     },
 186   { "tear",     0xb,    0xf     },
 187   { "ptb0",     0xc,    0xf     },
 188   { "ptb1",     0xd,    0xf     },
 189   { "ivar0",    0xe,    0xf     },
 190   { "ivar1",    0xf,    0xf     },
 191   {  0 ,        0x0,    0xf     }
 192 };
 193
 194 static const struct ns32k_option list_P032[]= /* lpr spr */
 195 {
 196   { "upsr",     0x0,    0xf     },
 197   { "fp",       0x8,    0xf     },
 198   { "sp",       0x9,    0xf     },
 199   { "sb",       0xa,    0xf     },
 200   { "psr",      0xb,    0xf     },
 201   { "intbase",  0xe,    0xf     },
 202   { "mod",      0xf,    0xf     },
 203   {  0 ,        0x0,    0xf     }
 204 };
 205
 206 static const struct ns32k_option list_M032[]= /* lmr smr */
 207 {
 208   { "bpr0",     0x0,    0xf     },
 209   { "bpr1",     0x1,    0xf     },
 210   { "pf0",      0x4,    0xf     },
 211   { "pf1",      0x5,    0xf     },
 212   { "sc",       0x8,    0xf     },
 213   { "msr",      0xa,    0xf     },
 214   { "bcnt",     0xb,    0xf     },
 215   { "ptb0",     0xc,    0xf     },
 216   { "ptb1",     0xd,    0xf     },
 217   { "eia",      0xf,    0xf     },
 218   {  0 ,        0x0,    0xf     }
 219 };
 220
 221
 222 /*
 223  * figure out which options are present
 224  */
 225 static void
 226 optlist(options, optionP, result)
 227      int options;
 228      const struct ns32k_option *optionP;
 229      char *result;
 230 {
 231     if (options == 0) {
 232         sprintf(result, "[]");
 233         return;
 234     }
 235     sprintf(result, "[");
 236
 237     for (; (options != 0) && optionP->pattern; optionP++) {
 238         if ((options & optionP->match) == optionP->value) {
 239             /* we found a match, update result and options */
 240             strcat(result, optionP->pattern);
 241             options &= ~optionP->value;
 242             if (options != 0)   /* more options to come */
 243                 strcat(result, ",");
 244         }
 245     }
 246     if (options != 0)
 247         strcat(result, "undefined");
 248
 249     strcat(result, "]");
 250 }
 251
 252 static void
 253 list_search (reg_value, optionP, result)
 254      int reg_value;
 255      const struct ns32k_option *optionP;
 256      char *result;
 257 {
 258     for (; optionP->pattern; optionP++) {
 259         if ((reg_value & optionP->match) == optionP->value) {
 260             sprintf(result, "%s", optionP->pattern);
 261             return;
 262         }
 263     }
 264     sprintf(result, "undefined");
 265 }
 266 \f
 267 /*
 268  * extract "count" bits starting "offset" bits
 269  * into buffer
 270  */
 271
 272 static int
 273 bit_extract (buffer, offset, count)
 274      bfd_byte *buffer;
 275      int offset;
 276      int count;
 277 {
 278   int result;
 279   int bit;
 280
 281   buffer += offset >> 3;
 282   offset &= 7;
 283   bit = 1;
 284   result = 0;
 285   while (count--)
 286     {
 287       FETCH_DATA(dis_info, buffer + 1);
 288       if ((*buffer & (1 << offset)))
 289         result |= bit;
 290       if (++offset == 8)
 291         {
 292           offset = 0;
 293           buffer++;
 294         }
 295       bit <<= 1;
 296     }
 297   return result;
 298 }
 299
 300 /* Like bit extract but the buffer is valid and doen't need to be
 301  * fetched
 302  */
 303 static int
 304 bit_extract_simple (buffer, offset, count)
 305      bfd_byte *buffer;
 306      int offset;
 307      int count;
 308 {
 309   int result;
 310   int mask;
 311   int bit;
 312
 313   buffer += offset >> 3;
 314   offset &= 7;
 315   bit = 1;
 316   result = 0;
 317   while (count--)
 318     {
 319       if ((*buffer & (1 << offset)))
 320         result |= bit;
 321       if (++offset == 8)
 322         {
 323           offset = 0;
 324           buffer++;
 325         }
 326       bit <<= 1;
 327     }
 328   return result;
 329 }
 330
 331 static void
 332 bit_copy (buffer, offset, count, to)
 333      char *buffer;
 334      int offset;
 335      int count;
 336      char *to;
 337 {
 338   for(; count > 8; count -= 8, to++, offset += 8)
 339     *to = bit_extract (buffer, offset, 8);
 340   *to = bit_extract (buffer, offset, count);
 341 }
 342
 343
 344 static int
 345 sign_extend (value, bits)
 346      int value, bits;
 347 {
 348   value = value & ((1 << bits) - 1);
 349   return (value & (1 << (bits-1))
 350           ? value | (~((1 << bits) - 1))
 351           : value);
 352 }
 353
 354 static void
 355 flip_bytes (ptr, count)
 356      char *ptr;
 357      int count;
 358 {
 359   char tmp;
 360
 361   while (count > 0)
 362     {
 363       tmp = ptr[0];
 364       ptr[0] = ptr[count-1];
 365       ptr[count-1] = tmp;
 366       ptr++;
 367       count -= 2;
 368     }
 369 }
 370 \f
 371 /* Given a character C, does it represent a general addressing mode?  */
 372 #define Is_gen(c) \
 373   ((c) == 'F' || (c) == 'L' || (c) == 'B' \
 374    || (c) == 'W' || (c) == 'D' || (c) == 'A' || (c) == 'I' || (c) == 'Z')
 375
 376 /* Adressing modes.  */
 377 #define Adrmod_index_byte 0x1c
 378 #define Adrmod_index_word 0x1d
 379 #define Adrmod_index_doubleword 0x1e
 380 #define Adrmod_index_quadword 0x1f
 381
 382 /* Is MODE an indexed addressing mode?  */
 383 #define Adrmod_is_index(mode) \
 384   (mode == Adrmod_index_byte \
 385    || mode == Adrmod_index_word \
 386    || mode == Adrmod_index_doubleword \
 387    || mode == Adrmod_index_quadword)
 388
 389 \f
 390 /* Print the 32000 instruction at address MEMADDR in debugged memory,
 391    on STREAM.  Returns length of the instruction, in bytes.  */
 392
 393 int
 394 print_insn_ns32k (memaddr, info)
 395      bfd_vma memaddr;
 396      disassemble_info *info;
 397 {
 398   register unsigned int i;
 399   register char *d;
 400   unsigned short first_word;
 401   int ioffset;          /* bits into instruction */
 402   int aoffset;          /* bits into arguments */
 403   char arg_bufs[MAX_ARGS+1][ARG_LEN];
 404   int argnum;
 405   int maxarg;
 406   struct private priv;
 407   bfd_byte *buffer = priv.the_buffer;
 408   dis_info = info;
 409
 410   info->private_data = (PTR) &priv;
 411   priv.max_fetched = priv.the_buffer;
 412   priv.insn_start = memaddr;
 413   if (setjmp (priv.bailout) != 0)
 414     /* Error return.  */
 415     return -1;
 416
 417   /* Look for 8bit opcodes first. Other wise, fetching two bytes could take
 418    * us over the end of accessible data unnecessarilly
 419    */
 420   FETCH_DATA(info, buffer + 1);
 421   for (i = 0; i < NOPCODES; i++)
 422     if (ns32k_opcodes[i].opcode_id_size <= 8
 423         && ((buffer[0]
 424              & (((unsigned long) 1 << ns32k_opcodes[i].opcode_id_size) - 1))
 425             == ns32k_opcodes[i].opcode_seed))
 426       break;
 427   if (i == NOPCODES) {
 428     /* Maybe it is 9 to 16 bits big */
 429     FETCH_DATA(info, buffer + 2);
 430     first_word = read_memory_integer(buffer, 2);
 431
 432     for (i = 0; i < NOPCODES; i++)
 433       if ((first_word
 434            & (((unsigned long) 1 << ns32k_opcodes[i].opcode_id_size) - 1))
 435           == ns32k_opcodes[i].opcode_seed)
 436         break;
 437
 438     /* Handle undefined instructions.  */
 439     if (i == NOPCODES)
 440       {
 441         (*dis_info->fprintf_func)(dis_info->stream, "0%o", buffer[0]);
 442         return 1;
 443       }
 444   }
 445
 446   (*dis_info->fprintf_func)(dis_info->stream, "%s", ns32k_opcodes[i].name);
 447
 448   ioffset = ns32k_opcodes[i].opcode_size;
 449   aoffset = ns32k_opcodes[i].opcode_size;
 450   d = ns32k_opcodes[i].operands;
 451
 452   if (*d)
 453     {
 454       /* Offset in bits of the first thing beyond each index byte.
 455          Element 0 is for operand A and element 1 is for operand B.
 456          The rest are irrelevant, but we put them here so we don't
 457          index outside the array.  */
 458       int index_offset[MAX_ARGS];
 459
 460       /* 0 for operand A, 1 for operand B, greater for other args.  */
 461       int whicharg = 0;
 462
 463       (*dis_info->fprintf_func)(dis_info->stream, "\t");
 464
 465       maxarg = 0;
 466
 467       /* First we have to find and keep track of the index bytes,
 468          if we are using scaled indexed addressing mode, since the index
 469          bytes occur right after the basic instruction, not as part
 470          of the addressing extension.  */
 471       if (Is_gen(d[1]))
 472         {
 473           int addr_mode = bit_extract (buffer, ioffset - 5, 5);
 474
 475           if (Adrmod_is_index (addr_mode))
 476             {
 477               aoffset += 8;
 478               index_offset[0] = aoffset;
 479             }
 480         }
 481       if (d[2] && Is_gen(d[3]))
 482         {
 483           int addr_mode = bit_extract (buffer, ioffset - 10, 5);
 484
 485           if (Adrmod_is_index (addr_mode))
 486             {
 487               aoffset += 8;
 488               index_offset[1] = aoffset;
 489             }
 490         }
 491
 492       while (*d)
 493         {
 494           argnum = *d - '1';
 495           d++;
 496           if (argnum > maxarg && argnum < MAX_ARGS)
 497             maxarg = argnum;
 498           ioffset = print_insn_arg (*d, ioffset, &aoffset, buffer,
 499                                     memaddr, arg_bufs[argnum],
 500                                     index_offset[whicharg]);
 501           d++;
 502           whicharg++;
 503         }
 504       for (argnum = 0; argnum <= maxarg; argnum++)
 505         {
 506           bfd_vma addr;
 507           char *ch;
 508           for (ch = arg_bufs[argnum]; *ch;)
 509             {
 510               if (*ch == NEXT_IS_ADDR)
 511                 {
 512                   ++ch;
 513                   addr = bfd_scan_vma (ch, NULL, 16);
 514                   (*dis_info->print_address_func) (addr, dis_info);
 515                   while (*ch && *ch != NEXT_IS_ADDR)
 516                     ++ch;
 517                   if (*ch)
 518                     ++ch;
 519                 }
 520               else
 521                 (*dis_info->fprintf_func)(dis_info->stream, "%c", *ch++);
 522             }
 523           if (argnum < maxarg)
 524             (*dis_info->fprintf_func)(dis_info->stream, ", ");
 525         }
 526     }
 527   return aoffset / 8;
 528 }
 529
 530 /* Print an instruction operand of category given by d.  IOFFSET is
 531    the bit position below which small (<1 byte) parts of the operand can
 532    be found (usually in the basic instruction, but for indexed
 533    addressing it can be in the index byte).  AOFFSETP is a pointer to the
 534    bit position of the addressing extension.  BUFFER contains the
 535    instruction.  ADDR is where BUFFER was read from.  Put the disassembled
 536    version of the operand in RESULT.  INDEX_OFFSET is the bit position
 537    of the index byte (it contains garbage if this operand is not a
 538    general operand using scaled indexed addressing mode).  */
 539
 540 static int
 541 print_insn_arg (d, ioffset, aoffsetp, buffer, addr, result, index_offset)
 542      int d;
 543      int ioffset, *aoffsetp;
 544      char *buffer;
 545      bfd_vma addr;
 546      char *result;
 547      int index_offset;
 548 {
 549   int addr_mode;
 550   float Fvalue;
 551   double Lvalue;
 552   int Ivalue;
 553   int disp1, disp2;
 554   int index;
 555   int size;
 556
 557   switch (d)
 558     {
 559     case 'f':
 560       /* a "gen" operand but 5 bits from the end of instruction */
 561       ioffset -= 5;
 562     case 'Z':
 563     case 'F':
 564     case 'L':
 565     case 'I':
 566     case 'B':
 567     case 'W':
 568     case 'D':
 569     case 'A':
 570       addr_mode = bit_extract (buffer, ioffset-5, 5);
 571       ioffset -= 5;
 572       switch (addr_mode)
 573         {
 574         case 0x0: case 0x1: case 0x2: case 0x3:
 575         case 0x4: case 0x5: case 0x6: case 0x7:
 576           /* register mode R0 -- R7 */
 577           switch (d)
 578             {
 579             case 'F':
 580             case 'L':
 581             case 'Z':
 582               sprintf (result, "f%d", addr_mode);
 583               break;
 584             default:
 585               sprintf (result, "r%d", addr_mode);
 586             }
 587           break;
 588         case 0x8: case 0x9: case 0xa: case 0xb:
 589         case 0xc: case 0xd: case 0xe: case 0xf:
 590           /* Register relative disp(R0 -- R7) */
 591           disp1 = get_displacement (buffer, aoffsetp);
 592           sprintf (result, "%d(r%d)", disp1, addr_mode & 7);
 593           break;
 594         case 0x10:
 595         case 0x11:
 596         case 0x12:
 597           /* Memory relative disp2(disp1(FP, SP, SB)) */
 598           disp1 = get_displacement (buffer, aoffsetp);
 599           disp2 = get_displacement (buffer, aoffsetp);
 600           sprintf (result, "%d(%d(%s))", disp2, disp1,
 601                    addr_mode==0x10?"fp":addr_mode==0x11?"sp":"sb");
 602           break;
 603         case 0x13:
 604           /* reserved */
 605           sprintf (result, "reserved");
 606           break;
 607         case 0x14:
 608           /* Immediate */
 609           switch (d)
 610             {
 611             case 'I': case 'Z': case 'A':
 612               /* I and Z are output operands and can`t be immediate
 613                * A is an address and we can`t have the address of
 614                * an immediate either. We don't know how much to increase
 615                * aoffsetp by since whatever generated this is broken
 616                * anyway!
 617                */
 618               sprintf (result, _("$<undefined>"));
 619               break;
 620             case 'B':
 621               Ivalue = bit_extract (buffer, *aoffsetp, 8);
 622               Ivalue = sign_extend (Ivalue, 8);
 623               *aoffsetp += 8;
 624               sprintf (result, "$%d", Ivalue);
 625               break;
 626             case 'W':
 627               Ivalue = bit_extract (buffer, *aoffsetp, 16);
 628               flip_bytes (&Ivalue, 2);
 629               *aoffsetp += 16;
 630               Ivalue = sign_extend (Ivalue, 16);
 631               sprintf (result, "$%d", Ivalue);
 632               break;
 633             case 'D':
 634               Ivalue = bit_extract (buffer, *aoffsetp, 32);
 635               flip_bytes (&Ivalue, 4);
 636               *aoffsetp += 32;
 637               sprintf (result, "$%d", Ivalue);
 638               break;
 639             case 'F':
 640               bit_copy (buffer, *aoffsetp, 32, (char *) &Fvalue);
 641               flip_bytes (&Fvalue, 4);
 642               *aoffsetp += 32;
 643               if (INVALID_FLOAT (&Fvalue, 4))
 644                 sprintf (result, "<<invalid float 0x%.8x>>", *(int *) &Fvalue);
 645               else /* assume host has ieee float */
 646                 sprintf (result, "$%g", Fvalue);
 647               break;
 648             case 'L':
 649               bit_copy (buffer, *aoffsetp, 64, (char *) &Lvalue);
 650               flip_bytes (&Lvalue, 8);
 651               *aoffsetp += 64;
 652               if (INVALID_FLOAT (&Lvalue, 8))
 653                 sprintf (result, "<<invalid long 0x%.8x%.8x>>",
 654                          *(((int *) &Lvalue) + 1), *(int *) &Lvalue);
 655               else /* assume host has ieee float */
 656                 sprintf (result, "$%g", Lvalue);
 657               break;
 658             }
 659           break;
 660         case 0x15:
 661           /* Absolute @disp */
 662           disp1 = get_displacement (buffer, aoffsetp);
 663           sprintf (result, "@|%d|", disp1);
 664           break;
 665         case 0x16:
 666           /* External EXT(disp1) + disp2 (Mod table stuff) */
 667           disp1 = get_displacement (buffer, aoffsetp);
 668           disp2 = get_displacement (buffer, aoffsetp);
 669           sprintf (result, "EXT(%d) + %d", disp1, disp2);
 670           break;
 671         case 0x17:
 672           /* Top of stack tos */
 673           sprintf (result, "tos");
 674           break;
 675         case 0x18:
 676           /* Memory space disp(FP) */
 677           disp1 = get_displacement (buffer, aoffsetp);
 678           sprintf (result, "%d(fp)", disp1);
 679           break;
 680         case 0x19:
 681           /* Memory space disp(SP) */
 682           disp1 = get_displacement (buffer, aoffsetp);
 683           sprintf (result, "%d(sp)", disp1);
 684           break;
 685         case 0x1a:
 686           /* Memory space disp(SB) */
 687           disp1 = get_displacement (buffer, aoffsetp);
 688           sprintf (result, "%d(sb)", disp1);
 689           break;
 690         case 0x1b:
 691           /* Memory space disp(PC) */
 692           disp1 = get_displacement (buffer, aoffsetp);
 693           *result++ = NEXT_IS_ADDR;
 694           sprintf_vma (result, addr + disp1);
 695           result += strlen (result);
 696           *result++ = NEXT_IS_ADDR;
 697           *result = '\0';
 698           break;
 699         case 0x1c:
 700         case 0x1d:
 701         case 0x1e:
 702         case 0x1f:
 703           /* Scaled index basemode[R0 -- R7:B,W,D,Q] */
 704           index = bit_extract (buffer, index_offset - 8, 3);
 705           print_insn_arg (d, index_offset, aoffsetp, buffer, addr,
 706                           result, 0);
 707           {
 708             static const char *ind = "bwdq";
 709             char *off;
 710
 711             off = result + strlen (result);
 712             sprintf (off, "[r%d:%c]", index,
 713                      ind[addr_mode & 3]);
 714           }
 715           break;
 716         }
 717       break;
 718     case 'H':
 719     case 'q':
 720       Ivalue = bit_extract (buffer, ioffset-4, 4);
 721       Ivalue = sign_extend (Ivalue, 4);
 722       sprintf (result, "%d", Ivalue);
 723       ioffset -= 4;
 724       break;
 725     case 'r':
 726       Ivalue = bit_extract (buffer, ioffset-3, 3);
 727       sprintf (result, "r%d", Ivalue&7);
 728       ioffset -= 3;
 729       break;
 730     case 'd':
 731       sprintf (result, "%d", get_displacement (buffer, aoffsetp));
 732       break;
 733     case 'b':
 734       Ivalue = get_displacement (buffer, aoffsetp);
 735       /*
 736        * Warning!!  HACK ALERT!
 737        * Operand type 'b' is only used by the cmp{b,w,d} and
 738        * movm{b,w,d} instructions; we need to know whether
 739        * it's a `b' or `w' or `d' instruction; and for both
 740        * cmpm and movm it's stored at the same place so we
 741        * just grab two bits of the opcode and look at it...
 742        *
 743        */
 744       size = bit_extract(buffer, ioffset-6, 2);
 745       if (size == 0)            /* 00 => b */
 746         size = 1;
 747       else if (size == 1)       /* 01 => w */
 748         size = 2;
 749       else
 750         size = 4;               /* 11 => d */
 751
 752       sprintf (result, "%d", (Ivalue / size) + 1);
 753       break;
 754     case 'p':
 755       *result++ = NEXT_IS_ADDR;
 756       sprintf_vma (result, addr + get_displacement (buffer, aoffsetp));
 757       result += strlen (result);
 758       *result++ = NEXT_IS_ADDR;
 759       *result = '\0';
 760       break;
 761     case 'i':
 762       Ivalue = bit_extract (buffer, *aoffsetp, 8);
 763       *aoffsetp += 8;
 764       sprintf (result, "0x%x", Ivalue);
 765       break;
 766     case 'u':
 767       Ivalue = bit_extract (buffer, *aoffsetp, 8);
 768       optlist(Ivalue, opt_u, result);
 769       *aoffsetp += 8;
 770       break;
 771     case 'U':
 772       Ivalue = bit_extract(buffer, *aoffsetp, 8);
 773       optlist(Ivalue, opt_U, result);
 774       *aoffsetp += 8;
 775       break;
 776     case 'O':
 777       Ivalue = bit_extract(buffer, ioffset-9, 9);
 778       optlist(Ivalue, opt_O, result);
 779       ioffset -= 9;
 780       break;
 781     case 'C':
 782       Ivalue = bit_extract(buffer, ioffset-4, 4);
 783       optlist(Ivalue, opt_C, result);
 784       ioffset -= 4;
 785       break;
 786     case 'S':
 787       Ivalue = bit_extract(buffer, ioffset - 8, 8);
 788       optlist(Ivalue, opt_S, result);
 789       ioffset -= 8;
 790       break;
 791     case 'M':
 792       Ivalue = bit_extract(buffer, ioffset-4, 4);
 793       list_search(Ivalue, 0 ? list_M032 : list_M532, result);
 794       ioffset -= 4;
 795       break;
 796     case 'P':
 797       Ivalue = bit_extract(buffer, ioffset-4, 4);
 798       list_search(Ivalue, 0 ? list_P032 : list_P532, result);
 799       ioffset -= 4;
 800       break;
 801     case 'g':
 802       Ivalue = bit_extract(buffer, *aoffsetp, 3);
 803       sprintf(result, "%d", Ivalue);
 804       *aoffsetp += 3;
 805       break;
 806     case 'G':
 807       Ivalue = bit_extract(buffer, *aoffsetp, 5);
 808       sprintf(result, "%d", Ivalue + 1);
 809       *aoffsetp += 5;
 810       break;
 811     }
 812   return ioffset;
 813 }
 814
 815 static int
 816 get_displacement (buffer, aoffsetp)
 817      char *buffer;
 818      int *aoffsetp;
 819 {
 820   int Ivalue;
 821   short Ivalue2;
 822
 823   Ivalue = bit_extract (buffer, *aoffsetp, 8);
 824   switch (Ivalue & 0xc0)
 825     {
 826     case 0x00:
 827     case 0x40:
 828       Ivalue = sign_extend (Ivalue, 7);
 829       *aoffsetp += 8;
 830       break;
 831     case 0x80:
 832       Ivalue2 = bit_extract (buffer, *aoffsetp, 16);
 833       flip_bytes (&Ivalue2, 2);
 834       Ivalue = sign_extend (Ivalue2, 14);
 835       *aoffsetp += 16;
 836       break;
 837     case 0xc0:
 838       Ivalue = bit_extract (buffer, *aoffsetp, 32);
 839       flip_bytes (&Ivalue, 4);
 840       Ivalue = sign_extend (Ivalue, 30);
 841       *aoffsetp += 32;
 842       break;
 843     }
 844   return Ivalue;
 845 }
 846 \f
 847
 848 #if 1 /* a version that should work on ns32k f's&d's on any machine */
 849 static int
 850 invalid_float (p, len)
 851      register char *p;
 852      register int len;
 853 {
 854   register int val;
 855
 856   if ( len == 4 )
 857     val = (bit_extract_simple(p, 23, 8)/*exponent*/ == 0xff
 858            || (bit_extract_simple(p, 23, 8)/*exponent*/ == 0 &&
 859                bit_extract_simple(p, 0, 23)/*mantisa*/ != 0));
 860   else if ( len == 8 )
 861     val = (bit_extract_simple(p, 52, 11)/*exponent*/ == 0x7ff
 862            || (bit_extract_simple(p, 52, 11)/*exponent*/ == 0
 863                && (bit_extract_simple(p, 0, 32)/*low mantisa*/ != 0
 864                    || bit_extract_simple(p, 32, 20)/*high mantisa*/ != 0)));
 865   else
 866     val = 1;
 867   return (val);
 868 }
 869 #else
 870
 871 /* assumes the bytes have been swapped to local order */
 872 typedef union { double d;
 873                 float f;
 874                 struct { unsigned m:23, e:8, :1;} sf;
 875                 struct { unsigned lm; unsigned m:20, e:11, :1;} sd;
 876               } float_type_u;
 877
 878 static int
 879 invalid_float (p, len)
 880      register float_type_u *p;
 881      register int len;
 882 {
 883   register int val;
 884   if ( len == sizeof (float) )
 885     val = (p->sf.e == 0xff
 886            || (p->sf.e == 0 && p->sf.m != 0));
 887   else if ( len == sizeof (double) )
 888     val = (p->sd.e == 0x7ff
 889            || (p->sd.e == 0 && (p->sd.m != 0 || p->sd.lm != 0)));
 890   else
 891     val = 1;
 892   return (val);
 893 }
 894 #endif