opcodes/ns32k-dis.c

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