X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=opcodes%2Fz8k-dis.c;h=11edd3a8fb03a5197000eb71fbb2921ca321d4ae;hb=362c0c4d9cc9f320d1e85755404879a13ebed91a;hp=2a2d3c343b00b1b65e5addb812b459bfa961d4bb;hpb=447bbbea3a96b0be25437f797a8f27775c09da08;p=deliverable%2Fbinutils-gdb.git diff --git a/opcodes/z8k-dis.c b/opcodes/z8k-dis.c index 2a2d3c343b..11edd3a8fb 100644 --- a/opcodes/z8k-dis.c +++ b/opcodes/z8k-dis.c @@ -1,519 +1,643 @@ -#include +/* Disassemble z8000 code. + Copyright (C) 1992-2016 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" -static void fetch_data(); -static void fetch_instr(); -static unsigned long get_val(); -static int is_segmented(); -static int lookup_instr(); -static void output_instr(); -static void unpack_instr(); -static void unparse_instr(); - -typedef struct { - unsigned char instr_buf[24]; - unsigned long bytes_fetched; - unsigned long 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; - - -static char *codes[16] = +#include + +typedef struct { - "f", - "lt", - "le", - "ule", - "ov/pe", - "mi", - "eq", - "c/ult", - "t", - "ge", - "gt", - "ugt", - "nov/po", - "pl", - "ne", - "nc/uge" -}; - - -int print_insn_z8k(addr, in_buf, stream) -unsigned long addr; -unsigned char *in_buf; -FILE *stream; + /* 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; + OPCODES_SIGJMP_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) { - instr_data_s instr_data; + 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); + OPCODES_SIGLONGJMP (priv->bailout, 1); + } - fetch_instr( &in_buf, &instr_data ); - if ( lookup_instr( &instr_data )) { - fetch_data( &in_buf, &instr_data ); - unpack_instr( &instr_data ); - unparse_instr( &instr_data ); - output_instr( &instr_data, addr, stream ); - return instr_data.bytes_fetched; - } - else { - fprintf(stream,".word %02x%02x", in_buf[0], in_buf[1]); - return 2; - } + 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; -static void fetch_data( in_buf, instr_data ) -unsigned char **in_buf; -instr_data_s *instr_data; -{ - int bytes_2fetch; + ++p; + priv->bytes[i] = *p; + priv->nibbles[i++] = *p >> 4; + priv->nibbles[i++] = *p & 0xf; - bytes_2fetch = z8k_table[instr_data->tabl_index].length - - instr_data->bytes_fetched; - while( bytes_2fetch-- ) - instr_data->instr_buf[instr_data->bytes_fetched++] = *(*in_buf)++; + ++p; + } + } + priv->max_fetched = nibble; + return 1; } -static void fetch_instr( in_buf, instr_data ) -unsigned char **in_buf; -instr_data_s *instr_data; +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] = + { + "", + "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) { - unsigned int loop = 2; + instr_data_s instr_data; + + info->private_data = (PTR) &instr_data; + instr_data.max_fetched = 0; + instr_data.insn_start = addr; + if (OPCODES_SIGSETJMP (instr_data.bailout) != 0) + /* Error return. */ + return -1; - instr_data->bytes_fetched = 0; - while( loop-- ) - instr_data->instr_buf[instr_data->bytes_fetched++] = *(*in_buf)++; + 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; + } } -static unsigned long get_val( instr_buf, start_nibl, nibls_long ) -unsigned char (*instr_buf)[]; -unsigned int start_nibl, nibls_long; +int +print_insn_z8001 (bfd_vma addr, disassemble_info *info) { - unsigned long ret_val; - unsigned char byte_val, nibl_val; - unsigned int nibl_index, nibl_lim; - unsigned int byte_index; - unsigned int which_nibl; - - ret_val = 0; - nibl_lim = start_nibl + nibls_long; - for( nibl_index = start_nibl; nibl_index < nibl_lim; nibl_index++ ) - { - byte_index = nibl_index / 2; - which_nibl = nibl_index % 2; - switch( which_nibl ) - { - case 0: - byte_val = (*instr_buf)[byte_index]; - nibl_val = (byte_val >> 4) & 0x0f; - break; - case 1: - nibl_val = byte_val & 0x0f; - break; - } - ret_val = (ret_val << 4) | nibl_val; - } - - return ret_val; - + return print_insn_z8k (addr, info, 1); } -static int is_segmented() +int +print_insn_z8002 (bfd_vma addr, disassemble_info *info) { - return 1; + return print_insn_z8k (addr, info, 0); } -static -int lookup_instr( instr_data ) -instr_data_s *instr_data; +int +z8k_lookup_instr (unsigned char *nibbles, disassemble_info *info) { - - int nibl_index, tabl_index; - int tablent_found, nibl_matched; + 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; - while( ! nibl_matched && z8k_table[tabl_index].name) - { - nibl_matched = 1; - for( nibl_index = 0; nibl_index < 4 && nibl_matched; nibl_index++ ) + FETCH_DATA (info, 4); + while (!nibl_matched && z8k_table[tabl_index].name) { - instr_nibl = get_val( instr_data->instr_buf, nibl_index, 1 ); - - 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_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; - default: - break; - } + 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++; } - tabl_index++; - } - - - instr_data->tabl_index = tabl_index; - - return nibl_matched; - + return -1; } -static void output_instr( instr_data, addr, stream ) -instr_data_s *instr_data; -unsigned long addr; -FILE *stream; +static void +output_instr (instr_data_s *instr_data, + unsigned long addr ATTRIBUTE_UNUSED, + disassemble_info *info) { - int loop, loop_limit; - unsigned long word_val; - char tmp_str[20]; - char out_str[100]; + int num_bytes; + char out_str[100]; - strcpy( out_str, "" ); + out_str[0] = 0; - loop_limit = z8k_table[instr_data->tabl_index].length / 2; - for( loop = 0; loop < loop_limit; loop++ ) - { - word_val = get_val( instr_data->instr_buf, loop * 4, 4 ); - sprintf( tmp_str, "%04x ", word_val ); - strcat( out_str, tmp_str ); - } + num_bytes = (z8k_table[instr_data->tabl_index].length + seg_length) * 2; + FETCH_DATA (info, num_bytes); - while( loop++ < 5 ) - { - strcat( out_str, " " ); - } + strcat (out_str, instr_data->instr_asmsrc); - strcat( out_str, instr_data->instr_asmsrc ); - - fprintf( stream, "%s", out_str ); + (*info->fprintf_func) (info->stream, "%s", out_str); } -static void unpack_instr( instr_data ) -instr_data_s *instr_data; +static void +unpack_instr (instr_data_s *instr_data, int is_segmented, disassemble_info *info) { - int nibl_index, word_index; - int nibl_count, loop; - unsigned short instr_nibl, instr_byte, instr_word, instr_long; - unsigned short tabl_datum, datum_class, datum_value; - - nibl_count = 0; - loop = 0; - while( z8k_table[instr_data->tabl_index].byte_info[loop] != 0 ) - { - word_index = (int) nibl_count / 4; - nibl_index = (int) nibl_count % 4; - - switch( nibl_index ) - { - case 0: - instr_nibl = get_val( instr_data->instr_buf, nibl_count, 1 ); - instr_byte = get_val( instr_data->instr_buf, nibl_count, 2 ); - instr_word = get_val( instr_data->instr_buf, nibl_count, 4 ); - instr_long = get_val( instr_data->instr_buf, nibl_count, 8 ); - break; - case 1: - instr_nibl = get_val( instr_data->instr_buf, nibl_count, 1 ); - break; - case 2: - instr_nibl = get_val( instr_data->instr_buf, nibl_count, 1 ); - instr_byte = get_val( instr_data->instr_buf, nibl_count, 2 ); - break; - case 3: - instr_nibl = get_val( instr_data->instr_buf, nibl_count, 1 ); - break; - default: - break; - } + 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_X: - instr_data->address = instr_nibl; - break; - case CLASS_BA: - instr_data->displacement = instr_nibl; - break; - case CLASS_BX: - instr_data->arg_reg[datum_value] = instr_nibl; - break; - case CLASS_DISP: - switch( datum_value ) - { - case ARG_DISP16: - instr_data->displacement = instr_word; - nibl_count += 3; - break; - case ARG_DISP12: - instr_data->displacement = instr_word & 0x0fff; - nibl_count += 2; - break; - default: - break; - } - break; - case CLASS_IMM: - switch( datum_value ) - { - case ARG_IMM4: - instr_data->immediate = instr_nibl; - 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: - instr_data->immediate = instr_long; - nibl_count += 7; - break; - case ARG_IMMN: - instr_data->immediate = instr_nibl -1; - break; - /* ????? */ - /* missing ARG_IMMNMINUS1 */ - case ARG_IMM_1: - instr_data->immediate = 1; - break; - case ARG_IMM_2: - instr_data->immediate = 2; - break; - case ARG_NIM16: - instr_data->immediate = (- instr_word); - nibl_count += 3; - 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_CTRL: - instr_data->ctrl_code = instr_nibl; - break; - case CLASS_DA: - case CLASS_ADDRESS: - if( is_segmented() ) - { - if( instr_nibl & 0x8 ) - { - instr_data->address = ((instr_word & 0x7f00) << 8) + - (instr_long & 0xffff); - nibl_count += 7; - } - else - { - instr_data->address = ((instr_word & 0x7f00) << 8) + - (instr_word & 0x00ff); - nibl_count += 3; - } - } - else - { - instr_data->address = instr_word; - nibl_count += 3; - } - break; - case CLASS_0CCC: - instr_data->cond_code = instr_nibl & 0x7; - break; - case CLASS_1CCC: - instr_data->cond_code = instr_nibl & 0x7; - break; - case CLASS_0DISP7: - instr_data->displacement = instr_byte & 0x7f; - nibl_count += 1; - break; - case CLASS_1DISP7: - instr_data->displacement = instr_byte & 0x7f; - 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_BIT: - /* do nothing */ - break; - case CLASS_IR: - instr_data->arg_reg[datum_value] = instr_nibl; - break; - case CLASS_FLAGS: - instr_data->flags = instr_nibl; - break; - case CLASS_REG: - instr_data->arg_reg[datum_value] = instr_nibl; - break; - case CLASS_REG_BYTE: - instr_data->arg_reg[datum_value] = instr_nibl; - break; - case CLASS_REG_WORD: - instr_data->arg_reg[datum_value] = instr_nibl; - break; - case CLASS_REG_QUAD: - instr_data->arg_reg[datum_value] = instr_nibl; - break; - case CLASS_REG_LONG: - instr_data->arg_reg[datum_value] = instr_nibl; - break; - case CLASS_REGN0: - instr_data->arg_reg[datum_value] = instr_nibl; - break; - default: - break; - } + 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 ) -instr_data_s *instr_data; +static void +unparse_instr (instr_data_s *instr_data, int is_segmented) { - unsigned short tabl_datum, datum_class, datum_value; - int loop, loop_limit; - char out_str[80], tmp_str[25]; + unsigned short datum_value; + unsigned int tabl_datum, datum_class; + int loop, loop_limit; + char out_str[80], tmp_str[25]; - sprintf( out_str, "\t%s\t", z8k_table[instr_data->tabl_index].name ); + 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, "," ); + 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%0x(R%d)", instr_data->address, - instr_data->arg_reg[datum_value] ); - strcat( out_str, tmp_str ); - break; - case CLASS_BA: - sprintf( tmp_str, "r%d(#%x)", instr_data->arg_reg[datum_value], - instr_data->displacement); - strcat( out_str, tmp_str ); - break; - case CLASS_BX: - sprintf( tmp_str, "r%d(R%d)", 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%0x", instr_data->displacement ); - strcat( out_str, tmp_str ); - break; - case CLASS_IMM: - sprintf( tmp_str, "#0x%0x", 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, "0x%0x", instr_data->ctrl_code ); - strcat( out_str, tmp_str ); - break; - case CLASS_DA: - case CLASS_ADDRESS: - sprintf( tmp_str, "#0x%0x", instr_data->address ); - strcat( out_str, tmp_str ); - break; - case CLASS_IR: - sprintf( tmp_str, "@R%d", instr_data->arg_reg[datum_value] ); - strcat( out_str, tmp_str ); - break; - case CLASS_FLAGS: - sprintf( tmp_str, "0x%0x", 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%d", - instr_data->arg_reg[datum_value] - 0x8 ); - } - else - { - sprintf( tmp_str, "rh%d", instr_data->arg_reg[datum_value] ); - } - strcat( out_str, tmp_str ); - break; - case CLASS_REG_WORD: - sprintf( tmp_str, "r%d", instr_data->arg_reg[datum_value] ); - strcat( out_str, tmp_str ); - break; - case CLASS_REG_QUAD: - sprintf( tmp_str, "rq%d", instr_data->arg_reg[datum_value] ); - strcat( out_str, tmp_str ); - break; - case CLASS_REG_LONG: - sprintf( tmp_str, "rr%d", instr_data->arg_reg[datum_value] ); - strcat( out_str, tmp_str ); - break; - default: - break; - } - } + 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 ); + strcpy (instr_data->instr_asmsrc, out_str); }