1 /* Print VAX instructions. 2 Copyright (C) 1995-2016 Free Software Foundation, Inc. 3 Contributed by Pauline Middelink <middelin (at) 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 488
