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
29static 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.  */
36static 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
73struct 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
89static int
90fetch_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.  */
112static unsigned int  entry_addr_occupied_slots = 0;
113static unsigned int  entry_addr_total_slots = 0;
114static 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
120static bfd_boolean
121parse_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
163static void
164free_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
180static bfd_boolean
181is_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
200static int
201print_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
315static int
316print_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
357int
358print_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
457