aboutsummaryrefslogtreecommitdiff
path: root/cpu/m32c.opc
diff options
context:
space:
mode:
Diffstat (limited to 'cpu/m32c.opc')
-rw-r--r--cpu/m32c.opc1157
1 files changed, 1157 insertions, 0 deletions
diff --git a/cpu/m32c.opc b/cpu/m32c.opc
new file mode 100644
index 0000000..b918c05
--- /dev/null
+++ b/cpu/m32c.opc
@@ -0,0 +1,1157 @@
+/* m32c opcode support. -*- C -*-
+ Copyright (C) 2005 Red Hat, Inc.
+ This file is part of CGEN. */
+
+/* This file is an addendum to m32c.cpu. Heavy use of C code isn't
+ appropriate in .cpu files, so it resides here. This especially applies
+ to assembly/disassembly where parsing/printing can be quite involved.
+ Such things aren't really part of the specification of the cpu, per se,
+ so .cpu files provide the general framework and .opc files handle the
+ nitty-gritty details as necessary.
+
+ 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 */
+
+/* Needed for RTL's 'ext' and 'trunc' operators. */
+#include "cgen-types.h"
+#include "cgen-ops.h"
+
+/* We can't use the default hash size because many bits are used by
+ operands. */
+#define CGEN_DIS_HASH_SIZE 1
+#define CGEN_DIS_HASH(buf, value) 0
+#define CGEN_VERBOSE_ASSEMBLER_ERRORS
+#define CGEN_VALIDATE_INSN_SUPPORTED
+
+extern int m32c_cgen_insn_supported (CGEN_CPU_DESC, const CGEN_INSN *);
+
+#define CGEN_ASM_HASH_SIZE 0xffff
+#define CGEN_ASM_HASH(mnem) m32c_asm_hash ((mnem))
+
+/* -- */
+
+/* -- opc.c */
+static unsigned int
+m32c_asm_hash (const char *mnem)
+{
+ unsigned int h;
+
+ /* The length of the mnemonic for the Jcnd insns is 1. Hash jsri. */
+ if (mnem[0] == 'j' && mnem[1] != 's')
+ return 'j';
+
+ /* Don't hash scCND */
+ if (mnem[0] == 's' && mnem[1] == 'c')
+ return 's';
+
+ for (h = 0; *mnem && *mnem != ' ' && *mnem != ':'; ++mnem)
+ h += *mnem;
+ return h % CGEN_ASM_HASH_SIZE;
+}
+
+/* -- asm.c */
+#include <ctype.h>
+
+#define MACH_M32C 5 /* Must match md_begin. */
+
+static int
+m32c_cgen_isa_register (const char **strp)
+ {
+ int u;
+ const char *s = *strp;
+ static char * m32c_register_names [] =
+ {
+ "r0", "r1", "r2", "r3", "r0l", "r0h", "r1l", "r1h",
+ "a0", "a1", "r2r0", "r3r1", "sp", "fb", "dct0", "dct1", "flg", "svf",
+ "drc0", "drc1", "dmd0", "dmd1", "intb", "svp", "vct", "isp", "dma0",
+ "dma1", "dra0", "dra1", "dsa0", "dsa1", 0
+ };
+
+ for (u = 0; m32c_register_names[u]; u++)
+ {
+ int len = strlen (m32c_register_names[u]);
+
+ if (memcmp (m32c_register_names[u], s, len) == 0
+ && (s[len] == 0 || ! ISALNUM (s[len])))
+ return 1;
+ }
+ return 0;
+}
+
+static const char *
+parse_unsigned6 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ const char *errmsg = 0;
+ unsigned long value;
+ long have_zero = 0;
+
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ if (strncmp (*strp, "0x0", 3) == 0
+ || (**strp == '0' && *(*strp + 1) != 'x'))
+ have_zero = 1;
+
+ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value > 0x3f)
+ return _("imm:6 immediate is out of range");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_unsigned8 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ const char *errmsg = 0;
+ unsigned long value;
+ long have_zero = 0;
+
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ if (strncmp (*strp, "0x0", 3) == 0
+ || (**strp == '0' && *(*strp + 1) != 'x'))
+ have_zero = 1;
+
+ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value > 0xff)
+ return _("dsp:8 immediate is out of range");
+
+ /* If this field may require a relocation then use larger dsp16. */
+ if (! have_zero && value == 0)
+ return _("dsp:8 immediate is out of range");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_signed4 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep)
+{
+ const char *errmsg = 0;
+ signed long value;
+ long have_zero = 0;
+
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ if (strncmp (*strp, "0x0", 3) == 0
+ || (**strp == '0' && *(*strp + 1) != 'x'))
+ have_zero = 1;
+
+ errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value < -8 || value > 7)
+ return _("Immediate is out of range -8 to 7");
+
+ /* If this field may require a relocation then use larger dsp16. */
+ if (! have_zero && value == 0)
+ return _("Immediate is out of range -8 to 7");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_signed8 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep)
+{
+ const char *errmsg = 0;
+ signed long value;
+
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value <= 255 && value > 127)
+ value -= 0x100;
+
+ if (value < -128 || value > 127)
+ return _("dsp:8 immediate is out of range");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_unsigned16 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ const char *errmsg = 0;
+ unsigned long value;
+ long have_zero = 0;
+
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ /* Don't successfully parse register names */
+ if (m32c_cgen_isa_register (strp))
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ if (strncmp (*strp, "0x0", 3) == 0
+ || (**strp == '0' && *(*strp + 1) != 'x'))
+ have_zero = 1;
+
+ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value > 0xffff)
+ return _("dsp:16 immediate is out of range");
+
+ /* If this field may require a relocation then use larger dsp24. */
+ if (cd->machs == MACH_M32C && ! have_zero && value == 0
+ && (strncmp (*strp, "[a", 2) == 0
+ || **strp == ','
+ || **strp == 0))
+ return _("dsp:16 immediate is out of range");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_signed16 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep)
+{
+ const char *errmsg = 0;
+ signed long value;
+
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value <= 65535 && value > 32767)
+ value -= 0x10000;
+
+ if (value < -32768 || value > 32767)
+ return _("dsp:16 immediate is out of range");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_unsigned20 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ const char *errmsg = 0;
+ unsigned long value;
+
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ /* Don't successfully parse register names */
+ if (m32c_cgen_isa_register (strp))
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value > 0xfffff)
+ return _("dsp:20 immediate is out of range");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_unsigned24 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ const char *errmsg = 0;
+ unsigned long value;
+
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ /* Don't successfully parse register names */
+ if (m32c_cgen_isa_register (strp))
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value > 0xffffff)
+ return _("dsp:24 immediate is out of range");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_signed32 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep)
+{
+ const char *errmsg = 0;
+ signed long value;
+
+#if 0
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ /* Don't successfully parse register names */
+ if (m32c_cgen_isa_register (strp))
+ return "Invalid literal"; /* anything -- will not be seen */
+#endif
+
+ errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_imm1_S (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep)
+{
+ const char *errmsg = 0;
+ signed long value;
+
+#if 0
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ /* Don't successfully parse register names */
+ if (m32c_cgen_isa_register (strp))
+ return "Invalid literal"; /* anything -- will not be seen */
+#endif
+
+ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value < 1 || value > 2)
+ return _("immediate is out of range 1-2");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_imm3_S (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep)
+{
+ const char *errmsg = 0;
+ signed long value;
+
+#if 0
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+
+ /* Don't successfully parse register names */
+ if (m32c_cgen_isa_register (strp))
+ return "Invalid literal"; /* anything -- will not be seen */
+#endif
+
+ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value < 1 || value > 8)
+ return _("immediate is out of range 1-8");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_Bitno16R (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ const char *errmsg = 0;
+ unsigned long value;
+
+#if 0
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+#endif
+
+ errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (value > 15)
+ return _("Bit number for indexing general register is out of range 0-15");
+
+ *valuep = value;
+ return 0;
+}
+
+static const char *
+parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep,
+ unsigned bits)
+{
+ const char *errmsg = 0;
+ unsigned long bit;
+ unsigned long base;
+ const char *newp = *strp;
+ unsigned long long bitbase;
+
+#if 0
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+#endif
+
+ errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
+ if (errmsg)
+ return errmsg;
+
+ if (*newp != ',')
+ return "Missing base for bit,base:8";
+
+ ++newp;
+ errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & base);
+ if (errmsg)
+ return errmsg;
+
+ bitbase = (unsigned long long)bit + ((unsigned long long)base * 8);
+
+ if (bitbase >= (1ull << bits))
+ return _("bit,base is out of range");
+
+ *valuep = bitbase;
+ *strp = newp;
+ return 0;
+}
+
+static const char *
+parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep,
+ unsigned bits)
+{
+ const char *errmsg = 0;
+ unsigned long bit;
+ signed long base;
+ const char *newp = *strp;
+ long long bitbase;
+ long long limit;
+
+#if 0
+ /* Don't successfully parse literals beginning with '[' */
+ if (**strp == '[')
+ return "Invalid literal"; /* anything -- will not be seen */
+#endif
+
+ errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
+ if (errmsg)
+ return errmsg;
+
+ if (*newp != ',')
+ return "Missing base for bit,base:8";
+
+ ++newp;
+ errmsg = cgen_parse_signed_integer (cd, & newp, opindex, & base);
+ if (errmsg)
+ return errmsg;
+
+ bitbase = (long long)bit + ((long long)base * 8);
+
+ limit = 1ll << (bits - 1);
+ if (bitbase < -limit || bitbase >= limit)
+ return _("bit,base is out of range");
+
+ *valuep = bitbase;
+ *strp = newp;
+ return 0;
+}
+
+static const char *
+parse_unsigned_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ return parse_unsigned_bitbase (cd, strp, opindex, valuep, 8);
+}
+
+static const char *
+parse_unsigned_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ return parse_unsigned_bitbase (cd, strp, opindex, valuep, 11);
+}
+
+static const char *
+parse_unsigned_bitbase16 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ return parse_unsigned_bitbase (cd, strp, opindex, valuep, 16);
+}
+
+static const char *
+parse_unsigned_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ return parse_unsigned_bitbase (cd, strp, opindex, valuep, 19);
+}
+
+static const char *
+parse_unsigned_bitbase27 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, unsigned long *valuep)
+{
+ return parse_unsigned_bitbase (cd, strp, opindex, valuep, 27);
+}
+
+static const char *
+parse_signed_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep)
+{
+ return parse_signed_bitbase (cd, strp, opindex, valuep, 8);
+}
+
+static const char *
+parse_signed_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep)
+{
+ return parse_signed_bitbase (cd, strp, opindex, valuep, 11);
+}
+
+static const char *
+parse_signed_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
+ int opindex, signed long *valuep)
+{
+ return parse_signed_bitbase (cd, strp, opindex, valuep, 19);
+}
+
+/* Parse the suffix as :<char> or as nothing followed by a whitespace. */
+static const char *
+parse_suffix (const char **strp, char suffix)
+{
+ const char *newp = *strp;
+
+ if (**strp == ':' && tolower (*(*strp + 1)) == suffix)
+ newp = *strp + 2;
+
+ if (isspace (*newp))
+ {
+ *strp = newp;
+ return 0;
+ }
+
+ return "Invalid suffix"; /* anything -- will not be seen */
+}
+
+static const char *
+parse_S (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
+ int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
+{
+ return parse_suffix (strp, 's');
+}
+
+static const char *
+parse_G (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
+ int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
+{
+ return parse_suffix (strp, 'g');
+}
+
+static const char *
+parse_Q (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
+ int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
+{
+ return parse_suffix (strp, 'q');
+}
+
+static const char *
+parse_Z (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
+ int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
+{
+ return parse_suffix (strp, 'z');
+}
+
+/* Parse an empty suffix. Fail if the next char is ':'. */
+static const char *
+parse_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
+ int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
+{
+ if (**strp == ':')
+ return "Unexpected suffix";
+ return 0;
+}
+
+static const char *
+parse_r0l_r0h (CGEN_CPU_DESC cd, const char **strp,
+ int opindex ATTRIBUTE_UNUSED, signed long *valuep)
+{
+ const char *errmsg;
+ signed long value;
+ signed long junk;
+ const char *newp = *strp;
+
+ /* Parse r0[hl] */
+ errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l_r0h, & value);
+ if (errmsg)
+ return errmsg;
+
+ if (*newp != ',')
+ return "not a valid r0l/r0h pair";
+ ++newp;
+
+ /* Parse the second register in the pair */
+ if (value == 0) /* r0l */
+ errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0h, & junk);
+ else
+ errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l, & junk);
+ if (errmsg)
+ return errmsg;
+
+ *strp = newp;
+ *valuep = ! value;
+ return 0;
+}
+
+/* Accept .b or .w in any case */
+static const char *
+parse_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
+ int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
+{
+ if (**strp == '.'
+ && (*(*strp + 1) == 'b' || *(*strp + 1) == 'B'
+ || *(*strp + 1) == 'w' || *(*strp + 1) == 'W'))
+ {
+ *strp += 2;
+ return 0;
+ }
+ return "Invalid size specifier";
+}
+
+/* static const char * parse_abs (CGEN_CPU_DESC, const char **, int, */
+/* unsigned long *, unsigned long); */
+/* static const char * parse_abs16 (CGEN_CPU_DESC, const char **, int, */
+/* int ATTRIBUTE_UNUSED, */
+/* enum cgen_parse_operand_result * ATTRIBUTE_UNUSED, */
+/* unsigned long * ); */
+/* static const char * parse_abs24 (CGEN_CPU_DESC, const char **, int, */
+/* int ATTRIBUTE_UNUSED, */
+/* enum cgen_parse_operand_result * ATTRIBUTE_UNUSED, */
+/* unsigned long *); */
+
+/* /\* Parse absolute *\/ */
+
+/* static const char * */
+/* parse_abs16 (CGEN_CPU_DESC cd, const char **strp, int opindex, */
+/* int reloc ATTRIBUTE_UNUSED, */
+/* enum cgen_parse_operand_result *type_addr ATTRIBUTE_UNUSED, */
+/* unsigned long *valuep) */
+/* { */
+/* return parse_abs (cd, strp, opindex, valuep, 16); */
+/* } */
+
+/* static const char * */
+/* parse_abs24 (CGEN_CPU_DESC cd, const char **strp, int opindex, */
+/* int reloc ATTRIBUTE_UNUSED, */
+/* enum cgen_parse_operand_result *type_addr ATTRIBUTE_UNUSED, */
+/* unsigned long *valuep) */
+/* { */
+/* return parse_abs (cd, strp, opindex, valuep, 24); */
+/* } */
+
+/* static const char * */
+/* parse_abs (CGEN_CPU_DESC cd, const char **strp, int opindex, */
+/* unsigned long *valuep, */
+/* unsigned long length) */
+/* { */
+/* const char *errmsg = 0; */
+/* const char *op; */
+/* int has_register = 0; */
+
+/* for (op = *strp; *op != '\0'; op++) */
+/* { */
+/* if (*op == '[') */
+/* { */
+/* has_register = 1; */
+/* break; */
+/* } */
+/* else if (*op == ',') */
+/* break; */
+/* } */
+
+/* if (has_register || m32c_cgen_isa_register (strp)) */
+/* errmsg = _("immediate value cannot be register"); */
+/* else */
+/* { */
+/* enum cgen_parse_operand_result result_type; */
+/* bfd_vma value; */
+/* const char *errmsg; */
+
+/* errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16, */
+/* &result_type, &value); */
+/* *valuep = value; */
+/* } */
+/* return errmsg; */
+/* } */
+/* /\* Handle signed/unsigned literal. *\/ */
+
+/* static const char * */
+/* parse_imm8 (cd, strp, opindex, valuep) */
+/* CGEN_CPU_DESC cd; */
+/* const char **strp; */
+/* int opindex; */
+/* unsigned long *valuep; */
+/* { */
+/* const char *errmsg = 0; */
+/* long value; */
+/* long have_zero = 0; */
+
+/* if (strncmp (*strp, "0x0", 3) == 0 */
+/* || (**strp == '0' && *(*strp + 1) != 'x')) */
+/* have_zero = 1; */
+/* errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
+/* *valuep = value; */
+/* /\* If this field may require a relocation then use larger dsp16. *\/ */
+/* if (! have_zero && value == 0) */
+/* errmsg = _("immediate value may not fit in dsp8 field"); */
+
+/* return errmsg; */
+/* } */
+
+/* static const char * */
+/* parse_imm16 (cd, strp, opindex, valuep) */
+/* CGEN_CPU_DESC cd; */
+/* const char **strp; */
+/* int opindex; */
+/* unsigned long *valuep; */
+/* { */
+/* const char *errmsg; */
+/* long value; */
+
+/* errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
+/* *valuep = value; */
+/* return errmsg; */
+/* } */
+
+/* static const char * */
+/* parse_imm24 (cd, strp, opindex, valuep) */
+/* CGEN_CPU_DESC cd; */
+/* const char **strp; */
+/* int opindex; */
+/* unsigned long *valuep; */
+/* { */
+/* const char *errmsg; */
+/* long value; */
+
+/* errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
+/* *valuep = value; */
+/* return errmsg; */
+/* } */
+
+/* static const char * */
+/* parse_imm32 (cd, strp, opindex, valuep) */
+/* CGEN_CPU_DESC cd; */
+/* const char **strp; */
+/* int opindex; */
+/* unsigned long *valuep; */
+/* { */
+/* const char *errmsg; */
+/* long value; */
+
+/* errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
+/* *valuep = value; */
+/* return errmsg; */
+/* } */
+
+/* /\* Handle bitfields. *\/ */
+
+/* static const char * */
+/* parse_boff8 (cd, strp, opindex, valuep) */
+/* CGEN_CPU_DESC cd; */
+/* const char **strp; */
+/* int opindex; */
+/* unsigned long *valuep; */
+/* { */
+/* const char *errmsg; */
+/* long bit_value, value; */
+
+/* errmsg = cgen_parse_signed_integer (cd, strp, opindex, & bit_value); */
+/* if (errmsg == 0) */
+/* { */
+/* *strp = *strp + 1; */
+/* errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
+/* } */
+/* value = value * 8 + bit_value; */
+/* *valuep = value; */
+/* if (value > 0x100) */
+/* errmsg = _("Operand out of range. Must be between 0 and 255."); */
+/* return errmsg; */
+/* } */
+
+/* static const char * */
+/* parse_boff16 (cd, strp, opindex, valuep) */
+/* CGEN_CPU_DESC cd; */
+/* const char **strp; */
+/* int opindex; */
+/* unsigned long *valuep; */
+/* { */
+/* const char *errmsg; */
+/* long bit_value, value; */
+
+/* errmsg = cgen_parse_signed_integer (cd, strp, opindex, & bit_value); */
+/* if (errmsg == 0) */
+/* { */
+/* *strp = *strp + 1; */
+/* errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
+/* } */
+/* value = value * 8 + bit_value; */
+/* *valuep = value; */
+/* if (value > 0x1000) */
+/* errmsg = _("Operand out of range. Must be between 0 and 65535."); */
+/* return errmsg; */
+/* } */
+
+
+/* Special check to ensure that instruction exists for given machine */
+int
+m32c_cgen_insn_supported (CGEN_CPU_DESC cd,
+ const CGEN_INSN *insn)
+{
+ int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
+ CGEN_BITSET isas = CGEN_INSN_BITSET_ATTR_VALUE (insn, CGEN_INSN_ISA);
+
+ /* If attributes are absent, assume no restriction. */
+ if (machs == 0)
+ machs = ~0;
+
+ return (machs & cd->machs)
+ && cgen_bitset_intersect_p (& isas, cd->isas);
+}
+
+/* Parse a set of registers, R0,R1,A0,A1,SB,FB. */
+
+static const char *
+parse_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ const char **strp,
+ int opindex ATTRIBUTE_UNUSED,
+ unsigned long *valuep,
+ int push
+ )
+{
+ const char *errmsg = 0;
+ int regno = 0;
+
+ *valuep = 0;
+ while (**strp && **strp != ')')
+ {
+ if (**strp == 'r' || **strp == 'R')
+ {
+ ++*strp;
+ regno = **strp - '0';
+ if (regno > 4)
+ errmsg = _("Register number is not valid");
+ }
+ else if (**strp == 'a' || **strp == 'A')
+ {
+ ++*strp;
+ regno = **strp - '0';
+ if (regno > 2)
+ errmsg = _("Register number is not valid");
+ regno = **strp - '0' + 4;
+ }
+
+ else if (strncasecmp (*strp, "sb", 2) == 0 || strncasecmp (*strp, "SB", 2) == 0)
+ {
+ regno = 6;
+ ++*strp;
+ }
+
+ else if (strncasecmp (*strp, "fb", 2) == 0 || strncasecmp (*strp, "FB", 2) == 0)
+ {
+ regno = 7;
+ ++*strp;
+ }
+
+ if (push) /* Mask is reversed for push. */
+ *valuep |= 0x80 >> regno;
+ else
+ *valuep |= 1 << regno;
+
+ ++*strp;
+ if (**strp == ',')
+ {
+ if (*(*strp + 1) == ')')
+ break;
+ ++*strp;
+ }
+ }
+
+ if (!*strp)
+ errmsg = _("Register list is not valid");
+
+ return errmsg;
+}
+
+#define POP 0
+#define PUSH 1
+
+static const char *
+parse_pop_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ const char **strp,
+ int opindex ATTRIBUTE_UNUSED,
+ unsigned long *valuep)
+{
+ return parse_regset (cd, strp, opindex, valuep, POP);
+}
+
+static const char *
+parse_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ const char **strp,
+ int opindex ATTRIBUTE_UNUSED,
+ unsigned long *valuep)
+{
+ return parse_regset (cd, strp, opindex, valuep, PUSH);
+}
+
+/* -- dis.c */
+
+#include "elf/m32c.h"
+#include "elf-bfd.h"
+
+/* Always print the short insn format suffix as ':<char>' */
+static void
+print_suffix (PTR dis_info, char suffix)
+{
+ disassemble_info *info = dis_info;
+ (*info->fprintf_func) (info->stream, ":%c", suffix);
+}
+
+static void
+print_S (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value ATTRIBUTE_UNUSED,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ print_suffix (dis_info, 's');
+}
+
+
+static void
+print_G (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value ATTRIBUTE_UNUSED,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ print_suffix (dis_info, 'g');
+}
+
+static void
+print_Q (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value ATTRIBUTE_UNUSED,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ print_suffix (dis_info, 'q');
+}
+
+static void
+print_Z (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value ATTRIBUTE_UNUSED,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ print_suffix (dis_info, 'z');
+}
+
+/* Print the empty suffix */
+static void
+print_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info ATTRIBUTE_UNUSED,
+ long value ATTRIBUTE_UNUSED,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ return;
+}
+
+static void
+print_r0l_r0h (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ disassemble_info *info = dis_info;
+ if (value == 0)
+ (*info->fprintf_func) (info->stream, "r0h,r0l");
+ else
+ (*info->fprintf_func) (info->stream, "r0l,r0h");
+}
+
+static void
+print_unsigned_bitbase (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ unsigned long value,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ disassemble_info *info = dis_info;
+ (*info->fprintf_func) (info->stream, "%ld,0x%lx", value & 0x7, value >> 3);
+}
+
+static void
+print_signed_bitbase (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ signed long value,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ disassemble_info *info = dis_info;
+ (*info->fprintf_func) (info->stream, "%ld,%ld", value & 0x7, value >> 3);
+}
+
+static void
+print_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value ATTRIBUTE_UNUSED,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ /* Always print the size as '.w' */
+ disassemble_info *info = dis_info;
+ (*info->fprintf_func) (info->stream, ".w");
+}
+
+#define POP 0
+#define PUSH 1
+
+static void print_pop_regset (CGEN_CPU_DESC, PTR, long, unsigned int, bfd_vma, int);
+static void print_push_regset (CGEN_CPU_DESC, PTR, long, unsigned int, bfd_vma, int);
+
+/* Print a set of registers, R0,R1,A0,A1,SB,FB. */
+
+static void
+print_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED,
+ int push)
+{
+ static char * m16c_register_names [] =
+ {
+ "r0", "r1", "r2", "r3", "a0", "a1", "sb", "fb"
+ };
+ disassemble_info *info = dis_info;
+ int mask;
+ int index = 0;
+ char* comma = "";
+
+ if (push)
+ mask = 0x80;
+ else
+ mask = 1;
+
+ if (value & mask)
+ {
+ (*info->fprintf_func) (info->stream, "%s", m16c_register_names [0]);
+ comma = ",";
+ }
+
+ for (index = 1; index <= 7; ++index)
+ {
+ if (push)
+ mask >>= 1;
+ else
+ mask <<= 1;
+
+ if (value & mask)
+ {
+ (*info->fprintf_func) (info->stream, "%s%s", comma,
+ m16c_register_names [index]);
+ comma = ",";
+ }
+ }
+}
+
+static void
+print_pop_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ print_regset (cd, dis_info, value, attrs, pc, length, POP);
+}
+
+static void
+print_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ print_regset (cd, dis_info, value, attrs, pc, length, PUSH);
+}
+#if 0 /* not used? */
+static void
+print_boff (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+ PTR dis_info,
+ long value,
+ unsigned int attrs ATTRIBUTE_UNUSED,
+ bfd_vma pc ATTRIBUTE_UNUSED,
+ int length ATTRIBUTE_UNUSED)
+{
+ disassemble_info *info = dis_info;
+ if (value)
+ info->fprintf_func (info->stream, "%d,%d", value % 16,
+ (value / 16) * 2);
+}
+
+#endif /* not used? */