opcodes/vax-dis.c

   1 /* Print VAX instructions.
   2    Copyright (C) 1995-2018 Free Software Foundation, Inc.
   3    Contributed by Pauline Middelink <middelin@polyware.iaf.nl>
   4
   5    This file is part of the GNU opcodes library.
   6
   7    This library is 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 3, or (at your option)
  10    any later version.
  11
  12    It is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include <setjmp.h>
  24 #include <string.h>
  25 #include "opcode/vax.h"
  26 #include "disassemble.h"
  27
  28 static char *reg_names[] =
  29 {
  30   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  31   "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc"
  32 };
  33
  34 /* Definitions for the function entry mask bits.  */
  35 static char *entry_mask_bit[] =
  36 {
  37   /* Registers 0 and 1 shall not be saved, since they're used to pass back
  38      a function's result to its caller...  */
  39   "~r0~", "~r1~",
  40   /* Registers 2 .. 11 are normal registers.  */
  41   "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11",
  42   /* Registers 12 and 13 are argument and frame pointer and must not
  43      be saved by using the entry mask.  */
  44   "~ap~", "~fp~",
  45   /* Bits 14 and 15 control integer and decimal overflow.  */
  46   "IntOvfl", "DecOvfl",
  47 };
  48
  49 /* Sign-extend an (unsigned char). */
  50 #define COERCE_SIGNED_CHAR(ch) ((signed char)(ch))
  51
  52 /* Get a 1 byte signed integer.  */
  53 #define NEXTBYTE(p)  \
  54   (p += 1, FETCH_DATA (info, p), \
  55   COERCE_SIGNED_CHAR(p[-1]))
  56
  57 /* Get a 2 byte signed integer.  */
  58 #define COERCE16(x) ((int) (((x) ^ 0x8000) - 0x8000))
  59 #define NEXTWORD(p)  \
  60   (p += 2, FETCH_DATA (info, p), \
  61    COERCE16 ((p[-1] << 8) + p[-2]))
  62
  63 /* Get a 4 byte signed integer.  */
  64 #define COERCE32(x) ((int) (((x) ^ 0x80000000) - 0x80000000))
  65 #define NEXTLONG(p)  \
  66   (p += 4, FETCH_DATA (info, p), \
  67    (COERCE32 ((((((p[-1] << 8) + p[-2]) << 8) + p[-3]) << 8) + p[-4])))
  68
  69 /* Maximum length of an instruction.  */
  70 #define MAXLEN 25
  71
  72 struct private
  73 {
  74   /* Points to first byte not fetched.  */
  75   bfd_byte * max_fetched;
  76   bfd_byte   the_buffer[MAXLEN];
  77   bfd_vma    insn_start;
  78   OPCODES_SIGJMP_BUF    bailout;
  79 };
  80
  81 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
  82    to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
  83    on error.  */
  84 #define FETCH_DATA(info, addr) \
  85   ((addr) <= ((struct private *)(info->private_data))->max_fetched \
  86    ? 1 : fetch_data ((info), (addr)))
  87
  88 static int
  89 fetch_data (struct disassemble_info *info, bfd_byte *addr)
  90 {
  91   int status;
  92   struct private *priv = (struct private *) info->private_data;
  93   bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
  94
  95   status = (*info->read_memory_func) (start,
  96                                       priv->max_fetched,
  97                                       addr - priv->max_fetched,
  98                                       info);
  99   if (status != 0)
 100     {
 101       (*info->memory_error_func) (status, start, info);
 102       OPCODES_SIGLONGJMP (priv->bailout, 1);
 103     }
 104   else
 105     priv->max_fetched = addr;
 106
 107   return 1;
 108 }
 109
 110 /* Entry mask handling.  */
 111 static unsigned int  entry_addr_occupied_slots = 0;
 112 static unsigned int  entry_addr_total_slots = 0;
 113 static bfd_vma *     entry_addr = NULL;
 114
 115 /* Parse the VAX specific disassembler options.  These contain function
 116    entry addresses, which can be useful to disassemble ROM images, since
 117    there's no symbol table.  Returns TRUE upon success, FALSE otherwise.  */
 118
 119 static bfd_boolean
 120 parse_disassembler_options (const char *options)
 121 {
 122   const char * entry_switch = "entry:";
 123
 124   while ((options = strstr (options, entry_switch)))
 125     {
 126       options += strlen (entry_switch);
 127
 128       /* The greater-than part of the test below is paranoia.  */
 129       if (entry_addr_occupied_slots >= entry_addr_total_slots)
 130         {
 131           /* A guesstimate of the number of entries we will have to create.  */
 132           entry_addr_total_slots +=
 133             strlen (options) / (strlen (entry_switch) + 5);
 134
 135           entry_addr = realloc (entry_addr, sizeof (bfd_vma)
 136                                 * entry_addr_total_slots);
 137         }
 138
 139       if (entry_addr == NULL)
 140         return FALSE;
 141
 142       entry_addr[entry_addr_occupied_slots] = bfd_scan_vma (options, NULL, 0);
 143       entry_addr_occupied_slots ++;
 144     }
 145
 146   return TRUE;
 147 }
 148
 149 #if 0 /* FIXME:  Ideally the disassembler should have target specific
 150          initialisation and termination function pointers.  Then
 151          parse_disassembler_options could be the init function and
 152          free_entry_array (below) could be the termination routine.
 153          Until then there is no way for the disassembler to tell us
 154          that it has finished and that we no longer need the entry
 155          array, so this routine is suppressed for now.  It does mean
 156          that we leak memory, but only to the extent that we do not
 157          free it just before the disassembler is about to terminate
 158          anyway.  */
 159
 160 /* Free memory allocated to our entry array.  */
 161
 162 static void
 163 free_entry_array (void)
 164 {
 165   if (entry_addr)
 166     {
 167       free (entry_addr);
 168       entry_addr = NULL;
 169       entry_addr_occupied_slots = entry_addr_total_slots = 0;
 170     }
 171 }
 172 #endif
 173 /* Check if the given address is a known function entry point.  This is
 174    the case if there is a symbol of the function type at this address.
 175    We also check for synthetic symbols as these are used for PLT entries
 176    (weak undefined symbols may not have the function type set).  Finally
 177    the address may have been forced to be treated as an entry point.  The
 178    latter helps in disassembling ROM images, because there's no symbol
 179    table at all.  Forced entry points can be given by supplying several
 180    -M options to objdump: -M entry:0xffbb7730.  */
 181
 182 static bfd_boolean
 183 is_function_entry (struct disassemble_info *info, bfd_vma addr)
 184 {
 185   unsigned int i;
 186
 187   /* Check if there's a function or PLT symbol at our address.  */
 188   if (info->symbols
 189       && info->symbols[0]
 190       && (info->symbols[0]->flags & (BSF_FUNCTION | BSF_SYNTHETIC))
 191       && addr == bfd_asymbol_value (info->symbols[0]))
 192     return TRUE;
 193
 194   /* Check for forced function entry address.  */
 195   for (i = entry_addr_occupied_slots; i--;)
 196     if (entry_addr[i] == addr)
 197       return TRUE;
 198
 199   return FALSE;
 200 }
 201
 202 /* Check if the given address is the last longword of a PLT entry.
 203    This longword is data and depending on the value it may interfere
 204    with disassembly of further PLT entries.  We make use of the fact
 205    PLT symbols are marked BSF_SYNTHETIC.  */
 206 static bfd_boolean
 207 is_plt_tail (struct disassemble_info *info, bfd_vma addr)
 208 {
 209   if (info->symbols
 210       && info->symbols[0]
 211       && (info->symbols[0]->flags & BSF_SYNTHETIC)
 212       && addr == bfd_asymbol_value (info->symbols[0]) + 8)
 213     return TRUE;
 214
 215   return FALSE;
 216 }
 217
 218 static int
 219 print_insn_mode (const char *d,
 220                  int size,
 221                  unsigned char *p0,
 222                  bfd_vma addr,  /* PC for this arg to be relative to.  */
 223                  disassemble_info *info)
 224 {
 225   unsigned char *p = p0;
 226   unsigned char mode, reg;
 227
 228   /* Fetch and interpret mode byte.  */
 229   mode = (unsigned char) NEXTBYTE (p);
 230   reg = mode & 0xF;
 231   switch (mode & 0xF0)
 232     {
 233     case 0x00:
 234     case 0x10:
 235     case 0x20:
 236     case 0x30: /* Literal mode                  $number.  */
 237       if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h')
 238         (*info->fprintf_func) (info->stream, "$0x%x [%c-float]", mode, d[1]);
 239       else
 240         (*info->fprintf_func) (info->stream, "$0x%x", mode);
 241       break;
 242     case 0x40: /* Index:                        base-addr[Rn] */
 243       p += print_insn_mode (d, size, p0 + 1, addr + 1, info);
 244       (*info->fprintf_func) (info->stream, "[%s]", reg_names[reg]);
 245       break;
 246     case 0x50: /* Register:                     Rn */
 247       (*info->fprintf_func) (info->stream, "%s", reg_names[reg]);
 248       break;
 249     case 0x60: /* Register deferred:            (Rn) */
 250       (*info->fprintf_func) (info->stream, "(%s)", reg_names[reg]);
 251       break;
 252     case 0x70: /* Autodecrement:                -(Rn) */
 253       (*info->fprintf_func) (info->stream, "-(%s)", reg_names[reg]);
 254       break;
 255     case 0x80: /* Autoincrement:                (Rn)+ */
 256       if (reg == 0xF)
 257         {       /* Immediate?  */
 258           int i;
 259
 260           FETCH_DATA (info, p + size);
 261           (*info->fprintf_func) (info->stream, "$0x");
 262           if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h')
 263             {
 264               int float_word;
 265
 266               float_word = p[0] | (p[1] << 8);
 267               if ((d[1] == 'd' || d[1] == 'f')
 268                   && (float_word & 0xff80) == 0x8000)
 269                 {
 270                   (*info->fprintf_func) (info->stream, "[invalid %c-float]",
 271                                          d[1]);
 272                 }
 273               else
 274                 {
 275                   for (i = 0; i < size; i++)
 276                     (*info->fprintf_func) (info->stream, "%02x",
 277                                            p[size - i - 1]);
 278                   (*info->fprintf_func) (info->stream, " [%c-float]", d[1]);
 279                 }
 280             }
 281           else
 282             {
 283               for (i = 0; i < size; i++)
 284                 (*info->fprintf_func) (info->stream, "%02x", p[size - i - 1]);
 285             }
 286           p += size;
 287         }
 288       else
 289         (*info->fprintf_func) (info->stream, "(%s)+", reg_names[reg]);
 290       break;
 291     case 0x90: /* Autoincrement deferred:       @(Rn)+ */
 292       if (reg == 0xF)
 293         (*info->fprintf_func) (info->stream, "*0x%x", NEXTLONG (p));
 294       else
 295         (*info->fprintf_func) (info->stream, "@(%s)+", reg_names[reg]);
 296       break;
 297     case 0xB0: /* Displacement byte deferred:   *displ(Rn).  */
 298       (*info->fprintf_func) (info->stream, "*");
 299       /* Fall through.  */
 300     case 0xA0: /* Displacement byte:            displ(Rn).  */
 301       if (reg == 0xF)
 302         (*info->print_address_func) (addr + 2 + NEXTBYTE (p), info);
 303       else
 304         (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTBYTE (p),
 305                                reg_names[reg]);
 306       break;
 307     case 0xD0: /* Displacement word deferred:   *displ(Rn).  */
 308       (*info->fprintf_func) (info->stream, "*");
 309       /* Fall through.  */
 310     case 0xC0: /* Displacement word:            displ(Rn).  */
 311       if (reg == 0xF)
 312         (*info->print_address_func) (addr + 3 + NEXTWORD (p), info);
 313       else
 314         (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTWORD (p),
 315                                reg_names[reg]);
 316       break;
 317     case 0xF0: /* Displacement long deferred:   *displ(Rn).  */
 318       (*info->fprintf_func) (info->stream, "*");
 319       /* Fall through.  */
 320     case 0xE0: /* Displacement long:            displ(Rn).  */
 321       if (reg == 0xF)
 322         (*info->print_address_func) (addr + 5 + NEXTLONG (p), info);
 323       else
 324         (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTLONG (p),
 325                                reg_names[reg]);
 326       break;
 327     }
 328
 329   return p - p0;
 330 }
 331
 332 /* Returns number of bytes "eaten" by the operand, or return -1 if an
 333    invalid operand was found, or -2 if an opcode tabel error was
 334    found. */
 335
 336 static int
 337 print_insn_arg (const char *d,
 338                 unsigned char *p0,
 339                 bfd_vma addr,   /* PC for this arg to be relative to.  */
 340                 disassemble_info *info)
 341 {
 342   int arg_len;
 343
 344   /* Check validity of addressing length.  */
 345   switch (d[1])
 346     {
 347     case 'b' : arg_len = 1;     break;
 348     case 'd' : arg_len = 8;     break;
 349     case 'f' : arg_len = 4;     break;
 350     case 'g' : arg_len = 8;     break;
 351     case 'h' : arg_len = 16;    break;
 352     case 'l' : arg_len = 4;     break;
 353     case 'o' : arg_len = 16;    break;
 354     case 'w' : arg_len = 2;     break;
 355     case 'q' : arg_len = 8;     break;
 356     default  : abort ();
 357     }
 358
 359   /* Branches have no mode byte.  */
 360   if (d[0] == 'b')
 361     {
 362       unsigned char *p = p0;
 363
 364       if (arg_len == 1)
 365         (*info->print_address_func) (addr + 1 + NEXTBYTE (p), info);
 366       else
 367         (*info->print_address_func) (addr + 2 + NEXTWORD (p), info);
 368
 369       return p - p0;
 370     }
 371
 372   return print_insn_mode (d, arg_len, p0, addr, info);
 373 }
 374
 375 /* Print the vax instruction at address MEMADDR in debugged memory,
 376    on INFO->STREAM.  Returns length of the instruction, in bytes.  */
 377
 378 int
 379 print_insn_vax (bfd_vma memaddr, disassemble_info *info)
 380 {
 381   static bfd_boolean parsed_disassembler_options = FALSE;
 382   const struct vot *votp;
 383   const char *argp;
 384   unsigned char *arg;
 385   struct private priv;
 386   bfd_byte *buffer = priv.the_buffer;
 387
 388   info->private_data = & priv;
 389   priv.max_fetched = priv.the_buffer;
 390   priv.insn_start = memaddr;
 391
 392   if (! parsed_disassembler_options
 393       && info->disassembler_options != NULL)
 394     {
 395       parse_disassembler_options (info->disassembler_options);
 396
 397       /* To avoid repeated parsing of these options.  */
 398       parsed_disassembler_options = TRUE;
 399     }
 400
 401   if (OPCODES_SIGSETJMP (priv.bailout) != 0)
 402     /* Error return.  */
 403     return -1;
 404
 405   argp = NULL;
 406   /* Check if the info buffer has more than one byte left since
 407      the last opcode might be a single byte with no argument data.  */
 408   if (info->buffer_length - (memaddr - info->buffer_vma) > 1
 409       && (info->stop_vma == 0 || memaddr < (info->stop_vma - 1)))
 410     {
 411       FETCH_DATA (info, buffer + 2);
 412     }
 413   else
 414     {
 415       FETCH_DATA (info, buffer + 1);
 416       buffer[1] = 0;
 417     }
 418
 419   /* Decode function entry mask.  */
 420   if (is_function_entry (info, memaddr))
 421     {
 422       int i = 0;
 423       int register_mask = buffer[1] << 8 | buffer[0];
 424
 425       (*info->fprintf_func) (info->stream, ".word 0x%04x # Entry mask: <",
 426                              register_mask);
 427
 428       for (i = 15; i >= 0; i--)
 429         if (register_mask & (1 << i))
 430           (*info->fprintf_func) (info->stream, " %s", entry_mask_bit[i]);
 431
 432       (*info->fprintf_func) (info->stream, " >");
 433
 434       return 2;
 435     }
 436
 437   /* Decode PLT entry offset longword.  */
 438   if (is_plt_tail (info, memaddr))
 439     {
 440       int offset;
 441
 442       FETCH_DATA (info, buffer + 4);
 443       offset = buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0];
 444       (*info->fprintf_func) (info->stream, ".long 0x%08x", offset);
 445
 446       return 4;
 447     }
 448
 449   for (votp = &votstrs[0]; votp->name[0]; votp++)
 450     {
 451       vax_opcodeT opcode = votp->detail.code;
 452
 453       /* 2 byte codes match 2 buffer pos. */
 454       if ((bfd_byte) opcode == buffer[0]
 455           && (opcode >> 8 == 0 || opcode >> 8 == buffer[1]))
 456         {
 457           argp = votp->detail.args;
 458           break;
 459         }
 460     }
 461   if (argp == NULL)
 462     {
 463       /* Handle undefined instructions. */
 464       (*info->fprintf_func) (info->stream, ".word 0x%x",
 465                              (buffer[0] << 8) + buffer[1]);
 466       return 2;
 467     }
 468
 469   /* Point at first byte of argument data, and at descriptor for first
 470      argument.  */
 471   arg = buffer + ((votp->detail.code >> 8) ? 2 : 1);
 472
 473   /* Make sure we have it in mem */
 474   FETCH_DATA (info, arg);
 475
 476   (*info->fprintf_func) (info->stream, "%s", votp->name);
 477   if (*argp)
 478     (*info->fprintf_func) (info->stream, " ");
 479
 480   while (*argp)
 481     {
 482       arg += print_insn_arg (argp, arg, memaddr + arg - buffer, info);
 483       argp += 2;
 484       if (*argp)
 485         (*info->fprintf_func) (info->stream, ",");
 486     }
 487
 488   return arg - buffer;
 489 }
 490