X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=opcodes%2Fvax-dis.c;h=f58c4ad4f2d7ccdf90974a56198fb822c6a05304;hb=4c4addbe57711f1cdbb72305b8cbd03a68ae2e34;hp=54b59f30d404dcfdb286d78dec956f746449e433;hpb=5b64ad42d36e6d487e1f7287d37fbc243a178e72;p=deliverable%2Fbinutils-gdb.git diff --git a/opcodes/vax-dis.c b/opcodes/vax-dis.c index 54b59f30d4..f58c4ad4f2 100644 --- a/opcodes/vax-dis.c +++ b/opcodes/vax-dis.c @@ -1,31 +1,29 @@ /* Print VAX instructions. - Copyright (C) 1995, 1998 Free Software Foundation, Inc. + Copyright (C) 1995-2020 Free Software Foundation, Inc. Contributed by Pauline Middelink -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This file is part of the GNU opcodes library. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public + License for more details. -#include "opcode/vax.h" -#include "dis-asm.h" - -/* Local function prototypes */ -static int -print_insn_arg PARAMS ((const char *, unsigned char *, bfd_vma, - disassemble_info *)); + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ -static int -print_insn_mode PARAMS ((int, unsigned char *, bfd_vma, disassemble_info *)); +#include "sysdep.h" +#include +#include +#include "opcode/vax.h" +#include "disassemble.h" static char *reg_names[] = { @@ -33,12 +31,23 @@ static char *reg_names[] = "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc" }; +/* Definitions for the function entry mask bits. */ +static char *entry_mask_bit[] = +{ + /* Registers 0 and 1 shall not be saved, since they're used to pass back + a function's result to its caller... */ + "~r0~", "~r1~", + /* Registers 2 .. 11 are normal registers. */ + "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", + /* Registers 12 and 13 are argument and frame pointer and must not + be saved by using the entry mask. */ + "~ap~", "~fp~", + /* Bits 14 and 15 control integer and decimal overflow. */ + "IntOvfl", "DecOvfl", +}; + /* Sign-extend an (unsigned char). */ -#if __STDC__ == 1 #define COERCE_SIGNED_CHAR(ch) ((signed char)(ch)) -#else -#define COERCE_SIGNED_CHAR(ch) ((int)(((ch) ^ 0x80) & 0xFF) - 128) -#endif /* Get a 1 byte signed integer. */ #define NEXTBYTE(p) \ @@ -55,20 +64,18 @@ static char *reg_names[] = #define COERCE32(x) ((int) (((x) ^ 0x80000000) - 0x80000000)) #define NEXTLONG(p) \ (p += 4, FETCH_DATA (info, p), \ - (COERCE32 ((((((p[-1] << 8) + p[-2]) << 8) + p[-3]) << 8) + p[-4]))) + (COERCE32 (((((((unsigned) p[-1] << 8) + p[-2]) << 8) + p[-3]) << 8) + p[-4]))) /* Maximum length of an instruction. */ #define MAXLEN 25 -#include - struct private { /* Points to first byte not fetched. */ - bfd_byte *max_fetched; - bfd_byte the_buffer[MAXLEN]; - bfd_vma insn_start; - jmp_buf bailout; + bfd_byte * max_fetched; + bfd_byte the_buffer[MAXLEN]; + bfd_vma insn_start; + OPCODES_SIGJMP_BUF bailout; }; /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive) @@ -79,9 +86,7 @@ struct private ? 1 : fetch_data ((info), (addr))) static int -fetch_data (info, addr) - struct disassemble_info *info; - bfd_byte *addr; +fetch_data (struct disassemble_info *info, bfd_byte *addr) { int status; struct private *priv = (struct private *) info->private_data; @@ -94,7 +99,7 @@ fetch_data (info, addr) if (status != 0) { (*info->memory_error_func) (status, start, info); - longjmp (priv->bailout, 1); + OPCODES_SIGLONGJMP (priv->bailout, 1); } else priv->max_fetched = addr; @@ -102,127 +107,125 @@ fetch_data (info, addr) return 1; } -/* Print the vax instruction at address MEMADDR in debugged memory, - on INFO->STREAM. Returns length of the instruction, in bytes. */ +/* Entry mask handling. */ +static unsigned int entry_addr_occupied_slots = 0; +static unsigned int entry_addr_total_slots = 0; +static bfd_vma * entry_addr = NULL; -int -print_insn_vax (memaddr, info) - bfd_vma memaddr; - disassemble_info *info; -{ - const struct vot *votp; - const char *argp = NULL; - unsigned char *arg; - struct private priv; - bfd_byte *buffer = priv.the_buffer; +/* Parse the VAX specific disassembler options. These contain function + entry addresses, which can be useful to disassemble ROM images, since + there's no symbol table. Returns TRUE upon success, FALSE otherwise. */ - info->private_data = (PTR) &priv; - priv.max_fetched = priv.the_buffer; - priv.insn_start = memaddr; - if (setjmp (priv.bailout) != 0) - { - /* Error return. */ - return -1; - } +static bfd_boolean +parse_disassembler_options (const char *options) +{ + const char * entry_switch = "entry:"; - FETCH_DATA (info, buffer + 2); - for (votp = &votstrs[0]; votp->name[0]; votp++) + while ((options = strstr (options, entry_switch))) { - register vax_opcodeT opcode = votp->detail.code; + options += strlen (entry_switch); - /* 2 byte codes match 2 buffer pos. */ - if ((bfd_byte) opcode == buffer[0] - && (opcode >> 8 == 0 || opcode >> 8 == buffer[1])) + /* The greater-than part of the test below is paranoia. */ + if (entry_addr_occupied_slots >= entry_addr_total_slots) { - argp = votp->detail.args; - break; - } - } - if (argp == NULL) - { - /* Handle undefined instructions. */ - (*info->fprintf_func) (info->stream, ".word 0x%x", - (buffer[0] << 8) + buffer[1]); - return 2; - } - - /* Point at first byte of argument data, and at descriptor for first - argument. */ - arg = buffer + ((votp->detail.code >> 8) ? 2 : 1); + /* A guesstimate of the number of entries we will have to create. */ + entry_addr_total_slots += + strlen (options) / (strlen (entry_switch) + 5); - /* Make sure we have it in mem */ - FETCH_DATA (info, arg); + entry_addr = realloc (entry_addr, sizeof (bfd_vma) + * entry_addr_total_slots); + } - (*info->fprintf_func) (info->stream, "%s", votp->name); - if (*argp) - (*info->fprintf_func) (info->stream, " "); + if (entry_addr == NULL) + return FALSE; - while (*argp) - { - arg += print_insn_arg (argp, arg, memaddr + arg - buffer, info); - argp += 2; - if (*argp) - (*info->fprintf_func) (info->stream, ","); + entry_addr[entry_addr_occupied_slots] = bfd_scan_vma (options, NULL, 0); + entry_addr_occupied_slots ++; } - return arg - buffer; + return TRUE; } -/* Returns number of bytes "eaten" by the operand, or return -1 if an - invalid operand was found, or -2 if an opcode tabel error was - found. */ - -static int -print_insn_arg (d, p0, addr, info) - const char *d; - unsigned char *p0; - bfd_vma addr; /* PC for this arg to be relative to */ - disassemble_info *info; +#if 0 /* FIXME: Ideally the disassembler should have target specific + initialisation and termination function pointers. Then + parse_disassembler_options could be the init function and + free_entry_array (below) could be the termination routine. + Until then there is no way for the disassembler to tell us + that it has finished and that we no longer need the entry + array, so this routine is suppressed for now. It does mean + that we leak memory, but only to the extent that we do not + free it just before the disassembler is about to terminate + anyway. */ + +/* Free memory allocated to our entry array. */ + +static void +free_entry_array (void) { - int arg_len; - - /* check validity of addressing length */ - switch (d[1]) + if (entry_addr) { - case 'b' : arg_len = 1; break; - case 'd' : arg_len = 8; break; - case 'f' : arg_len = 4; break; - case 'g' : arg_len = 8; break; - case 'h' : arg_len = 16; break; - case 'l' : arg_len = 4; break; - case 'o' : arg_len = 16; break; - case 'w' : arg_len = 2; break; - case 'q' : arg_len = 8; break; - default : abort(); + free (entry_addr); + entry_addr = NULL; + entry_addr_occupied_slots = entry_addr_total_slots = 0; } +} +#endif +/* Check if the given address is a known function entry point. This is + the case if there is a symbol of the function type at this address. + We also check for synthetic symbols as these are used for PLT entries + (weak undefined symbols may not have the function type set). Finally + the address may have been forced to be treated as an entry point. The + latter helps in disassembling ROM images, because there's no symbol + table at all. Forced entry points can be given by supplying several + -M options to objdump: -M entry:0xffbb7730. */ + +static bfd_boolean +is_function_entry (struct disassemble_info *info, bfd_vma addr) +{ + unsigned int i; - /* branches have no mode byte */ - if (d[0] == 'b') - { - unsigned char *p = p0; + /* Check if there's a function or PLT symbol at our address. */ + if (info->symbols + && info->symbols[0] + && (info->symbols[0]->flags & (BSF_FUNCTION | BSF_SYNTHETIC)) + && addr == bfd_asymbol_value (info->symbols[0])) + return TRUE; - if (arg_len == 1) - (*info->print_address_func) (addr + 1 + NEXTBYTE (p), info); - else - (*info->print_address_func) (addr + 2 + NEXTWORD (p), info); + /* Check for forced function entry address. */ + for (i = entry_addr_occupied_slots; i--;) + if (entry_addr[i] == addr) + return TRUE; - return p - p0; - } + return FALSE; +} - return print_insn_mode (arg_len, p0, addr, info); +/* Check if the given address is the last longword of a PLT entry. + This longword is data and depending on the value it may interfere + with disassembly of further PLT entries. We make use of the fact + PLT symbols are marked BSF_SYNTHETIC. */ +static bfd_boolean +is_plt_tail (struct disassemble_info *info, bfd_vma addr) +{ + if (info->symbols + && info->symbols[0] + && (info->symbols[0]->flags & BSF_SYNTHETIC) + && addr == bfd_asymbol_value (info->symbols[0]) + 8) + return TRUE; + + return FALSE; } static int -print_insn_mode (size, p0, addr, info) - int size; - unsigned char *p0; - bfd_vma addr; /* PC for this arg to be relative to */ - disassemble_info *info; +print_insn_mode (const char *d, + int size, + unsigned char *p0, + bfd_vma addr, /* PC for this arg to be relative to. */ + disassemble_info *info) { unsigned char *p = p0; unsigned char mode, reg; - /* fetch and interpret mode byte */ + /* Fetch and interpret mode byte. */ mode = (unsigned char) NEXTBYTE (p); reg = mode & 0xF; switch (mode & 0xF0) @@ -230,63 +233,101 @@ print_insn_mode (size, p0, addr, info) case 0x00: case 0x10: case 0x20: - case 0x30: /* literal mode $number */ - (*info->fprintf_func) (info->stream, "$0x%x", mode); + case 0x30: /* Literal mode $number. */ + if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h') + (*info->fprintf_func) (info->stream, "$0x%x [%c-float]", mode, d[1]); + else + (*info->fprintf_func) (info->stream, "$0x%x", mode); break; - case 0x40: /* index: base-addr[Rn] */ - p += print_insn_mode (size, p0 + 1, addr + 1, info); - (*info->fprintf_func) (info->stream, "[%s]", reg_names[reg]); + case 0x40: /* Index: base-addr[Rn] */ + { + unsigned char *q = p0 + 1; + unsigned char nextmode = NEXTBYTE (q); + if (nextmode < 0x60 || nextmode == 0x8f) + /* Literal, index, register, or immediate is invalid. In + particular don't recurse into another index mode which + might overflow the_buffer. */ + (*info->fprintf_func) (info->stream, "[invalid base]"); + else + p += print_insn_mode (d, size, p0 + 1, addr + 1, info); + (*info->fprintf_func) (info->stream, "[%s]", reg_names[reg]); + } break; - case 0x50: /* register: Rn */ + case 0x50: /* Register: Rn */ (*info->fprintf_func) (info->stream, "%s", reg_names[reg]); break; - case 0x60: /* register deferred: (Rn) */ + case 0x60: /* Register deferred: (Rn) */ (*info->fprintf_func) (info->stream, "(%s)", reg_names[reg]); break; - case 0x70: /* autodecrement: -(Rn) */ + case 0x70: /* Autodecrement: -(Rn) */ (*info->fprintf_func) (info->stream, "-(%s)", reg_names[reg]); break; - case 0x80: /* autoincrement: (Rn)+ */ + case 0x80: /* Autoincrement: (Rn)+ */ if (reg == 0xF) - { /* immediate? */ + { /* Immediate? */ int i; FETCH_DATA (info, p + size); (*info->fprintf_func) (info->stream, "$0x"); - for (i = 0; i < size; i++) - (*info->fprintf_func) (info->stream, "%02x", p[size - i - 1]); + if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h') + { + int float_word; + + float_word = p[0] | (p[1] << 8); + if ((d[1] == 'd' || d[1] == 'f') + && (float_word & 0xff80) == 0x8000) + { + (*info->fprintf_func) (info->stream, "[invalid %c-float]", + d[1]); + } + else + { + for (i = 0; i < size; i++) + (*info->fprintf_func) (info->stream, "%02x", + p[size - i - 1]); + (*info->fprintf_func) (info->stream, " [%c-float]", d[1]); + } + } + else + { + for (i = 0; i < size; i++) + (*info->fprintf_func) (info->stream, "%02x", p[size - i - 1]); + } p += size; } else (*info->fprintf_func) (info->stream, "(%s)+", reg_names[reg]); break; - case 0x90: /* autoincrement deferred: @(Rn)+ */ + case 0x90: /* Autoincrement deferred: @(Rn)+ */ if (reg == 0xF) (*info->fprintf_func) (info->stream, "*0x%x", NEXTLONG (p)); else (*info->fprintf_func) (info->stream, "@(%s)+", reg_names[reg]); break; - case 0xB0: /* displacement byte deferred: *displ(Rn) */ + case 0xB0: /* Displacement byte deferred: *displ(Rn). */ (*info->fprintf_func) (info->stream, "*"); - case 0xA0: /* displacement byte: displ(Rn) */ + /* Fall through. */ + case 0xA0: /* Displacement byte: displ(Rn). */ if (reg == 0xF) (*info->print_address_func) (addr + 2 + NEXTBYTE (p), info); else (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTBYTE (p), reg_names[reg]); break; - case 0xD0: /* displacement word deferred: *displ(Rn) */ + case 0xD0: /* Displacement word deferred: *displ(Rn). */ (*info->fprintf_func) (info->stream, "*"); - case 0xC0: /* displacement word: displ(Rn) */ + /* Fall through. */ + case 0xC0: /* Displacement word: displ(Rn). */ if (reg == 0xF) (*info->print_address_func) (addr + 3 + NEXTWORD (p), info); else (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTWORD (p), reg_names[reg]); break; - case 0xF0: /* displacement long deferred: *displ(Rn) */ + case 0xF0: /* Displacement long deferred: *displ(Rn). */ (*info->fprintf_func) (info->stream, "*"); - case 0xE0: /* displacement long: displ(Rn) */ + /* Fall through. */ + case 0xE0: /* Displacement long: displ(Rn). */ if (reg == 0xF) (*info->print_address_func) (addr + 5 + NEXTLONG (p), info); else @@ -297,3 +338,164 @@ print_insn_mode (size, p0, addr, info) return p - p0; } + +/* Returns number of bytes "eaten" by the operand, or return -1 if an + invalid operand was found, or -2 if an opcode tabel error was + found. */ + +static int +print_insn_arg (const char *d, + unsigned char *p0, + bfd_vma addr, /* PC for this arg to be relative to. */ + disassemble_info *info) +{ + int arg_len; + + /* Check validity of addressing length. */ + switch (d[1]) + { + case 'b' : arg_len = 1; break; + case 'd' : arg_len = 8; break; + case 'f' : arg_len = 4; break; + case 'g' : arg_len = 8; break; + case 'h' : arg_len = 16; break; + case 'l' : arg_len = 4; break; + case 'o' : arg_len = 16; break; + case 'w' : arg_len = 2; break; + case 'q' : arg_len = 8; break; + default : abort (); + } + + /* Branches have no mode byte. */ + if (d[0] == 'b') + { + unsigned char *p = p0; + + if (arg_len == 1) + (*info->print_address_func) (addr + 1 + NEXTBYTE (p), info); + else + (*info->print_address_func) (addr + 2 + NEXTWORD (p), info); + + return p - p0; + } + + return print_insn_mode (d, arg_len, p0, addr, info); +} + +/* Print the vax instruction at address MEMADDR in debugged memory, + on INFO->STREAM. Returns length of the instruction, in bytes. */ + +int +print_insn_vax (bfd_vma memaddr, disassemble_info *info) +{ + static bfd_boolean parsed_disassembler_options = FALSE; + const struct vot *votp; + const char *argp; + unsigned char *arg; + struct private priv; + bfd_byte *buffer = priv.the_buffer; + + info->private_data = & priv; + priv.max_fetched = priv.the_buffer; + priv.insn_start = memaddr; + + if (! parsed_disassembler_options + && info->disassembler_options != NULL) + { + parse_disassembler_options (info->disassembler_options); + + /* To avoid repeated parsing of these options. */ + parsed_disassembler_options = TRUE; + } + + if (OPCODES_SIGSETJMP (priv.bailout) != 0) + /* Error return. */ + return -1; + + argp = NULL; + /* Check if the info buffer has more than one byte left since + the last opcode might be a single byte with no argument data. */ + if (info->buffer_length - (memaddr - info->buffer_vma) > 1 + && (info->stop_vma == 0 || memaddr < (info->stop_vma - 1))) + { + FETCH_DATA (info, buffer + 2); + } + else + { + FETCH_DATA (info, buffer + 1); + buffer[1] = 0; + } + + /* Decode function entry mask. */ + if (is_function_entry (info, memaddr)) + { + int i = 0; + int register_mask = buffer[1] << 8 | buffer[0]; + + (*info->fprintf_func) (info->stream, ".word 0x%04x # Entry mask: <", + register_mask); + + for (i = 15; i >= 0; i--) + if (register_mask & (1 << i)) + (*info->fprintf_func) (info->stream, " %s", entry_mask_bit[i]); + + (*info->fprintf_func) (info->stream, " >"); + + return 2; + } + + /* Decode PLT entry offset longword. */ + if (is_plt_tail (info, memaddr)) + { + int offset; + + FETCH_DATA (info, buffer + 4); + offset = ((unsigned) buffer[3] << 24 | buffer[2] << 16 + | buffer[1] << 8 | buffer[0]); + (*info->fprintf_func) (info->stream, ".long 0x%08x", offset); + + return 4; + } + + for (votp = &votstrs[0]; votp->name[0]; votp++) + { + vax_opcodeT opcode = votp->detail.code; + + /* 2 byte codes match 2 buffer pos. */ + if ((bfd_byte) opcode == buffer[0] + && (opcode >> 8 == 0 || opcode >> 8 == buffer[1])) + { + argp = votp->detail.args; + break; + } + } + if (argp == NULL) + { + /* Handle undefined instructions. */ + (*info->fprintf_func) (info->stream, ".word 0x%x", + (buffer[0] << 8) + buffer[1]); + return 2; + } + + /* Point at first byte of argument data, and at descriptor for first + argument. */ + arg = buffer + ((votp->detail.code >> 8) ? 2 : 1); + + /* Make sure we have it in mem */ + FETCH_DATA (info, arg); + + (*info->fprintf_func) (info->stream, "%s", votp->name); + if (*argp) + (*info->fprintf_func) (info->stream, " "); + + while (*argp) + { + arg += print_insn_arg (argp, arg, memaddr + arg - buffer, info); + argp += 2; + if (*argp) + (*info->fprintf_func) (info->stream, ","); + } + + return arg - buffer; +} +