opcodes/z8k-dis.c

   1 /*
   2 This file is part of GNU Binutils.
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 #include <ansidecl.h>
  19 #include "sysdep.h"
  20 #include "dis-asm.h"
  21
  22 #define DEFINE_TABLE
  23 #include "z8k-opc.h"
  24
  25 \f
  26 #include <setjmp.h>
  27
  28 \f
  29 typedef struct
  30 {
  31   /* These are all indexed by nibble number (i.e only every other entry
  32      of bytes is used, and every 4th entry of words).  */
  33   unsigned char nibbles[24];
  34   unsigned char bytes[24];
  35   unsigned short words[24];
  36
  37   /* Nibble number of first word not yet fetched.  */
  38   int max_fetched;
  39   bfd_vma insn_start;
  40   jmp_buf bailout;
  41
  42   long tabl_index;
  43   char instr_asmsrc[80];
  44   unsigned long arg_reg[0x0f];
  45   unsigned long immediate;
  46   unsigned long displacement;
  47   unsigned long address;
  48   unsigned long cond_code;
  49   unsigned long ctrl_code;
  50   unsigned long flags;
  51   unsigned long interrupts;
  52 }
  53 instr_data_s;
  54
  55 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
  56    to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
  57    on error.  */
  58 #define FETCH_DATA(info, nibble) \
  59   ((nibble) <= ((instr_data_s *)(info->private_data))->max_fetched \
  60    ? 1 : fetch_data ((info), (nibble)))
  61
  62 static int
  63 fetch_data (info, nibble)
  64      struct disassemble_info *info;
  65      int nibble;
  66 {
  67   unsigned char mybuf[20];
  68   int status;
  69   instr_data_s *priv = (instr_data_s *)info->private_data;
  70   bfd_vma start = priv->insn_start + priv->max_fetched / 2;
  71
  72   if ((nibble % 4) != 0)
  73     abort ();
  74   status = (*info->read_memory_func) (start,
  75                                       (bfd_byte *) mybuf,
  76                                       (nibble - priv->max_fetched) / 2,
  77                                       info);
  78   if (status != 0)
  79     {
  80       (*info->memory_error_func) (status, start, info);
  81       longjmp (priv->bailout, 1);
  82     }
  83
  84   {
  85     int i;
  86     char *p = mybuf + priv->max_fetched / 2;
  87
  88     for (i = priv->max_fetched; i < nibble;)
  89       {
  90         priv->words[i] = (p[0] << 8) | p[1];
  91
  92         priv->bytes[i] = *p;
  93         priv->nibbles[i++] = *p >> 4;
  94         priv->nibbles[i++] = *p &0xf;
  95
  96         ++p;
  97         priv->bytes[i] = *p;
  98         priv->nibbles[i++] = *p >> 4;
  99         priv->nibbles[i++] = *p & 0xf;
 100
 101         ++p;
 102       }
 103   }
 104   priv->max_fetched = nibble;
 105   return 1;
 106 }
 107
 108 static char *codes[16] =
 109 {
 110   "f",
 111   "lt",
 112   "le",
 113   "ule",
 114   "ov/pe",
 115   "mi",
 116   "eq",
 117   "c/ult",
 118   "t",
 119   "ge",
 120   "gt",
 121   "ugt",
 122   "nov/po",
 123   "pl",
 124   "ne",
 125   "nc/uge"
 126 };
 127
 128 int z8k_lookup_instr PARAMS ((unsigned char*, disassemble_info *));
 129 static void output_instr
 130   PARAMS ((instr_data_s *, unsigned long, disassemble_info *));
 131 static void unpack_instr PARAMS ((instr_data_s *, int, disassemble_info *));
 132 static void unparse_instr PARAMS ((instr_data_s *));
 133
 134 static int
 135 print_insn_z8k (addr, info, is_segmented)
 136      unsigned long addr;
 137      disassemble_info *info;
 138      int is_segmented;
 139 {
 140   instr_data_s instr_data;
 141
 142   info->private_data = (PTR) &instr_data;
 143   instr_data.max_fetched = 0;
 144   instr_data.insn_start = addr;
 145   if (setjmp (instr_data.bailout) != 0)
 146     /* Error return.  */
 147     return -1;
 148
 149   instr_data.tabl_index = z8k_lookup_instr (instr_data.nibbles, info);
 150   if (instr_data.tabl_index > 0)
 151     {
 152       unpack_instr (&instr_data, is_segmented, info);
 153       unparse_instr (&instr_data);
 154       output_instr (&instr_data, addr, info);
 155       return z8k_table[instr_data.tabl_index].length;
 156     }
 157   else
 158     {
 159       FETCH_DATA (info, 4);
 160       (*info->fprintf_func) (info->stream, ".word %02x%02x",
 161                              instr_data.bytes[0], instr_data.bytes[2]);
 162       return 2;
 163     }
 164 }
 165
 166 print_insn_z8001 (addr, info)
 167      unsigned long addr;
 168      disassemble_info *info;
 169 {
 170   return print_insn_z8k (addr, info, 1);
 171 }
 172
 173 print_insn_z8002 (addr, info)
 174      unsigned long addr;
 175      disassemble_info *info;
 176 {
 177   return print_insn_z8k (addr, info, 0);
 178 }
 179
 180 int
 181 z8k_lookup_instr (nibbles, info)
 182      unsigned char *nibbles;
 183      disassemble_info *info;
 184 {
 185
 186   int nibl_index, tabl_index;
 187   int nibl_matched;
 188   unsigned short instr_nibl;
 189   unsigned short tabl_datum, datum_class, datum_value;
 190
 191   nibl_matched = 0;
 192   tabl_index = 0;
 193   while (!nibl_matched && z8k_table[tabl_index].name)
 194     {
 195       nibl_matched = 1;
 196       for (nibl_index = 0; nibl_index < z8k_table[tabl_index].length * 2 && nibl_matched; nibl_index++)
 197         {
 198           if ((nibl_index % 4) == 0)
 199             /* Fetch one word at a time.  */
 200             FETCH_DATA (info, nibl_index + 4);
 201           instr_nibl = nibbles[nibl_index];
 202
 203           tabl_datum = z8k_table[tabl_index].byte_info[nibl_index];
 204           datum_class = tabl_datum & CLASS_MASK;
 205           datum_value = ~CLASS_MASK & tabl_datum;
 206
 207           switch (datum_class)
 208             {
 209             case CLASS_BIT:
 210               if (datum_value != instr_nibl)
 211                 nibl_matched = 0;
 212               break;
 213             case CLASS_00II:
 214               if (!((~instr_nibl) & 0x4))
 215                 nibl_matched = 0;
 216               break;
 217             case CLASS_01II:
 218               if (!(instr_nibl & 0x4))
 219                 nibl_matched = 0;
 220               break;
 221             case CLASS_0CCC:
 222               if (!((~instr_nibl) & 0x8))
 223                 nibl_matched = 0;
 224               break;
 225             case CLASS_1CCC:
 226               if (!(instr_nibl & 0x8))
 227                 nibl_matched = 0;
 228               break;
 229             case CLASS_0DISP7:
 230               if (!((~instr_nibl) & 0x8))
 231                 nibl_matched = 0;
 232               nibl_index += 1;
 233               break;
 234             case CLASS_1DISP7:
 235               if (!(instr_nibl & 0x8))
 236                 nibl_matched = 0;
 237               nibl_index += 1;
 238               break;
 239             case CLASS_REGN0:
 240               if (instr_nibl == 0)
 241                 nibl_matched = 0;
 242               break;
 243             case CLASS_BIT_1OR2:
 244               if ((instr_nibl | 0x2) != (datum_value | 0x2))
 245                 nibl_matched = 0;
 246               break;
 247             default:
 248               break;
 249             }
 250         }
 251       if (nibl_matched)
 252         {
 253           return tabl_index;
 254         }
 255
 256       tabl_index++;
 257     }
 258   return -1;
 259
 260 }
 261
 262 static void
 263 output_instr (instr_data, addr, info)
 264      instr_data_s *instr_data;
 265      unsigned long addr;
 266      disassemble_info *info;
 267 {
 268   int loop, loop_limit;
 269   char tmp_str[20];
 270   char out_str[100];
 271
 272   strcpy (out_str, "\t");
 273
 274   loop_limit = z8k_table[instr_data->tabl_index].length * 2;
 275   FETCH_DATA (info, loop_limit);
 276   for (loop = 0; loop < loop_limit; loop++)
 277     {
 278       sprintf (tmp_str, "%x", instr_data->nibbles[loop]);
 279       strcat (out_str, tmp_str);
 280     }
 281
 282   while (loop++ < 8)
 283     {
 284       strcat (out_str, " ");
 285     }
 286
 287   strcat (out_str, instr_data->instr_asmsrc);
 288
 289   (*info->fprintf_func) (info->stream, "%s", out_str);
 290 }
 291
 292 static void
 293 unpack_instr (instr_data, is_segmented, info)
 294      instr_data_s *instr_data;
 295      int is_segmented;
 296      disassemble_info *info;
 297 {
 298   int nibl_count, loop;
 299   unsigned short instr_nibl, instr_byte, instr_word;
 300   long instr_long;
 301   unsigned short tabl_datum, datum_class, datum_value;
 302
 303   nibl_count = 0;
 304   loop = 0;
 305   while (z8k_table[instr_data->tabl_index].byte_info[loop] != 0)
 306     {
 307       FETCH_DATA (info, nibl_count + 4 - (nibl_count % 4));
 308       instr_nibl = instr_data->nibbles[nibl_count];
 309       instr_byte = instr_data->bytes[nibl_count];
 310       instr_word = instr_data->words[nibl_count];
 311
 312       tabl_datum = z8k_table[instr_data->tabl_index].byte_info[loop];
 313       datum_class = tabl_datum & CLASS_MASK;
 314       datum_value = tabl_datum & ~CLASS_MASK;
 315
 316       switch (datum_class)
 317         {
 318         case CLASS_X:
 319           instr_data->address = instr_nibl;
 320           break;
 321         case CLASS_BA:
 322           instr_data->displacement = instr_nibl;
 323           break;
 324         case CLASS_BX:
 325           instr_data->arg_reg[datum_value] = instr_nibl;
 326           break;
 327         case CLASS_DISP:
 328           switch (datum_value)
 329             {
 330             case ARG_DISP16:
 331               instr_data->displacement = instr_word;
 332               nibl_count += 3;
 333               break;
 334             case ARG_DISP12:
 335               instr_data->displacement = instr_word & 0x0fff;
 336               nibl_count += 2;
 337               break;
 338             default:
 339               break;
 340             }
 341           break;
 342         case CLASS_IMM:
 343           switch (datum_value)
 344             {
 345             case ARG_IMM4:
 346               instr_data->immediate = instr_nibl;
 347               break;
 348             case ARG_NIM8:
 349               instr_data->immediate = (-instr_byte);
 350               nibl_count += 1;
 351               break;
 352             case ARG_IMM8:
 353               instr_data->immediate = instr_byte;
 354               nibl_count += 1;
 355               break;
 356             case ARG_IMM16:
 357               instr_data->immediate = instr_word;
 358               nibl_count += 3;
 359               break;
 360             case ARG_IMM32:
 361               FETCH_DATA (info, nibl_count + 8);
 362               instr_long = (instr_data->words[nibl_count] << 16)
 363                 | (instr_data->words[nibl_count + 4]);
 364               instr_data->immediate = instr_long;
 365               nibl_count += 7;
 366               break;
 367             case ARG_IMMN:
 368               instr_data->immediate = instr_nibl - 1;
 369               break;
 370               /* ????? */
 371               /* missing ARG_IMMNMINUS1 */
 372             case ARG_IMM_1:
 373               instr_data->immediate = 1;
 374               break;
 375             case ARG_IMM_2:
 376               instr_data->immediate = 2;
 377               break;
 378             case ARG_IMM2:
 379               instr_data->immediate = instr_nibl & 0x3;
 380               break;
 381             default:
 382               break;
 383             }
 384           break;
 385         case CLASS_CC:
 386           instr_data->cond_code = instr_nibl;
 387           break;
 388         case CLASS_CTRL:
 389           instr_data->ctrl_code = instr_nibl;
 390           break;
 391         case CLASS_DA:
 392         case CLASS_ADDRESS:
 393           if (is_segmented)
 394             {
 395               if (instr_nibl & 0x8)
 396                 {
 397                   FETCH_DATA (info, nibl_count + 8);
 398                   instr_long = (instr_data->words[nibl_count] << 16)
 399                     | (instr_data->words[nibl_count + 4]);
 400                   instr_data->address = ((instr_word & 0x7f00) << 8) +
 401                     (instr_long & 0xffff);
 402                   nibl_count += 7;
 403                 }
 404               else
 405                 {
 406                   instr_data->address = ((instr_word & 0x7f00) << 8) +
 407                     (instr_word & 0x00ff);
 408                   nibl_count += 3;
 409                 }
 410             }
 411           else
 412             {
 413               instr_data->address = instr_word;
 414               nibl_count += 3;
 415             }
 416           break;
 417         case CLASS_0CCC:
 418           instr_data->cond_code = instr_nibl & 0x7;
 419           break;
 420         case CLASS_1CCC:
 421           instr_data->cond_code = instr_nibl & 0x7;
 422           break;
 423         case CLASS_0DISP7:
 424           instr_data->displacement = instr_byte & 0x7f;
 425           nibl_count += 1;
 426           break;
 427         case CLASS_1DISP7:
 428           instr_data->displacement = instr_byte & 0x7f;
 429           nibl_count += 1;
 430           break;
 431         case CLASS_01II:
 432           instr_data->interrupts = instr_nibl & 0x3;
 433           break;
 434         case CLASS_00II:
 435           instr_data->interrupts = instr_nibl & 0x3;
 436           break;
 437         case CLASS_BIT:
 438           /* do nothing */
 439           break;
 440         case CLASS_IR:
 441           instr_data->arg_reg[datum_value] = instr_nibl;
 442           break;
 443         case CLASS_FLAGS:
 444           instr_data->flags = instr_nibl;
 445           break;
 446         case CLASS_REG:
 447           instr_data->arg_reg[datum_value] = instr_nibl;
 448           break;
 449         case CLASS_REG_BYTE:
 450           instr_data->arg_reg[datum_value] = instr_nibl;
 451           break;
 452         case CLASS_REG_WORD:
 453           instr_data->arg_reg[datum_value] = instr_nibl;
 454           break;
 455         case CLASS_REG_QUAD:
 456           instr_data->arg_reg[datum_value] = instr_nibl;
 457           break;
 458         case CLASS_REG_LONG:
 459           instr_data->arg_reg[datum_value] = instr_nibl;
 460           break;
 461         case CLASS_REGN0:
 462           instr_data->arg_reg[datum_value] = instr_nibl;
 463           break;
 464         default:
 465           break;
 466         }
 467
 468       loop += 1;
 469       nibl_count += 1;
 470     }
 471 }
 472
 473 static void
 474 unparse_instr (instr_data)
 475      instr_data_s *instr_data;
 476 {
 477   unsigned short tabl_datum, datum_class, datum_value;
 478   int loop, loop_limit;
 479   char out_str[80], tmp_str[25];
 480
 481   sprintf (out_str, "\t%s\t", z8k_table[instr_data->tabl_index].name);
 482
 483   loop_limit = z8k_table[instr_data->tabl_index].noperands;
 484   for (loop = 0; loop < loop_limit; loop++)
 485     {
 486       if (loop)
 487         strcat (out_str, ",");
 488
 489       tabl_datum = z8k_table[instr_data->tabl_index].arg_info[loop];
 490       datum_class = tabl_datum & CLASS_MASK;
 491       datum_value = tabl_datum & ~CLASS_MASK;
 492
 493       switch (datum_class)
 494         {
 495         case CLASS_X:
 496           sprintf (tmp_str, "0x%0x(R%d)", instr_data->address,
 497                    instr_data->arg_reg[datum_value]);
 498           strcat (out_str, tmp_str);
 499           break;
 500         case CLASS_BA:
 501           sprintf (tmp_str, "r%d(#%x)", instr_data->arg_reg[datum_value],
 502                    instr_data->immediate);
 503           strcat (out_str, tmp_str);
 504           break;
 505         case CLASS_BX:
 506           sprintf (tmp_str, "r%d(R%d)", instr_data->arg_reg[datum_value],
 507                    instr_data->arg_reg[ARG_RX]);
 508           strcat (out_str, tmp_str);
 509           break;
 510         case CLASS_DISP:
 511           sprintf (tmp_str, "#0x%0x", instr_data->displacement);
 512           strcat (out_str, tmp_str);
 513           break;
 514         case CLASS_IMM:
 515           sprintf (tmp_str, "#0x%0x", instr_data->immediate);
 516           strcat (out_str, tmp_str);
 517           break;
 518         case CLASS_CC:
 519           sprintf (tmp_str, "%s", codes[instr_data->cond_code]);
 520           strcat (out_str, tmp_str);
 521           break;
 522         case CLASS_CTRL:
 523           sprintf (tmp_str, "0x%0x", instr_data->ctrl_code);
 524           strcat (out_str, tmp_str);
 525           break;
 526         case CLASS_DA:
 527         case CLASS_ADDRESS:
 528           sprintf (tmp_str, "#0x%0x", instr_data->address);
 529           strcat (out_str, tmp_str);
 530           break;
 531         case CLASS_IR:
 532           sprintf (tmp_str, "@R%d", instr_data->arg_reg[datum_value]);
 533           strcat (out_str, tmp_str);
 534           break;
 535         case CLASS_FLAGS:
 536           sprintf (tmp_str, "0x%0x", instr_data->flags);
 537           strcat (out_str, tmp_str);
 538           break;
 539         case CLASS_REG_BYTE:
 540           if (instr_data->arg_reg[datum_value] >= 0x8)
 541             {
 542               sprintf (tmp_str, "rl%d",
 543                        instr_data->arg_reg[datum_value] - 0x8);
 544             }
 545           else
 546             {
 547               sprintf (tmp_str, "rh%d", instr_data->arg_reg[datum_value]);
 548             }
 549           strcat (out_str, tmp_str);
 550           break;
 551         case CLASS_REG_WORD:
 552           sprintf (tmp_str, "r%d", instr_data->arg_reg[datum_value]);
 553           strcat (out_str, tmp_str);
 554           break;
 555         case CLASS_REG_QUAD:
 556           sprintf (tmp_str, "rq%d", instr_data->arg_reg[datum_value]);
 557           strcat (out_str, tmp_str);
 558           break;
 559         case CLASS_REG_LONG:
 560           sprintf (tmp_str, "rr%d", instr_data->arg_reg[datum_value]);
 561           strcat (out_str, tmp_str);
 562           break;
 563         default:
 564           break;
 565         }
 566     }
 567
 568   strcpy (instr_data->instr_asmsrc, out_str);
 569 }