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
fetch_data(struct disassemble_info * info,bfd_byte * addr)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
parse_disassembler_options(char * options)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
is_function_entry(struct disassemble_info * info,bfd_vma addr)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
is_plt_tail(struct disassemble_info * info,bfd_vma addr)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
print_insn_mode(const char * d,int size,unsigned char * p0,bfd_vma addr,disassemble_info * info)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
print_insn_arg(const char * d,unsigned char * p0,bfd_vma addr,disassemble_info * info)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
print_insn_vax(bfd_vma memaddr,disassemble_info * info)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
488