X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=opcodes%2Fvax-dis.c;h=8b5935a77bcd369fb158db6d6bbb421082e31e4e;hb=4b185e973e59e5ac90eadd694d6583d5abce4a38;hp=54b59f30d404dcfdb286d78dec956f746449e433;hpb=5b64ad42d36e6d487e1f7287d37fbc243a178e72;p=deliverable%2Fbinutils-gdb.git diff --git a/opcodes/vax-dis.c b/opcodes/vax-dis.c index 54b59f30d4..8b5935a77b 100644 --- a/opcodes/vax-dis.c +++ b/opcodes/vax-dis.c @@ -1,31 +1,35 @@ /* Print VAX instructions. - Copyright (C) 1995, 1998 Free Software Foundation, Inc. + Copyright 1995, 1998, 2000, 2001, 2002, 2005 + 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 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 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 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. -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. */ + 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. */ +#include +#include +#include "sysdep.h" #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 *)); +static int fetch_data PARAMS ((struct disassemble_info *, bfd_byte *)); +static int print_insn_arg + PARAMS ((const char *, unsigned char *, bfd_vma, disassemble_info *)); +static int print_insn_mode + PARAMS ((const char *, int, unsigned char *, bfd_vma, disassemble_info *)); -static int -print_insn_mode PARAMS ((int, unsigned char *, bfd_vma, disassemble_info *)); static char *reg_names[] = { @@ -33,6 +37,21 @@ 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)) @@ -60,15 +79,13 @@ static char *reg_names[] = /* 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; + jmp_buf bailout; }; /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive) @@ -102,6 +119,95 @@ fetch_data (info, addr) return 1; } +/* 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; + +/* 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. */ + +static bfd_boolean +parse_disassembler_options (char * options) +{ + const char * entry_switch = "entry:"; + + while ((options = strstr (options, entry_switch))) + { + options += strlen (entry_switch); + + /* The greater-than part of the test below is paranoia. */ + if (entry_addr_occupied_slots >= entry_addr_total_slots) + { + /* A guesstimate of the number of entries we will have to create. */ + entry_addr_total_slots += + strlen (options) / (strlen (entry_switch) + 5); + + entry_addr = realloc (entry_addr, sizeof (bfd_vma) + * entry_addr_total_slots); + } + + if (entry_addr == NULL) + return FALSE; + + entry_addr[entry_addr_occupied_slots] = bfd_scan_vma (options, NULL, 0); + entry_addr_occupied_slots ++; + } + + return TRUE; +} + +#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) +{ + if (entry_addr) + { + 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. Either there must + be a symbol of function type at this address, or the address must be + a forced entry point. The later 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; + + /* Check if there's a BSF_FUNCTION symbol at our address. */ + if (info->symbols + && info->symbols[0] + && (info->symbols[0]->flags & BSF_FUNCTION) + && addr == bfd_asymbol_value (info->symbols[0])) + return TRUE; + + /* Check for forced function entry address. */ + for (i = entry_addr_occupied_slots; i--;) + if (entry_addr[i] == addr) + return TRUE; + + return FALSE; +} + /* Print the vax instruction at address MEMADDR in debugged memory, on INFO->STREAM. Returns length of the instruction, in bytes. */ @@ -110,8 +216,9 @@ print_insn_vax (memaddr, info) bfd_vma memaddr; disassemble_info *info; { + static bfd_boolean parsed_disassembler_options = FALSE; const struct vot *votp; - const char *argp = NULL; + const char *argp; unsigned char *arg; struct private priv; bfd_byte *buffer = priv.the_buffer; @@ -119,13 +226,53 @@ print_insn_vax (memaddr, info) info->private_data = (PTR) &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 (setjmp (priv.bailout) != 0) { /* Error return. */ return -1; } - FETCH_DATA (info, buffer + 2); + 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) + { + 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; + } + for (votp = &votstrs[0]; votp->name[0]; votp++) { register vax_opcodeT opcode = votp->detail.code; @@ -209,11 +356,12 @@ print_insn_arg (d, p0, addr, info) return p - p0; } - return print_insn_mode (arg_len, p0, addr, info); + return print_insn_mode (d, arg_len, p0, addr, info); } static int -print_insn_mode (size, p0, addr, info) +print_insn_mode (d, size, p0, addr, info) + const char *d; int size; unsigned char *p0; bfd_vma addr; /* PC for this arg to be relative to */ @@ -231,10 +379,13 @@ print_insn_mode (size, p0, addr, info) case 0x10: case 0x20: case 0x30: /* literal mode $number */ - (*info->fprintf_func) (info->stream, "$0x%x", mode); + 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); + 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 */ @@ -253,8 +404,30 @@ print_insn_mode (size, p0, addr, info) 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