X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=cpu%2Fm32c.opc;h=2796e1c1cffb1bfa3dff4a34baa3947b3621ff4b;hb=70bc38f51381698804566504e25d197e8e731d2d;hp=7caf21d6f6958ef598d2f5ec6b3e078e09f85f52;hpb=e729279b04301d65a619b1bad04b6aff686899b2;p=deliverable%2Fbinutils-gdb.git diff --git a/cpu/m32c.opc b/cpu/m32c.opc index 7caf21d6f6..2796e1c1cf 100644 --- a/cpu/m32c.opc +++ b/cpu/m32c.opc @@ -1,6 +1,6 @@ /* m32c opcode support. -*- C -*- - Copyright 2005 Free Software Foundation, Inc. + Copyright 2005, 2007, 2009, 2010 Free Software Foundation, Inc. Contributed by Red Hat Inc; developed under contract from Renesas @@ -8,7 +8,7 @@ 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 2 of the License, or + 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, @@ -18,7 +18,9 @@ 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. */ + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + /* 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 @@ -38,8 +40,8 @@ /* -- opc.h */ /* Needed for RTL's 'ext' and 'trunc' operators. */ -#include "cgen-types.h" -#include "cgen-ops.h" +#include "cgen/basic-modes.h" +#include "cgen/basic-ops.h" /* We can't use the default hash size because many bits are used by operands. */ @@ -69,6 +71,10 @@ m32c_asm_hash (const char *mnem) if (mnem[0] == 's' && mnem[1] == 'c') return 's'; + /* Don't hash bmCND */ + if (mnem[0] == 'b' && mnem[1] == 'm') + return 'b'; + for (h = 0; *mnem && *mnem != ' ' && *mnem != ':'; ++mnem) h += *mnem; return h % CGEN_ASM_HASH_SIZE; @@ -150,9 +156,30 @@ parse_unsigned8 (CGEN_CPU_DESC cd, const char **strp, int opindex, unsigned long *valuep) { const char *errmsg = 0; - unsigned long value; + unsigned long value = 0; long have_zero = 0; + if (strncasecmp (*strp, "%dsp8(", 6) == 0) + { + enum cgen_parse_operand_result result_type; + bfd_vma val; + + *strp += 6; + errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_8, + & result_type, & val); + if (**strp != ')') + return _("missing `)'"); + (*strp) ++; + + if (errmsg == NULL + && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) + return _("%dsp8() takes a symbolic address, not a number"); + + value = val; + *valuep = value; + return errmsg; + } + if (strncmp (*strp, "0x0", 3) == 0 || (**strp == '0' && *(*strp + 1) != 'x')) have_zero = 1; @@ -195,13 +222,59 @@ parse_signed4 (CGEN_CPU_DESC cd, const char **strp, return 0; } +static const char * +parse_signed4n (CGEN_CPU_DESC cd, const char **strp, + int opindex, signed long *valuep) +{ + const char *errmsg = 0; + signed long value; + long have_zero = 0; + + if (strncmp (*strp, "0x0", 3) == 0 + || (**strp == '0' && *(*strp + 1) != 'x')) + have_zero = 1; + + PARSE_SIGNED; + + if (value < -7 || value > 8) + return _("Immediate is out of range -7 to 8"); + + /* If this field may require a relocation then use larger dsp16. */ + if (! have_zero && value == 0) + return _("Immediate is out of range -7 to 8"); + + *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; - + signed long value = 0; + + if (strncasecmp (*strp, "%hi8(", 5) == 0) + { + enum cgen_parse_operand_result result_type; + bfd_vma val; + + *strp += 5; + errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32C_HI8, + & result_type, & val); + if (**strp != ')') + return _("missing `)'"); + (*strp) ++; + + if (errmsg == NULL + && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) + val >>= 16; + + value = val; + *valuep = value; + return errmsg; + } + PARSE_SIGNED; if (value <= 255 && value > 127) @@ -219,9 +292,30 @@ parse_unsigned16 (CGEN_CPU_DESC cd, const char **strp, int opindex, unsigned long *valuep) { const char *errmsg = 0; - unsigned long value; + unsigned long value = 0; long have_zero = 0; - + + if (strncasecmp (*strp, "%dsp16(", 7) == 0) + { + enum cgen_parse_operand_result result_type; + bfd_vma val; + + *strp += 7; + errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_16, + & result_type, & val); + if (**strp != ')') + return _("missing `)'"); + (*strp) ++; + + if (errmsg == NULL + && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) + return _("%dsp16() takes a symbolic address, not a number"); + + value = val; + *valuep = value; + return errmsg; + } + /* Don't successfully parse literals beginning with '['. */ if (**strp == '[') return "Invalid literal"; /* Anything -- will not be seen. */ @@ -257,7 +351,49 @@ parse_signed16 (CGEN_CPU_DESC cd, const char **strp, int opindex, signed long *valuep) { const char *errmsg = 0; - signed long value; + signed long value = 0; + + if (strncasecmp (*strp, "%lo16(", 6) == 0) + { + enum cgen_parse_operand_result result_type; + bfd_vma val; + + *strp += 6; + errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16, + & result_type, & val); + if (**strp != ')') + return _("missing `)'"); + (*strp) ++; + + if (errmsg == NULL + && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) + val &= 0xffff; + + value = val; + *valuep = value; + return errmsg; + } + + if (strncasecmp (*strp, "%hi16(", 6) == 0) + { + enum cgen_parse_operand_result result_type; + bfd_vma val; + + *strp += 6; + errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16, + & result_type, & val); + if (**strp != ')') + return _("missing `)'"); + (*strp) ++; + + if (errmsg == NULL + && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) + val >>= 16; + + value = val; + *valuep = value; + return errmsg; + } PARSE_SIGNED; @@ -323,6 +459,26 @@ parse_unsigned24 (CGEN_CPU_DESC cd, const char **strp, return 0; } +/* This should only be used for #imm->reg. */ +static const char * +parse_signed24 (CGEN_CPU_DESC cd, const char **strp, + int opindex, signed long *valuep) +{ + const char *errmsg = 0; + signed long value; + + PARSE_SIGNED; + + if (value <= 0xffffff && value > 0x7fffff) + value -= 0x1000000; + + 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) @@ -374,16 +530,34 @@ parse_imm3_S (CGEN_CPU_DESC cd, const char **strp, return 0; } +static const char * +parse_bit3_S (CGEN_CPU_DESC cd, const char **strp, + int opindex, signed long *valuep) +{ + const char *errmsg = 0; + signed long value; + + errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); + if (errmsg) + return errmsg; + + if (value < 0 || value > 7) + return _("immediate is out of range 0-7"); + + *valuep = value; + return 0; +} + static const char * parse_lab_5_3 (CGEN_CPU_DESC cd, const char **strp, int opindex ATTRIBUTE_UNUSED, int opinfo, enum cgen_parse_operand_result *type_addr, - unsigned long *valuep) + bfd_vma *valuep) { const char *errmsg = 0; - unsigned long value; + bfd_vma value; enum cgen_parse_operand_result op_res; errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_5_3, @@ -392,7 +566,7 @@ parse_lab_5_3 (CGEN_CPU_DESC cd, if (type_addr) *type_addr = op_res; - if (op_res == CGEN_PARSE_OPERAND_ADDRESS) + if (op_res == CGEN_PARSE_OPERAND_RESULT_QUEUED) { /* This is a hack; the field cannot handle near-zero signed offsets that CGEN wants to put in to indicate an "empty" @@ -431,13 +605,14 @@ parse_Bitno16R (CGEN_CPU_DESC cd, const char **strp, static const char * parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp, int opindex, unsigned long *valuep, - unsigned bits) + unsigned bits, int allow_syms) { const char *errmsg = 0; unsigned long bit; unsigned long base; const char *newp = *strp; unsigned long long bitbase; + long have_zero = 0; errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit); if (errmsg) @@ -447,6 +622,11 @@ parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp, return "Missing base for bit,base:8"; ++newp; + + if (strncmp (newp, "0x0", 3) == 0 + || (newp[0] == '0' && newp[1] != 'x')) + have_zero = 1; + errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & base); if (errmsg) return errmsg; @@ -456,6 +636,21 @@ parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp, if (bitbase >= (1ull << bits)) return _("bit,base is out of range"); + /* If this field may require a relocation then use larger displacement. */ + if (! have_zero && base == 0) + { + switch (allow_syms) { + case 0: + return _("bit,base out of range for symbol"); + case 1: + break; + case 2: + if (strncmp (newp, "[sb]", 4) != 0) + return _("bit,base out of range for symbol"); + break; + } + } + *valuep = bitbase; *strp = newp; return 0; @@ -464,7 +659,7 @@ parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp, static const char * parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp, int opindex, signed long *valuep, - unsigned bits) + unsigned bits, int allow_syms) { const char *errmsg = 0; unsigned long bit; @@ -472,6 +667,7 @@ parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp, const char *newp = *strp; long long bitbase; long long limit; + long have_zero = 0; errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit); if (errmsg) @@ -481,6 +677,11 @@ parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp, return "Missing base for bit,base:8"; ++newp; + + if (strncmp (newp, "0x0", 3) == 0 + || (newp[0] == '0' && newp[1] != 'x')) + have_zero = 1; + errmsg = cgen_parse_signed_integer (cd, & newp, opindex, & base); if (errmsg) return errmsg; @@ -491,6 +692,10 @@ parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp, if (bitbase < -limit || bitbase >= limit) return _("bit,base is out of range"); + /* If this field may require a relocation then use larger displacement. */ + if (! have_zero && base == 0 && ! allow_syms) + return _("bit,base out of range for symbol"); + *valuep = bitbase; *strp = newp; return 0; @@ -500,56 +705,56 @@ 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); + return parse_unsigned_bitbase (cd, strp, opindex, valuep, 8, 0); } 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); + return parse_unsigned_bitbase (cd, strp, opindex, valuep, 11, 0); } 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); + return parse_unsigned_bitbase (cd, strp, opindex, valuep, 16, 1); } 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); + return parse_unsigned_bitbase (cd, strp, opindex, valuep, 19, 2); } 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); + return parse_unsigned_bitbase (cd, strp, opindex, valuep, 27, 1); } 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); + return parse_signed_bitbase (cd, strp, opindex, valuep, 8, 1); } 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); + return parse_signed_bitbase (cd, strp, opindex, valuep, 11, 0); } 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); + return parse_signed_bitbase (cd, strp, opindex, valuep, 19, 1); } /* Parse the suffix as : or as nothing followed by a whitespace. */ @@ -665,14 +870,14 @@ m32c_cgen_insn_supported (CGEN_CPU_DESC cd, const CGEN_INSN *insn) { int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH); - int isas = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_ISA); + 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) - && (isas & cd->isas)); + && cgen_bitset_intersect_p (& isas, cd->isas)); } /* Parse a set of registers, R0,R1,A0,A1,SB,FB. */ @@ -911,7 +1116,7 @@ print_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, }; disassemble_info *info = dis_info; int mask; - int index = 0; + int reg_index = 0; char* comma = ""; if (push) @@ -925,7 +1130,7 @@ print_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, comma = ","; } - for (index = 1; index <= 7; ++index) + for (reg_index = 1; reg_index <= 7; ++reg_index) { if (push) mask >>= 1; @@ -935,7 +1140,7 @@ print_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, if (value & mask) { (*info->fprintf_func) (info->stream, "%s%s", comma, - m16c_register_names [index]); + m16c_register_names [reg_index]); comma = ","; } } @@ -962,3 +1167,16 @@ print_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, { print_regset (cd, dis_info, value, attrs, pc, length, PUSH); } + +static void +print_signed4n (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, + void * 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", -value); +}