/* Disassemble z8000 code. Copyright 1992, 1993, 1998, 2000, 2001, 2002, 2003, 2007 Free Software Foundation, Inc. This file is part of the GNU opcodes library. 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. 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. You should have received a copy of the GNU General Public License along with this file; see the file COPYING. If not, write to the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ #include "sysdep.h" #include "dis-asm.h" #define DEFINE_TABLE #include "z8k-opc.h" #include <setjmp.h> typedef struct { /* These are all indexed by nibble number (i.e only every other entry of bytes is used, and every 4th entry of words). */ unsigned char nibbles[24]; unsigned char bytes[24]; unsigned short words[24]; /* Nibble number of first word not yet fetched. */ int max_fetched; bfd_vma insn_start; jmp_buf bailout; int tabl_index; char instr_asmsrc[80]; unsigned long arg_reg[0x0f]; unsigned long immediate; unsigned long displacement; unsigned long address; unsigned long cond_code; unsigned long ctrl_code; unsigned long flags; unsigned long interrupts; } instr_data_s; /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive) to ADDR (exclusive) are valid. Returns 1 for success, longjmps on error. */ #define FETCH_DATA(info, nibble) \ ((nibble) < ((instr_data_s *) (info->private_data))->max_fetched \ ? 1 : fetch_data ((info), (nibble))) static int fetch_data (struct disassemble_info *info, int nibble) { unsigned char mybuf[20]; int status; instr_data_s *priv = (instr_data_s *) info->private_data; if ((nibble % 4) != 0) abort (); status = (*info->read_memory_func) (priv->insn_start, (bfd_byte *) mybuf, nibble / 2, info); if (status != 0) { (*info->memory_error_func) (status, priv->insn_start, info); longjmp (priv->bailout, 1); } { int i; unsigned char *p = mybuf; for (i = 0; i < nibble;) { priv->words[i] = (p[0] << 8) | p[1]; priv->bytes[i] = *p; priv->nibbles[i++] = *p >> 4; priv->nibbles[i++] = *p & 0xf; ++p; priv->bytes[i] = *p; priv->nibbles[i++] = *p >> 4; priv->nibbles[i++] = *p & 0xf; ++p; } } priv->max_fetched = nibble; return 1; } static char *codes[16] = { "f", "lt", "le", "ule", "ov/pe", "mi", "eq", "c/ult", "t", "ge", "gt", "ugt", "nov/po", "pl", "ne", "nc/uge" }; static char *ctrl_names[8] = { "<invld>", "flags", "fcw", "refresh", "psapseg", "psapoff", "nspseg", "nspoff" }; static int seg_length; int z8k_lookup_instr (unsigned char *, disassemble_info *); static void output_instr (instr_data_s *, unsigned long, disassemble_info *); static void unpack_instr (instr_data_s *, int, disassemble_info *); static void unparse_instr (instr_data_s *, int); static int print_insn_z8k (bfd_vma addr, disassemble_info *info, int is_segmented) { instr_data_s instr_data; info->private_data = (PTR) &instr_data; instr_data.max_fetched = 0; instr_data.insn_start = addr; if (setjmp (instr_data.bailout) != 0) /* Error return. */ return -1; info->bytes_per_chunk = 2; info->bytes_per_line = 6; info->display_endian = BFD_ENDIAN_BIG; instr_data.tabl_index = z8k_lookup_instr (instr_data.nibbles, info); if (instr_data.tabl_index >= 0) { unpack_instr (&instr_data, is_segmented, info); unparse_instr (&instr_data, is_segmented); output_instr (&instr_data, addr, info); return z8k_table[instr_data.tabl_index].length + seg_length; } else { FETCH_DATA (info, 4); (*info->fprintf_func) (info->stream, ".word %02x%02x", instr_data.bytes[0], instr_data.bytes[2]); return 2; } } int print_insn_z8001 (bfd_vma addr, disassemble_info *info) { return print_insn_z8k (addr, info, 1); } int print_insn_z8002 (bfd_vma addr, disassemble_info *info) { return print_insn_z8k (addr, info, 0); } int z8k_lookup_instr (unsigned char *nibbles, disassemble_info *info) { int nibl_index, tabl_index; int nibl_matched; int need_fetch = 0; unsigned short instr_nibl; unsigned short tabl_datum, datum_class, datum_value; nibl_matched = 0; tabl_index = 0; FETCH_DATA (info, 4); while (!nibl_matched && z8k_table[tabl_index].name) { nibl_matched = 1; for (nibl_index = 0; nibl_index < z8k_table[tabl_index].length * 2 && nibl_matched; nibl_index++) { if ((nibl_index % 4) == 0) { /* Fetch data only if it isn't already there. */ if (nibl_index >= 4 || (nibl_index < 4 && need_fetch)) FETCH_DATA (info, nibl_index + 4); /* Fetch one word at a time. */ if (nibl_index < 4) need_fetch = 0; else need_fetch = 1; } instr_nibl = nibbles[nibl_index]; tabl_datum = z8k_table[tabl_index].byte_info[nibl_index]; datum_class = tabl_datum & CLASS_MASK; datum_value = ~CLASS_MASK & tabl_datum; switch (datum_class) { case CLASS_BIT: if (datum_value != instr_nibl) nibl_matched = 0; break; case CLASS_IGNORE: break; case CLASS_00II: if (!((~instr_nibl) & 0x4)) nibl_matched = 0; break; case CLASS_01II: if (!(instr_nibl & 0x4)) nibl_matched = 0; break; case CLASS_0CCC: if (!((~instr_nibl) & 0x8)) nibl_matched = 0; break; case CLASS_1CCC: if (!(instr_nibl & 0x8)) nibl_matched = 0; break; case CLASS_0DISP7: if (!((~instr_nibl) & 0x8)) nibl_matched = 0; nibl_index += 1; break; case CLASS_1DISP7: if (!(instr_nibl & 0x8)) nibl_matched = 0; nibl_index += 1; break; case CLASS_REGN0: if (instr_nibl == 0) nibl_matched = 0; break; case CLASS_BIT_1OR2: if ((instr_nibl | 0x2) != (datum_value | 0x2)) nibl_matched = 0; break; default: break; } } if (nibl_matched) return tabl_index; tabl_index++; } return -1; } static void output_instr (instr_data_s *instr_data, unsigned long addr ATTRIBUTE_UNUSED, disassemble_info *info) { int num_bytes; char out_str[100]; out_str[0] = 0; num_bytes = (z8k_table[instr_data->tabl_index].length + seg_length) * 2; FETCH_DATA (info, num_bytes); strcat (out_str, instr_data->instr_asmsrc); (*info->fprintf_func) (info->stream, "%s", out_str); } static void unpack_instr (instr_data_s *instr_data, int is_segmented, disassemble_info *info) { int nibl_count, loop; unsigned short instr_nibl, instr_byte, instr_word; long instr_long; unsigned int tabl_datum, datum_class; unsigned short datum_value; nibl_count = 0; loop = 0; seg_length = 0; while (z8k_table[instr_data->tabl_index].byte_info[loop] != 0) { FETCH_DATA (info, nibl_count + 4 - (nibl_count % 4)); instr_nibl = instr_data->nibbles[nibl_count]; instr_byte = instr_data->bytes[nibl_count & ~1]; instr_word = instr_data->words[nibl_count & ~3]; tabl_datum = z8k_table[instr_data->tabl_index].byte_info[loop]; datum_class = tabl_datum & CLASS_MASK; datum_value = tabl_datum & ~CLASS_MASK; switch (datum_class) { case CLASS_DISP: switch (datum_value) { case ARG_DISP16: instr_data->displacement = instr_data->insn_start + 4 + (signed short) (instr_word & 0xffff); nibl_count += 3; break; case ARG_DISP12: if (instr_word & 0x800) /* Negative 12 bit displacement. */ instr_data->displacement = instr_data->insn_start + 2 - (signed short) ((instr_word & 0xfff) | 0xf000) * 2; else instr_data->displacement = instr_data->insn_start + 2 - (instr_word & 0x0fff) * 2; nibl_count += 2; break; default: break; } break; case CLASS_IMM: switch (datum_value) { case ARG_IMM4: instr_data->immediate = instr_nibl; break; case ARG_NIM4: instr_data->immediate = (- instr_nibl) & 0xf; break; case ARG_NIM8: instr_data->immediate = (- instr_byte) & 0xff; nibl_count += 1; break; case ARG_IMM8: instr_data->immediate = instr_byte; nibl_count += 1; break; case ARG_IMM16: instr_data->immediate = instr_word; nibl_count += 3; break; case ARG_IMM32: FETCH_DATA (info, nibl_count + 8); instr_long = (instr_data->words[nibl_count] << 16) | (instr_data->words[nibl_count + 4]); instr_data->immediate = instr_long; nibl_count += 7; break; case ARG_IMMN: instr_data->immediate = instr_nibl - 1; break; case ARG_IMM4M1: instr_data->immediate = instr_nibl + 1; break; case ARG_IMM_1: instr_data->immediate = 1; break; case ARG_IMM_2: instr_data->immediate = 2; break; case ARG_IMM2: instr_data->immediate = instr_nibl & 0x3; break; default: break; } break; case CLASS_CC: instr_data->cond_code = instr_nibl; break; case CLASS_ADDRESS: if (is_segmented) { if (instr_nibl & 0x8) { FETCH_DATA (info, nibl_count + 8); instr_long = (instr_data->words[nibl_count] << 16) | (instr_data->words[nibl_count + 4]); instr_data->address = ((instr_word & 0x7f00) << 16) + (instr_long & 0xffff); nibl_count += 7; seg_length = 2; } else { instr_data->address = ((instr_word & 0x7f00) << 16) + (instr_word & 0x00ff); nibl_count += 3; } } else { instr_data->address = instr_word; nibl_count += 3; } break; case CLASS_0CCC: case CLASS_1CCC: instr_data->ctrl_code = instr_nibl & 0x7; break; case CLASS_0DISP7: instr_data->displacement = instr_data->insn_start + 2 - (instr_byte & 0x7f) * 2; nibl_count += 1; break; case CLASS_1DISP7: instr_data->displacement = instr_data->insn_start + 2 - (instr_byte & 0x7f) * 2; nibl_count += 1; break; case CLASS_01II: instr_data->interrupts = instr_nibl & 0x3; break; case CLASS_00II: instr_data->interrupts = instr_nibl & 0x3; break; case CLASS_IGNORE: case CLASS_BIT: instr_data->ctrl_code = instr_nibl & 0x7; break; case CLASS_FLAGS: instr_data->flags = instr_nibl; break; case CLASS_REG: instr_data->arg_reg[datum_value] = instr_nibl; break; case CLASS_REGN0: instr_data->arg_reg[datum_value] = instr_nibl; break; case CLASS_DISP8: instr_data->displacement = instr_data->insn_start + 2 + (signed char) instr_byte * 2; nibl_count += 1; break; case CLASS_BIT_1OR2: instr_data->immediate = ((instr_nibl >> 1) & 0x1) + 1; nibl_count += 1; break; default: abort (); break; } loop += 1; nibl_count += 1; } } static void print_intr(char *tmp_str, unsigned long interrupts) { int comma = 0; *tmp_str = 0; if (! (interrupts & 2)) { strcat (tmp_str, "vi"); comma = 1; } if (! (interrupts & 1)) { if (comma) strcat (tmp_str, ","); strcat (tmp_str, "nvi"); } } static void print_flags(char *tmp_str, unsigned long flags) { int comma = 0; *tmp_str = 0; if (flags & 8) { strcat (tmp_str, "c"); comma = 1; } if (flags & 4) { if (comma) strcat (tmp_str, ","); strcat (tmp_str, "z"); comma = 1; } if (flags & 2) { if (comma) strcat (tmp_str, ","); strcat (tmp_str, "s"); comma = 1; } if (flags & 1) { if (comma) strcat (tmp_str, ","); strcat (tmp_str, "p"); } } static void unparse_instr (instr_data_s *instr_data, int is_segmented) { unsigned short datum_value; unsigned int tabl_datum, datum_class; int loop, loop_limit; char out_str[80], tmp_str[25]; sprintf (out_str, "%s\t", z8k_table[instr_data->tabl_index].name); loop_limit = z8k_table[instr_data->tabl_index].noperands; for (loop = 0; loop < loop_limit; loop++) { if (loop) strcat (out_str, ","); tabl_datum = z8k_table[instr_data->tabl_index].arg_info[loop]; datum_class = tabl_datum & CLASS_MASK; datum_value = tabl_datum & ~CLASS_MASK; switch (datum_class) { case CLASS_X: sprintf (tmp_str, "0x%0lx(r%ld)", instr_data->address, instr_data->arg_reg[datum_value]); strcat (out_str, tmp_str); break; case CLASS_BA: if (is_segmented) sprintf (tmp_str, "rr%ld(#0x%lx)", instr_data->arg_reg[datum_value], instr_data->immediate); else sprintf (tmp_str, "r%ld(#0x%lx)", instr_data->arg_reg[datum_value], instr_data->immediate); strcat (out_str, tmp_str); break; case CLASS_BX: if (is_segmented) sprintf (tmp_str, "rr%ld(r%ld)", instr_data->arg_reg[datum_value], instr_data->arg_reg[ARG_RX]); else sprintf (tmp_str, "r%ld(r%ld)", instr_data->arg_reg[datum_value], instr_data->arg_reg[ARG_RX]); strcat (out_str, tmp_str); break; case CLASS_DISP: sprintf (tmp_str, "0x%0lx", instr_data->displacement); strcat (out_str, tmp_str); break; case CLASS_IMM: if (datum_value == ARG_IMM2) /* True with EI/DI instructions only. */ { print_intr (tmp_str, instr_data->interrupts); strcat (out_str, tmp_str); break; } sprintf (tmp_str, "#0x%0lx", instr_data->immediate); strcat (out_str, tmp_str); break; case CLASS_CC: sprintf (tmp_str, "%s", codes[instr_data->cond_code]); strcat (out_str, tmp_str); break; case CLASS_CTRL: sprintf (tmp_str, "%s", ctrl_names[instr_data->ctrl_code]); strcat (out_str, tmp_str); break; case CLASS_DA: case CLASS_ADDRESS: sprintf (tmp_str, "0x%0lx", instr_data->address); strcat (out_str, tmp_str); break; case CLASS_IR: if (is_segmented) sprintf (tmp_str, "@rr%ld", instr_data->arg_reg[datum_value]); else sprintf (tmp_str, "@r%ld", instr_data->arg_reg[datum_value]); strcat (out_str, tmp_str); break; case CLASS_IRO: sprintf (tmp_str, "@r%ld", instr_data->arg_reg[datum_value]); strcat (out_str, tmp_str); break; case CLASS_FLAGS: print_flags(tmp_str, instr_data->flags); strcat (out_str, tmp_str); break; case CLASS_REG_BYTE: if (instr_data->arg_reg[datum_value] >= 0x8) sprintf (tmp_str, "rl%ld", instr_data->arg_reg[datum_value] - 0x8); else sprintf (tmp_str, "rh%ld", instr_data->arg_reg[datum_value]); strcat (out_str, tmp_str); break; case CLASS_REG_WORD: sprintf (tmp_str, "r%ld", instr_data->arg_reg[datum_value]); strcat (out_str, tmp_str); break; case CLASS_REG_QUAD: sprintf (tmp_str, "rq%ld", instr_data->arg_reg[datum_value]); strcat (out_str, tmp_str); break; case CLASS_REG_LONG: sprintf (tmp_str, "rr%ld", instr_data->arg_reg[datum_value]); strcat (out_str, tmp_str); break; case CLASS_PR: if (is_segmented) sprintf (tmp_str, "rr%ld", instr_data->arg_reg[datum_value]); else sprintf (tmp_str, "r%ld", instr_data->arg_reg[datum_value]); strcat (out_str, tmp_str); break; default: abort (); break; } } strcpy (instr_data->instr_asmsrc, out_str); }