4.4BSD/usr/src/contrib/gdb-4.7.lbl/opcodes/z8k-dis.c
#include <stdio.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] =
{
"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;
{
instr_data_s instr_data;
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;
}
}
static void fetch_data( in_buf, instr_data )
unsigned char **in_buf;
instr_data_s *instr_data;
{
int bytes_2fetch;
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)++;
}
static void fetch_instr( in_buf, instr_data )
unsigned char **in_buf;
instr_data_s *instr_data;
{
unsigned int loop = 2;
instr_data->bytes_fetched = 0;
while( loop-- )
instr_data->instr_buf[instr_data->bytes_fetched++] = *(*in_buf)++;
}
static unsigned long get_val( instr_buf, start_nibl, nibls_long )
unsigned char (*instr_buf)[];
unsigned int start_nibl, nibls_long;
{
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;
}
static int is_segmented()
{
return 1;
}
static
int lookup_instr( instr_data )
instr_data_s *instr_data;
{
int nibl_index, tabl_index;
int tablent_found, nibl_matched;
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++ )
{
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;
}
}
if (nibl_matched)
{
instr_data->tabl_index = tabl_index;
return 1;
}
tabl_index++;
}
return 0;
}
static void output_instr( instr_data, addr, stream )
instr_data_s *instr_data;
unsigned long addr;
FILE *stream;
{
int loop, loop_limit;
unsigned long word_val;
char tmp_str[20];
char out_str[100];
strcpy( out_str, "" );
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 );
}
while( loop++ < 5 )
{
strcat( out_str, " " );
}
strcat( out_str, instr_data->instr_asmsrc );
fprintf( stream, "%s", out_str );
}
static void unpack_instr( instr_data )
instr_data_s *instr_data;
{
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;
}
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;
}
loop += 1;
nibl_count += 1;
}
}
static void unparse_instr( instr_data )
instr_data_s *instr_data;
{
unsigned short tabl_datum, datum_class, datum_value;
int loop, loop_limit;
char out_str[80], tmp_str[25];
sprintf( out_str, "\t%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%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;
}
}
strcpy( instr_data->instr_asmsrc, out_str );
}