opcodes/vax-dis.c

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