| /* Disassemble z8000 code. |
| Copyright 1992, 1993, 1998, 2000, 2001, 2002, 2003, 2005, 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); |
| } |
