mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-23 18:14:13 +08:00
473 lines
12 KiB
C
473 lines
12 KiB
C
/* Morpho Technologies mRISC opcode support, for GNU Binutils. -*- C -*-
|
||
Copyright 2001, 2007, 2008, 2009, 2012 Free Software Foundation, Inc.
|
||
|
||
Contributed by Red Hat Inc; developed under contract from
|
||
Morpho Technologies.
|
||
|
||
This file is part of the GNU Binutils.
|
||
|
||
This program 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 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program 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 program; if not, write to the Free Software
|
||
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
||
MA 02110-1301, USA. */
|
||
|
||
|
||
/* Each section is delimited with start and end markers.
|
||
|
||
<arch>-opc.h additions use: "-- opc.h"
|
||
<arch>-opc.c additions use: "-- opc.c"
|
||
<arch>-asm.c additions use: "-- asm.c"
|
||
<arch>-dis.c additions use: "-- dis.c"
|
||
<arch>-ibd.h additions use: "-- ibd.h" */
|
||
|
||
/* -- opc.h */
|
||
|
||
/* Check applicability of instructions against machines. */
|
||
#define CGEN_VALIDATE_INSN_SUPPORTED
|
||
|
||
/* Allows reason codes to be output when assembler errors occur. */
|
||
#define CGEN_VERBOSE_ASSEMBLER_ERRORS
|
||
|
||
/* Override disassembly hashing - there are variable bits in the top
|
||
byte of these instructions. */
|
||
#define CGEN_DIS_HASH_SIZE 8
|
||
#define CGEN_DIS_HASH(buf, value) (((* (unsigned char *) (buf)) >> 5) % CGEN_DIS_HASH_SIZE)
|
||
|
||
#define CGEN_ASM_HASH_SIZE 127
|
||
#define CGEN_ASM_HASH(insn) mt_asm_hash (insn)
|
||
|
||
extern unsigned int mt_asm_hash (const char *);
|
||
|
||
extern int mt_cgen_insn_supported (CGEN_CPU_DESC, const CGEN_INSN *);
|
||
|
||
|
||
/* -- opc.c */
|
||
#include "safe-ctype.h"
|
||
|
||
/* Special check to ensure that instruction exists for given machine. */
|
||
|
||
int
|
||
mt_cgen_insn_supported (CGEN_CPU_DESC cd, const CGEN_INSN *insn)
|
||
{
|
||
int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
|
||
|
||
/* No mach attribute? Assume it's supported for all machs. */
|
||
if (machs == 0)
|
||
return 1;
|
||
|
||
return ((machs & cd->machs) != 0);
|
||
}
|
||
|
||
/* A better hash function for instruction mnemonics. */
|
||
|
||
unsigned int
|
||
mt_asm_hash (const char* insn)
|
||
{
|
||
unsigned int hash;
|
||
const char* m = insn;
|
||
|
||
for (hash = 0; *m && ! ISSPACE (*m); m++)
|
||
hash = (hash * 23) ^ (0x1F & TOLOWER (*m));
|
||
|
||
/* printf ("%s %d\n", insn, (hash % CGEN_ASM_HASH_SIZE)); */
|
||
|
||
return hash % CGEN_ASM_HASH_SIZE;
|
||
}
|
||
|
||
|
||
/* -- asm.c */
|
||
/* Range checking for signed numbers. Returns 0 if acceptable
|
||
and 1 if the value is out of bounds for a signed quantity. */
|
||
|
||
static int
|
||
signed_out_of_bounds (long val)
|
||
{
|
||
if ((val < -32768) || (val > 32767))
|
||
return 1;
|
||
return 0;
|
||
}
|
||
|
||
static const char *
|
||
parse_loopsize (CGEN_CPU_DESC cd,
|
||
const char **strp,
|
||
int opindex,
|
||
void *arg)
|
||
{
|
||
signed long * valuep = (signed long *) arg;
|
||
const char *errmsg;
|
||
bfd_reloc_code_real_type code = BFD_RELOC_NONE;
|
||
enum cgen_parse_operand_result result_type;
|
||
bfd_vma value;
|
||
|
||
/* Is it a control transfer instructions? */
|
||
if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_LOOPSIZE)
|
||
{
|
||
code = BFD_RELOC_MT_PCINSN8;
|
||
errmsg = cgen_parse_address (cd, strp, opindex, code,
|
||
& result_type, & value);
|
||
*valuep = value;
|
||
return errmsg;
|
||
}
|
||
|
||
abort ();
|
||
}
|
||
|
||
static const char *
|
||
parse_imm16 (CGEN_CPU_DESC cd,
|
||
const char **strp,
|
||
int opindex,
|
||
void *arg)
|
||
{
|
||
signed long * valuep = (signed long *) arg;
|
||
const char *errmsg;
|
||
enum cgen_parse_operand_result result_type;
|
||
bfd_reloc_code_real_type code = BFD_RELOC_NONE;
|
||
bfd_vma value;
|
||
|
||
/* Is it a control transfer instructions? */
|
||
if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16O)
|
||
{
|
||
code = BFD_RELOC_16_PCREL;
|
||
errmsg = cgen_parse_address (cd, strp, opindex, code,
|
||
& result_type, & value);
|
||
if (errmsg == NULL)
|
||
{
|
||
if (signed_out_of_bounds (value))
|
||
errmsg = _("Operand out of range. Must be between -32768 and 32767.");
|
||
}
|
||
*valuep = value;
|
||
return errmsg;
|
||
}
|
||
|
||
/* If it's not a control transfer instruction, then
|
||
we have to check for %OP relocating operators. */
|
||
if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16L)
|
||
;
|
||
else if (strncmp (*strp, "%hi16", 5) == 0)
|
||
{
|
||
*strp += 5;
|
||
code = BFD_RELOC_HI16;
|
||
}
|
||
else if (strncmp (*strp, "%lo16", 5) == 0)
|
||
{
|
||
*strp += 5;
|
||
code = BFD_RELOC_LO16;
|
||
}
|
||
|
||
/* If we found a %OP relocating operator, then parse it as an address.
|
||
If not, we need to parse it as an integer, either signed or unsigned
|
||
depending on which operand type we have. */
|
||
if (code != BFD_RELOC_NONE)
|
||
{
|
||
/* %OP relocating operator found. */
|
||
errmsg = cgen_parse_address (cd, strp, opindex, code,
|
||
& result_type, & value);
|
||
if (errmsg == NULL)
|
||
{
|
||
switch (result_type)
|
||
{
|
||
case (CGEN_PARSE_OPERAND_RESULT_NUMBER):
|
||
if (code == BFD_RELOC_HI16)
|
||
value = (value >> 16) & 0xFFFF;
|
||
else if (code == BFD_RELOC_LO16)
|
||
value = value & 0xFFFF;
|
||
else
|
||
errmsg = _("Biiiig Trouble in parse_imm16!");
|
||
break;
|
||
|
||
case (CGEN_PARSE_OPERAND_RESULT_QUEUED):
|
||
/* No special processing for this case. */
|
||
break;
|
||
|
||
default:
|
||
errmsg = _("The percent-operator's operand is not a symbol");
|
||
break;
|
||
}
|
||
}
|
||
*valuep = value;
|
||
}
|
||
else
|
||
{
|
||
/* Parse hex values like 0xffff as unsigned, and sign extend
|
||
them manually. */
|
||
int parse_signed = (opindex == (CGEN_OPERAND_TYPE)MT_OPERAND_IMM16);
|
||
|
||
if ((*strp)[0] == '0'
|
||
&& ((*strp)[1] == 'x' || (*strp)[1] == 'X'))
|
||
parse_signed = 0;
|
||
|
||
/* No relocating operator. Parse as an number. */
|
||
if (parse_signed)
|
||
{
|
||
/* Parse as as signed integer. */
|
||
|
||
errmsg = cgen_parse_signed_integer (cd, strp, opindex, valuep);
|
||
|
||
if (errmsg == NULL)
|
||
{
|
||
#if 0
|
||
/* Manual range checking is needed for the signed case. */
|
||
if (*valuep & 0x8000)
|
||
value = 0xffff0000 | *valuep;
|
||
else
|
||
value = *valuep;
|
||
|
||
if (signed_out_of_bounds (value))
|
||
errmsg = _("Operand out of range. Must be between -32768 and 32767.");
|
||
/* Truncate to 16 bits. This is necessary
|
||
because cgen will have sign extended *valuep. */
|
||
*valuep &= 0xFFFF;
|
||
#endif
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* MT_OPERAND_IMM16Z. Parse as an unsigned integer. */
|
||
errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, (unsigned long *) valuep);
|
||
|
||
if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16
|
||
&& *valuep >= 0x8000
|
||
&& *valuep <= 0xffff)
|
||
*valuep -= 0x10000;
|
||
}
|
||
}
|
||
|
||
return errmsg;
|
||
}
|
||
|
||
|
||
static const char *
|
||
parse_dup (CGEN_CPU_DESC cd,
|
||
const char **strp,
|
||
int opindex,
|
||
unsigned long *valuep)
|
||
{
|
||
const char *errmsg = NULL;
|
||
|
||
if (strncmp (*strp, "dup", 3) == 0 || strncmp (*strp, "DUP", 3) == 0)
|
||
{
|
||
*strp += 3;
|
||
*valuep = 1;
|
||
}
|
||
else if (strncmp (*strp, "xx", 2) == 0 || strncmp (*strp, "XX", 2) == 0)
|
||
{
|
||
*strp += 2;
|
||
*valuep = 0;
|
||
}
|
||
else
|
||
errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
|
||
|
||
return errmsg;
|
||
}
|
||
|
||
|
||
static const char *
|
||
parse_ball (CGEN_CPU_DESC cd,
|
||
const char **strp,
|
||
int opindex,
|
||
unsigned long *valuep)
|
||
{
|
||
const char *errmsg = NULL;
|
||
|
||
if (strncmp (*strp, "all", 3) == 0 || strncmp (*strp, "ALL", 3) == 0)
|
||
{
|
||
*strp += 3;
|
||
*valuep = 1;
|
||
}
|
||
else if (strncmp (*strp, "one", 3) == 0 || strncmp (*strp, "ONE", 3) == 0)
|
||
{
|
||
*strp += 3;
|
||
*valuep = 0;
|
||
}
|
||
else
|
||
errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
|
||
|
||
return errmsg;
|
||
}
|
||
|
||
static const char *
|
||
parse_xmode (CGEN_CPU_DESC cd,
|
||
const char **strp,
|
||
int opindex,
|
||
unsigned long *valuep)
|
||
{
|
||
const char *errmsg = NULL;
|
||
|
||
if (strncmp (*strp, "pm", 2) == 0 || strncmp (*strp, "PM", 2) == 0)
|
||
{
|
||
*strp += 2;
|
||
*valuep = 1;
|
||
}
|
||
else if (strncmp (*strp, "xm", 2) == 0 || strncmp (*strp, "XM", 2) == 0)
|
||
{
|
||
*strp += 2;
|
||
*valuep = 0;
|
||
}
|
||
else
|
||
errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
|
||
|
||
return errmsg;
|
||
}
|
||
|
||
static const char *
|
||
parse_rc (CGEN_CPU_DESC cd,
|
||
const char **strp,
|
||
int opindex,
|
||
unsigned long *valuep)
|
||
{
|
||
const char *errmsg = NULL;
|
||
|
||
if (strncmp (*strp, "r", 1) == 0 || strncmp (*strp, "R", 1) == 0)
|
||
{
|
||
*strp += 1;
|
||
*valuep = 1;
|
||
}
|
||
else if (strncmp (*strp, "c", 1) == 0 || strncmp (*strp, "C", 1) == 0)
|
||
{
|
||
*strp += 1;
|
||
*valuep = 0;
|
||
}
|
||
else
|
||
errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
|
||
|
||
return errmsg;
|
||
}
|
||
|
||
static const char *
|
||
parse_cbrb (CGEN_CPU_DESC cd,
|
||
const char **strp,
|
||
int opindex,
|
||
unsigned long *valuep)
|
||
{
|
||
const char *errmsg = NULL;
|
||
|
||
if (strncmp (*strp, "rb", 2) == 0 || strncmp (*strp, "RB", 2) == 0)
|
||
{
|
||
*strp += 2;
|
||
*valuep = 1;
|
||
}
|
||
else if (strncmp (*strp, "cb", 2) == 0 || strncmp (*strp, "CB", 2) == 0)
|
||
{
|
||
*strp += 2;
|
||
*valuep = 0;
|
||
}
|
||
else
|
||
errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
|
||
|
||
return errmsg;
|
||
}
|
||
|
||
static const char *
|
||
parse_rbbc (CGEN_CPU_DESC cd,
|
||
const char **strp,
|
||
int opindex,
|
||
unsigned long *valuep)
|
||
{
|
||
const char *errmsg = NULL;
|
||
|
||
if (strncmp (*strp, "rt", 2) == 0 || strncmp (*strp, "RT", 2) == 0)
|
||
{
|
||
*strp += 2;
|
||
*valuep = 0;
|
||
}
|
||
else if (strncmp (*strp, "br1", 3) == 0 || strncmp (*strp, "BR1", 3) == 0)
|
||
{
|
||
*strp += 3;
|
||
*valuep = 1;
|
||
}
|
||
else if (strncmp (*strp, "br2", 3) == 0 || strncmp (*strp, "BR2", 3) == 0)
|
||
{
|
||
*strp += 3;
|
||
*valuep = 2;
|
||
}
|
||
else if (strncmp (*strp, "cs", 2) == 0 || strncmp (*strp, "CS", 2) == 0)
|
||
{
|
||
*strp += 2;
|
||
*valuep = 3;
|
||
}
|
||
else
|
||
errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
|
||
|
||
return errmsg;
|
||
}
|
||
|
||
static const char *
|
||
parse_type (CGEN_CPU_DESC cd,
|
||
const char **strp,
|
||
int opindex,
|
||
unsigned long *valuep)
|
||
{
|
||
const char *errmsg = NULL;
|
||
|
||
if (strncmp (*strp, "odd", 3) == 0 || strncmp (*strp, "ODD", 3) == 0)
|
||
{
|
||
*strp += 3;
|
||
*valuep = 0;
|
||
}
|
||
else if (strncmp (*strp, "even", 4) == 0 || strncmp (*strp, "EVEN", 4) == 0)
|
||
{
|
||
*strp += 4;
|
||
*valuep = 1;
|
||
}
|
||
else if (strncmp (*strp, "oe", 2) == 0 || strncmp (*strp, "OE", 2) == 0)
|
||
{
|
||
*strp += 2;
|
||
*valuep = 2;
|
||
}
|
||
else
|
||
errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
|
||
|
||
if ((errmsg == NULL) && (*valuep == 3))
|
||
errmsg = _("invalid operand. type may have values 0,1,2 only.");
|
||
|
||
return errmsg;
|
||
}
|
||
|
||
/* -- dis.c */
|
||
static void print_dollarhex (CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int);
|
||
static void print_pcrel (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 & 0xffffffff);
|
||
|
||
if (0)
|
||
print_normal (cd, dis_info, value, attrs, pc, length);
|
||
}
|
||
|
||
static void
|
||
print_pcrel (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)
|
||
{
|
||
print_address (cd, dis_info, value + pc, attrs, pc, length);
|
||
}
|
||
|
||
/* -- */
|
||
|
||
|
||
|
||
|
||
|