opcodes/vax-dis.c

   1 /* Print VAX instructions.
   2    Copyright (C) 1995-2016 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 "dis-asm.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 (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     case 0xA0: /* Displacement byte:            displ(Rn).  */
 300       if (reg == 0xF)
 301         (*info->print_address_func) (addr + 2 + NEXTBYTE (p), info);
 302       else
 303         (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTBYTE (p),
 304                                reg_names[reg]);
 305       break;
 306     case 0xD0: /* Displacement word deferred:   *displ(Rn).  */
 307       (*info->fprintf_func) (info->stream, "*");
 308     case 0xC0: /* Displacement word:            displ(Rn).  */
 309       if (reg == 0xF)
 310         (*info->print_address_func) (addr + 3 + NEXTWORD (p), info);
 311       else
 312         (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTWORD (p),
 313                                reg_names[reg]);
 314       break;
 315     case 0xF0: /* Displacement long deferred:   *displ(Rn).  */
 316       (*info->fprintf_func) (info->stream, "*");
 317     case 0xE0: /* Displacement long:            displ(Rn).  */
 318       if (reg == 0xF)
 319         (*info->print_address_func) (addr + 5 + NEXTLONG (p), info);
 320       else
 321         (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTLONG (p),
 322                                reg_names[reg]);
 323       break;
 324     }
 325
 326   return p - p0;
 327 }
 328
 329 /* Returns number of bytes "eaten" by the operand, or return -1 if an
 330    invalid operand was found, or -2 if an opcode tabel error was
 331    found. */
 332
 333 static int
 334 print_insn_arg (const char *d,
 335                 unsigned char *p0,
 336                 bfd_vma addr,   /* PC for this arg to be relative to.  */
 337                 disassemble_info *info)
 338 {
 339   int arg_len;
 340
 341   /* Check validity of addressing length.  */
 342   switch (d[1])
 343     {
 344     case 'b' : arg_len = 1;     break;
 345     case 'd' : arg_len = 8;     break;
 346     case 'f' : arg_len = 4;     break;
 347     case 'g' : arg_len = 8;     break;
 348     case 'h' : arg_len = 16;    break;
 349     case 'l' : arg_len = 4;     break;
 350     case 'o' : arg_len = 16;    break;
 351     case 'w' : arg_len = 2;     break;
 352     case 'q' : arg_len = 8;     break;
 353     default  : abort ();
 354     }
 355
 356   /* Branches have no mode byte.  */
 357   if (d[0] == 'b')
 358     {
 359       unsigned char *p = p0;
 360
 361       if (arg_len == 1)
 362         (*info->print_address_func) (addr + 1 + NEXTBYTE (p), info);
 363       else
 364         (*info->print_address_func) (addr + 2 + NEXTWORD (p), info);
 365
 366       return p - p0;
 367     }
 368
 369   return print_insn_mode (d, arg_len, p0, addr, info);
 370 }
 371
 372 /* Print the vax instruction at address MEMADDR in debugged memory,
 373    on INFO->STREAM.  Returns length of the instruction, in bytes.  */
 374
 375 int
 376 print_insn_vax (bfd_vma memaddr, disassemble_info *info)
 377 {
 378   static bfd_boolean parsed_disassembler_options = FALSE;
 379   const struct vot *votp;
 380   const char *argp;
 381   unsigned char *arg;
 382   struct private priv;
 383   bfd_byte *buffer = priv.the_buffer;
 384
 385   info->private_data = & priv;
 386   priv.max_fetched = priv.the_buffer;
 387   priv.insn_start = memaddr;
 388
 389   if (! parsed_disassembler_options
 390       && info->disassembler_options != NULL)
 391     {
 392       parse_disassembler_options (info->disassembler_options);
 393
 394       /* To avoid repeated parsing of these options.  */
 395       parsed_disassembler_options = TRUE;
 396     }
 397
 398   if (OPCODES_SIGSETJMP (priv.bailout) != 0)
 399     /* Error return.  */
 400     return -1;
 401
 402   argp = NULL;
 403   /* Check if the info buffer has more than one byte left since
 404      the last opcode might be a single byte with no argument data.  */
 405   if (info->buffer_length - (memaddr - info->buffer_vma) > 1
 406       && (info->stop_vma == 0 || memaddr < (info->stop_vma - 1)))
 407     {
 408       FETCH_DATA (info, buffer + 2);
 409     }
 410   else
 411     {
 412       FETCH_DATA (info, buffer + 1);
 413       buffer[1] = 0;
 414     }
 415
 416   /* Decode function entry mask.  */
 417   if (is_function_entry (info, memaddr))
 418     {
 419       int i = 0;
 420       int register_mask = buffer[1] << 8 | buffer[0];
 421
 422       (*info->fprintf_func) (info->stream, ".word 0x%04x # Entry mask: <",
 423                              register_mask);
 424
 425       for (i = 15; i >= 0; i--)
 426         if (register_mask & (1 << i))
 427           (*info->fprintf_func) (info->stream, " %s", entry_mask_bit[i]);
 428
 429       (*info->fprintf_func) (info->stream, " >");
 430
 431       return 2;
 432     }
 433
 434   /* Decode PLT entry offset longword.  */
 435   if (is_plt_tail (info, memaddr))
 436     {
 437       int offset;
 438
 439       FETCH_DATA (info, buffer + 4);
 440       offset = buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0];
 441       (*info->fprintf_func) (info->stream, ".long 0x%08x", offset);
 442
 443       return 4;
 444     }
 445
 446   for (votp = &votstrs[0]; votp->name[0]; votp++)
 447     {
 448       vax_opcodeT opcode = votp->detail.code;
 449
 450       /* 2 byte codes match 2 buffer pos. */
 451       if ((bfd_byte) opcode == buffer[0]
 452           && (opcode >> 8 == 0 || opcode >> 8 == buffer[1]))
 453         {
 454           argp = votp->detail.args;
 455           break;
 456         }
 457     }
 458   if (argp == NULL)
 459     {
 460       /* Handle undefined instructions. */
 461       (*info->fprintf_func) (info->stream, ".word 0x%x",
 462                              (buffer[0] << 8) + buffer[1]);
 463       return 2;
 464     }
 465
 466   /* Point at first byte of argument data, and at descriptor for first
 467      argument.  */
 468   arg = buffer + ((votp->detail.code >> 8) ? 2 : 1);
 469
 470   /* Make sure we have it in mem */
 471   FETCH_DATA (info, arg);
 472
 473   (*info->fprintf_func) (info->stream, "%s", votp->name);
 474   if (*argp)
 475     (*info->fprintf_func) (info->stream, " ");
 476
 477   while (*argp)
 478     {
 479       arg += print_insn_arg (argp, arg, memaddr + arg - buffer, info);
 480       argp += 2;
 481       if (*argp)
 482         (*info->fprintf_func) (info->stream, ",");
 483     }
 484
 485   return arg - buffer;
 486 }
 487