#include "sysdep.h"
#include <stdio.h>
#include "ansidecl.h"
#include "dis-asm.h"
#include "bfd.h"
#include "symcat.h"
#include "libiberty.h"
#include "ms1-desc.h"
#include "ms1-opc.h"
#include "opintl.h"
#define UNKNOWN_INSN_MSG _("*unknown*")
static void print_normal
(CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int);
static void print_address
(CGEN_CPU_DESC, void *, bfd_vma, unsigned int, bfd_vma, int) ATTRIBUTE_UNUSED;
static void print_keyword
(CGEN_CPU_DESC, void *, CGEN_KEYWORD *, long, unsigned int) ATTRIBUTE_UNUSED;
static void print_insn_normal
(CGEN_CPU_DESC, void *, const CGEN_INSN *, CGEN_FIELDS *, bfd_vma, int);
static int print_insn
(CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, unsigned);
static int default_print_insn
(CGEN_CPU_DESC, bfd_vma, disassemble_info *) ATTRIBUTE_UNUSED;
static int read_insn
(CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, int, CGEN_EXTRACT_INFO *,
unsigned long *);
static void print_dollarhex (CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int);
static void
print_dollarhex (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
void * dis_info,
long value,
unsigned int attrs ATTRIBUTE_UNUSED,
bfd_vma pc ATTRIBUTE_UNUSED,
int length ATTRIBUTE_UNUSED)
{
disassemble_info *info = (disassemble_info *) dis_info;
info->fprintf_func (info->stream, "$%lx", value);
if (0)
print_normal (cd, dis_info, value, attrs, pc, length);
}
void ms1_cgen_print_operand
(CGEN_CPU_DESC, int, PTR, CGEN_FIELDS *, void const *, bfd_vma, int);
void
ms1_cgen_print_operand (CGEN_CPU_DESC cd,
int opindex,
void * xinfo,
CGEN_FIELDS *fields,
void const *attrs ATTRIBUTE_UNUSED,
bfd_vma pc,
int length)
{
disassemble_info *info = (disassemble_info *) xinfo;
switch (opindex)
{
case MS1_OPERAND_A23 :
print_dollarhex (cd, info, fields->f_a23, 0, pc, length);
break;
case MS1_OPERAND_BALL :
print_dollarhex (cd, info, fields->f_ball, 0, pc, length);
break;
case MS1_OPERAND_BALL2 :
print_dollarhex (cd, info, fields->f_ball2, 0, pc, length);
break;
case MS1_OPERAND_BANKADDR :
print_dollarhex (cd, info, fields->f_bankaddr, 0, pc, length);
break;
case MS1_OPERAND_BRC :
print_dollarhex (cd, info, fields->f_brc, 0, pc, length);
break;
case MS1_OPERAND_BRC2 :
print_dollarhex (cd, info, fields->f_brc2, 0, pc, length);
break;
case MS1_OPERAND_CBRB :
print_dollarhex (cd, info, fields->f_cbrb, 0, pc, length);
break;
case MS1_OPERAND_CBS :
print_dollarhex (cd, info, fields->f_cbs, 0, pc, length);
break;
case MS1_OPERAND_CBX :
print_dollarhex (cd, info, fields->f_cbx, 0, pc, length);
break;
case MS1_OPERAND_CCB :
print_dollarhex (cd, info, fields->f_ccb, 0, pc, length);
break;
case MS1_OPERAND_CDB :
print_dollarhex (cd, info, fields->f_cdb, 0, pc, length);
break;
case MS1_OPERAND_CELL :
print_dollarhex (cd, info, fields->f_cell, 0, pc, length);
break;
case MS1_OPERAND_COLNUM :
print_dollarhex (cd, info, fields->f_colnum, 0, pc, length);
break;
case MS1_OPERAND_CONTNUM :
print_dollarhex (cd, info, fields->f_contnum, 0, pc, length);
break;
case MS1_OPERAND_CR :
print_dollarhex (cd, info, fields->f_cr, 0, pc, length);
break;
case MS1_OPERAND_CTXDISP :
print_dollarhex (cd, info, fields->f_ctxdisp, 0, pc, length);
break;
case MS1_OPERAND_DUP :
print_dollarhex (cd, info, fields->f_dup, 0, pc, length);
break;
case MS1_OPERAND_FBDISP :
print_dollarhex (cd, info, fields->f_fbdisp, 0, pc, length);
break;
case MS1_OPERAND_FBINCR :
print_dollarhex (cd, info, fields->f_fbincr, 0, pc, length);
break;
case MS1_OPERAND_FRDR :
print_keyword (cd, info, & ms1_cgen_opval_h_spr, fields->f_dr, 0|(1<<CGEN_OPERAND_ABS_ADDR));
break;
case MS1_OPERAND_FRDRRR :
print_keyword (cd, info, & ms1_cgen_opval_h_spr, fields->f_drrr, 0|(1<<CGEN_OPERAND_ABS_ADDR));
break;
case MS1_OPERAND_FRSR1 :
print_keyword (cd, info, & ms1_cgen_opval_h_spr, fields->f_sr1, 0|(1<<CGEN_OPERAND_ABS_ADDR));
break;
case MS1_OPERAND_FRSR2 :
print_keyword (cd, info, & ms1_cgen_opval_h_spr, fields->f_sr2, 0|(1<<CGEN_OPERAND_ABS_ADDR));
break;
case MS1_OPERAND_ID :
print_dollarhex (cd, info, fields->f_id, 0, pc, length);
break;
case MS1_OPERAND_IMM16 :
print_dollarhex (cd, info, fields->f_imm16s, 0|(1<<CGEN_OPERAND_SIGNED), pc, length);
break;
case MS1_OPERAND_IMM16O :
print_dollarhex (cd, info, fields->f_imm16s, 0, pc, length);
break;
case MS1_OPERAND_IMM16Z :
print_dollarhex (cd, info, fields->f_imm16u, 0, pc, length);
break;
case MS1_OPERAND_INCAMT :
print_dollarhex (cd, info, fields->f_incamt, 0, pc, length);
break;
case MS1_OPERAND_INCR :
print_dollarhex (cd, info, fields->f_incr, 0, pc, length);
break;
case MS1_OPERAND_LENGTH :
print_dollarhex (cd, info, fields->f_length, 0, pc, length);
break;
case MS1_OPERAND_MASK :
print_dollarhex (cd, info, fields->f_mask, 0, pc, length);
break;
case MS1_OPERAND_MASK1 :
print_dollarhex (cd, info, fields->f_mask1, 0, pc, length);
break;
case MS1_OPERAND_MODE :
print_dollarhex (cd, info, fields->f_mode, 0, pc, length);
break;
case MS1_OPERAND_PERM :
print_dollarhex (cd, info, fields->f_perm, 0, pc, length);
break;
case MS1_OPERAND_RBBC :
print_dollarhex (cd, info, fields->f_rbbc, 0, pc, length);
break;
case MS1_OPERAND_RC :
print_dollarhex (cd, info, fields->f_rc, 0, pc, length);
break;
case MS1_OPERAND_RC1 :
print_dollarhex (cd, info, fields->f_rc1, 0, pc, length);
break;
case MS1_OPERAND_RC2 :
print_dollarhex (cd, info, fields->f_rc2, 0, pc, length);
break;
case MS1_OPERAND_RCNUM :
print_dollarhex (cd, info, fields->f_rcnum, 0, pc, length);
break;
case MS1_OPERAND_RDA :
print_dollarhex (cd, info, fields->f_rda, 0, pc, length);
break;
case MS1_OPERAND_ROWNUM :
print_dollarhex (cd, info, fields->f_rownum, 0, pc, length);
break;
case MS1_OPERAND_ROWNUM1 :
print_dollarhex (cd, info, fields->f_rownum1, 0, pc, length);
break;
case MS1_OPERAND_ROWNUM2 :
print_dollarhex (cd, info, fields->f_rownum2, 0, pc, length);
break;
case MS1_OPERAND_SIZE :
print_dollarhex (cd, info, fields->f_size, 0, pc, length);
break;
case MS1_OPERAND_TYPE :
print_dollarhex (cd, info, fields->f_type, 0, pc, length);
break;
case MS1_OPERAND_WR :
print_dollarhex (cd, info, fields->f_wr, 0, pc, length);
break;
case MS1_OPERAND_XMODE :
print_dollarhex (cd, info, fields->f_xmode, 0, pc, length);
break;
default :
fprintf (stderr, _("Unrecognized field %d while printing insn.\n"),
opindex);
abort ();
}
}
cgen_print_fn * const ms1_cgen_print_handlers[] =
{
print_insn_normal,
};
void
ms1_cgen_init_dis (CGEN_CPU_DESC cd)
{
ms1_cgen_init_opcode_table (cd);
ms1_cgen_init_ibld_table (cd);
cd->print_handlers = & ms1_cgen_print_handlers[0];
cd->print_operand = ms1_cgen_print_operand;
}
static void
print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
void *dis_info,
long value,
unsigned int attrs,
bfd_vma pc ATTRIBUTE_UNUSED,
int length ATTRIBUTE_UNUSED)
{
disassemble_info *info = (disassemble_info *) dis_info;
#ifdef CGEN_PRINT_NORMAL
CGEN_PRINT_NORMAL (cd, info, value, attrs, pc, length);
#endif
if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
;
else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
(*info->fprintf_func) (info->stream, "%ld", value);
else
(*info->fprintf_func) (info->stream, "0x%lx", value);
}
static void
print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
void *dis_info,
bfd_vma value,
unsigned int attrs,
bfd_vma pc ATTRIBUTE_UNUSED,
int length ATTRIBUTE_UNUSED)
{
disassemble_info *info = (disassemble_info *) dis_info;
#ifdef CGEN_PRINT_ADDRESS
CGEN_PRINT_ADDRESS (cd, info, value, attrs, pc, length);
#endif
if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
;
else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
(*info->print_address_func) (value, info);
else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
(*info->print_address_func) (value, info);
else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
(*info->fprintf_func) (info->stream, "%ld", (long) value);
else
(*info->fprintf_func) (info->stream, "0x%lx", (long) value);
}
static void
print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
void *dis_info,
CGEN_KEYWORD *keyword_table,
long value,
unsigned int attrs ATTRIBUTE_UNUSED)
{
disassemble_info *info = (disassemble_info *) dis_info;
const CGEN_KEYWORD_ENTRY *ke;
ke = cgen_keyword_lookup_value (keyword_table, value);
if (ke != NULL)
(*info->fprintf_func) (info->stream, "%s", ke->name);
else
(*info->fprintf_func) (info->stream, "???");
}
static void
print_insn_normal (CGEN_CPU_DESC cd,
void *dis_info,
const CGEN_INSN *insn,
CGEN_FIELDS *fields,
bfd_vma pc,
int length)
{
const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
disassemble_info *info = (disassemble_info *) dis_info;
const CGEN_SYNTAX_CHAR_TYPE *syn;
CGEN_INIT_PRINT (cd);
for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
{
if (CGEN_SYNTAX_MNEMONIC_P (*syn))
{
(*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn));
continue;
}
if (CGEN_SYNTAX_CHAR_P (*syn))
{
(*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn));
continue;
}
ms1_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info,
fields, CGEN_INSN_ATTRS (insn), pc, length);
}
}
static int
read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
bfd_vma pc,
disassemble_info *info,
bfd_byte *buf,
int buflen,
CGEN_EXTRACT_INFO *ex_info,
unsigned long *insn_value)
{
int status = (*info->read_memory_func) (pc, buf, buflen, info);
if (status != 0)
{
(*info->memory_error_func) (status, pc, info);
return -1;
}
ex_info->dis_info = info;
ex_info->valid = (1 << buflen) - 1;
ex_info->insn_bytes = buf;
*insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG);
return 0;
}
static int
print_insn (CGEN_CPU_DESC cd,
bfd_vma pc,
disassemble_info *info,
bfd_byte *buf,
unsigned int buflen)
{
CGEN_INSN_INT insn_value;
const CGEN_INSN_LIST *insn_list;
CGEN_EXTRACT_INFO ex_info;
int basesize;
basesize = cd->base_insn_bitsize < buflen * 8 ?
cd->base_insn_bitsize : buflen * 8;
insn_value = cgen_get_insn_value (cd, buf, basesize);
ex_info.valid = (1 << buflen) - 1;
ex_info.dis_info = info;
ex_info.insn_bytes = buf;
insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value);
while (insn_list != NULL)
{
const CGEN_INSN *insn = insn_list->insn;
CGEN_FIELDS fields;
int length;
unsigned long insn_value_cropped;
#ifdef CGEN_VALIDATE_INSN_SUPPORTED
if (! ms1_cgen_insn_supported (cd, insn))
{
insn_list = CGEN_DIS_NEXT_INSN (insn_list);
continue;
}
#endif
if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen &&
(unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn),
info->endian == BFD_ENDIAN_BIG);
else
insn_value_cropped = insn_value;
if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn))
== CGEN_INSN_BASE_VALUE (insn))
{
if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) &&
(unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
{
unsigned long full_insn_value;
int rc = read_insn (cd, pc, info, buf,
CGEN_INSN_BITSIZE (insn) / 8,
& ex_info, & full_insn_value);
if (rc != 0)
return rc;
length = CGEN_EXTRACT_FN (cd, insn)
(cd, insn, &ex_info, full_insn_value, &fields, pc);
}
else
length = CGEN_EXTRACT_FN (cd, insn)
(cd, insn, &ex_info, insn_value_cropped, &fields, pc);
if (length < 0)
return length;
if (length > 0)
{
CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length);
return length / 8;
}
}
insn_list = CGEN_DIS_NEXT_INSN (insn_list);
}
return 0;
}
#ifndef CGEN_PRINT_INSN
#define CGEN_PRINT_INSN default_print_insn
#endif
static int
default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info)
{
bfd_byte buf[CGEN_MAX_INSN_SIZE];
int buflen;
int status;
buflen = cd->base_insn_bitsize / 8;
status = (*info->read_memory_func) (pc, buf, buflen, info);
if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
{
buflen = cd->min_insn_bitsize / 8;
status = (*info->read_memory_func) (pc, buf, buflen, info);
}
if (status != 0)
{
(*info->memory_error_func) (status, pc, info);
return -1;
}
return print_insn (cd, pc, info, buf, buflen);
}
typedef struct cpu_desc_list
{
struct cpu_desc_list *next;
int isa;
int mach;
int endian;
CGEN_CPU_DESC cd;
} cpu_desc_list;
int
print_insn_ms1 (bfd_vma pc, disassemble_info *info)
{
static cpu_desc_list *cd_list = 0;
cpu_desc_list *cl = 0;
static CGEN_CPU_DESC cd = 0;
static int prev_isa;
static int prev_mach;
static int prev_endian;
int length;
int isa,mach;
int endian = (info->endian == BFD_ENDIAN_BIG
? CGEN_ENDIAN_BIG
: CGEN_ENDIAN_LITTLE);
enum bfd_architecture arch;
#ifndef CGEN_BFD_ARCH
#define CGEN_BFD_ARCH bfd_arch_ms1
#endif
arch = info->arch;
if (arch == bfd_arch_unknown)
arch = CGEN_BFD_ARCH;
#ifdef CGEN_COMPUTE_MACH
mach = CGEN_COMPUTE_MACH (info);
#else
mach = info->mach;
#endif
#ifdef CGEN_COMPUTE_ISA
isa = CGEN_COMPUTE_ISA (info);
#else
isa = info->insn_sets;
#endif
if (cd
&& (isa != prev_isa
|| mach != prev_mach
|| endian != prev_endian))
{
cd = 0;
for (cl = cd_list; cl; cl = cl->next)
{
if (cl->isa == isa &&
cl->mach == mach &&
cl->endian == endian)
{
cd = cl->cd;
break;
}
}
}
if (! cd)
{
const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach);
const char *mach_name;
if (!arch_type)
abort ();
mach_name = arch_type->printable_name;
prev_isa = isa;
prev_mach = mach;
prev_endian = endian;
cd = ms1_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa,
CGEN_CPU_OPEN_BFDMACH, mach_name,
CGEN_CPU_OPEN_ENDIAN, prev_endian,
CGEN_CPU_OPEN_END);
if (!cd)
abort ();
cl = xmalloc (sizeof (struct cpu_desc_list));
cl->cd = cd;
cl->isa = isa;
cl->mach = mach;
cl->endian = endian;
cl->next = cd_list;
cd_list = cl;
ms1_cgen_init_dis (cd);
}
length = CGEN_PRINT_INSN (cd, pc, info);
if (length > 0)
return length;
if (length < 0)
return -1;
(*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
return cd->default_insn_bitsize / 8;
}