/* CPU data for m32c. THIS FILE IS MACHINE GENERATED WITH CGEN. Copyright 1996-2005 Free Software Foundation, Inc. This file is part of the GNU Binutils and/or GDB, the GNU debugger. 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, 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. */ #include "sysdep.h" #include #include #include "ansidecl.h" #include "bfd.h" #include "symcat.h" #include "m32c-desc.h" #include "m32c-opc.h" #include "opintl.h" #include "libiberty.h" #include "xregex.h" /* Attributes. */ static const CGEN_ATTR_ENTRY bool_attr[] = { { "#f", 0 }, { "#t", 1 }, { 0, 0 } }; static const CGEN_ATTR_ENTRY MACH_attr[] ATTRIBUTE_UNUSED = { { "base", MACH_BASE }, { "m16c", MACH_M16C }, { "m32c", MACH_M32C }, { "max", MACH_MAX }, { 0, 0 } }; static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED = { { "m16c", ISA_M16C }, { "m32c", ISA_M32C }, { "max", ISA_MAX }, { 0, 0 } }; static const CGEN_ATTR_ENTRY RL_TYPE_attr[] ATTRIBUTE_UNUSED = { { "NONE", RL_TYPE_NONE }, { "JUMP", RL_TYPE_JUMP }, { "1ADDR", RL_TYPE_1ADDR }, { "2ADDR", RL_TYPE_2ADDR }, { 0, 0 } }; const CGEN_ATTR_TABLE m32c_cgen_ifield_attr_table[] = { { "MACH", & MACH_attr[0], & MACH_attr[0] }, { "ISA", & ISA_attr[0], & ISA_attr[0] }, { "RL_TYPE", & RL_TYPE_attr[0], & RL_TYPE_attr[0] }, { "VIRTUAL", &bool_attr[0], &bool_attr[0] }, { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] }, { "ABS-ADDR", &bool_attr[0], &bool_attr[0] }, { "RESERVED", &bool_attr[0], &bool_attr[0] }, { "SIGN-OPT", &bool_attr[0], &bool_attr[0] }, { "SIGNED", &bool_attr[0], &bool_attr[0] }, { 0, 0, 0 } }; const CGEN_ATTR_TABLE m32c_cgen_hardware_attr_table[] = { { "MACH", & MACH_attr[0], & MACH_attr[0] }, { "ISA", & ISA_attr[0], & ISA_attr[0] }, { "RL_TYPE", & RL_TYPE_attr[0], & RL_TYPE_attr[0] }, { "VIRTUAL", &bool_attr[0], &bool_attr[0] }, { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] }, { "PC", &bool_attr[0], &bool_attr[0] }, { "PROFILE", &bool_attr[0], &bool_attr[0] }, { 0, 0, 0 } }; const CGEN_ATTR_TABLE m32c_cgen_operand_attr_table[] = { { "MACH", & MACH_attr[0], & MACH_attr[0] }, { "ISA", & ISA_attr[0], & ISA_attr[0] }, { "RL_TYPE", & RL_TYPE_attr[0], & RL_TYPE_attr[0] }, { "VIRTUAL", &bool_attr[0], &bool_attr[0] }, { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] }, { "ABS-ADDR", &bool_attr[0], &bool_attr[0] }, { "SIGN-OPT", &bool_attr[0], &bool_attr[0] }, { "SIGNED", &bool_attr[0], &bool_attr[0] }, { "NEGATIVE", &bool_attr[0], &bool_attr[0] }, { "RELAX", &bool_attr[0], &bool_attr[0] }, { "SEM-ONLY", &bool_attr[0], &bool_attr[0] }, { 0, 0, 0 } }; const CGEN_ATTR_TABLE m32c_cgen_insn_attr_table[] = { { "MACH", & MACH_attr[0], & MACH_attr[0] }, { "ISA", & ISA_attr[0], & ISA_attr[0] }, { "RL_TYPE", & RL_TYPE_attr[0], & RL_TYPE_attr[0] }, { "ALIAS", &bool_attr[0], &bool_attr[0] }, { "VIRTUAL", &bool_attr[0], &bool_attr[0] }, { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] }, { "COND-CTI", &bool_attr[0], &bool_attr[0] }, { "SKIP-CTI", &bool_attr[0], &bool_attr[0] }, { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] }, { "RELAXABLE", &bool_attr[0], &bool_attr[0] }, { "RELAXED", &bool_attr[0], &bool_attr[0] }, { "NO-DIS", &bool_attr[0], &bool_attr[0] }, { "PBB", &bool_attr[0], &bool_attr[0] }, { 0, 0, 0 } }; /* Instruction set variants. */ static const CGEN_ISA m32c_cgen_isa_table[] = { { "m16c", 32, 32, 8, 56 }, { "m32c", 32, 32, 8, 80 }, { 0, 0, 0, 0, 0 } }; /* Machine variants. */ static const CGEN_MACH m32c_cgen_mach_table[] = { { "m16c", "m16c", MACH_M16C, 0 }, { "m32c", "m32c", MACH_M32C, 0 }, { 0, 0, 0, 0 } }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_gr_entries[] = { { "r0", 0, {0, {{{0, 0}}}}, 0, 0 }, { "r1", 1, {0, {{{0, 0}}}}, 0, 0 }, { "r2", 2, {0, {{{0, 0}}}}, 0, 0 }, { "r3", 3, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_gr = { & m32c_cgen_opval_h_gr_entries[0], 4, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_gr_QI_entries[] = { { "r0l", 0, {0, {{{0, 0}}}}, 0, 0 }, { "r0h", 1, {0, {{{0, 0}}}}, 0, 0 }, { "r1l", 2, {0, {{{0, 0}}}}, 0, 0 }, { "r1h", 3, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_gr_QI = { & m32c_cgen_opval_h_gr_QI_entries[0], 4, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_gr_HI_entries[] = { { "r0", 0, {0, {{{0, 0}}}}, 0, 0 }, { "r1", 1, {0, {{{0, 0}}}}, 0, 0 }, { "r2", 2, {0, {{{0, 0}}}}, 0, 0 }, { "r3", 3, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_gr_HI = { & m32c_cgen_opval_h_gr_HI_entries[0], 4, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_gr_SI_entries[] = { { "r2r0", 0, {0, {{{0, 0}}}}, 0, 0 }, { "r3r1", 1, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_gr_SI = { & m32c_cgen_opval_h_gr_SI_entries[0], 2, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_gr_ext_QI_entries[] = { { "r0l", 0, {0, {{{0, 0}}}}, 0, 0 }, { "r1l", 1, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_gr_ext_QI = { & m32c_cgen_opval_h_gr_ext_QI_entries[0], 2, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_gr_ext_HI_entries[] = { { "r0", 0, {0, {{{0, 0}}}}, 0, 0 }, { "r1", 1, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_gr_ext_HI = { & m32c_cgen_opval_h_gr_ext_HI_entries[0], 2, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r0l_entries[] = { { "r0l", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r0l = { & m32c_cgen_opval_h_r0l_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r0h_entries[] = { { "r0h", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r0h = { & m32c_cgen_opval_h_r0h_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r1l_entries[] = { { "r1l", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r1l = { & m32c_cgen_opval_h_r1l_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r1h_entries[] = { { "r1h", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r1h = { & m32c_cgen_opval_h_r1h_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r0_entries[] = { { "r0", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r0 = { & m32c_cgen_opval_h_r0_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r1_entries[] = { { "r1", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r1 = { & m32c_cgen_opval_h_r1_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r2_entries[] = { { "r2", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r2 = { & m32c_cgen_opval_h_r2_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r3_entries[] = { { "r3", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r3 = { & m32c_cgen_opval_h_r3_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r0l_r0h_entries[] = { { "r0l", 0, {0, {{{0, 0}}}}, 0, 0 }, { "r0h", 1, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r0l_r0h = { & m32c_cgen_opval_h_r0l_r0h_entries[0], 2, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r2r0_entries[] = { { "r2r0", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r2r0 = { & m32c_cgen_opval_h_r2r0_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r3r1_entries[] = { { "r3r1", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r3r1 = { & m32c_cgen_opval_h_r3r1_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_r1r2r0_entries[] = { { "r1r2r0", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_r1r2r0 = { & m32c_cgen_opval_h_r1r2r0_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_ar_entries[] = { { "a0", 0, {0, {{{0, 0}}}}, 0, 0 }, { "a1", 1, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_ar = { & m32c_cgen_opval_h_ar_entries[0], 2, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_ar_QI_entries[] = { { "a0", 0, {0, {{{0, 0}}}}, 0, 0 }, { "a1", 1, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_ar_QI = { & m32c_cgen_opval_h_ar_QI_entries[0], 2, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_ar_HI_entries[] = { { "a0", 0, {0, {{{0, 0}}}}, 0, 0 }, { "a1", 1, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_ar_HI = { & m32c_cgen_opval_h_ar_HI_entries[0], 2, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_ar_SI_entries[] = { { "a1a0", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_ar_SI = { & m32c_cgen_opval_h_ar_SI_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_a0_entries[] = { { "a0", 0, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_a0 = { & m32c_cgen_opval_h_a0_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_a1_entries[] = { { "a1", 1, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_a1 = { & m32c_cgen_opval_h_a1_entries[0], 1, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_cond16_entries[] = { { "geu", 0, {0, {{{0, 0}}}}, 0, 0 }, { "c", 0, {0, {{{0, 0}}}}, 0, 0 }, { "gtu", 1, {0, {{{0, 0}}}}, 0, 0 }, { "eq", 2, {0, {{{0, 0}}}}, 0, 0 }, { "z", 2, {0, {{{0, 0}}}}, 0, 0 }, { "n", 3, {0, {{{0, 0}}}}, 0, 0 }, { "le", 4, {0, {{{0, 0}}}}, 0, 0 }, { "o", 5, {0, {{{0, 0}}}}, 0, 0 }, { "ge", 6, {0, {{{0, 0}}}}, 0, 0 }, { "ltu", 248, {0, {{{0, 0}}}}, 0, 0 }, { "nc", 248, {0, {{{0, 0}}}}, 0, 0 }, { "leu", 249, {0, {{{0, 0}}}}, 0, 0 }, { "ne", 250, {0, {{{0, 0}}}}, 0, 0 }, { "nz", 250, {0, {{{0, 0}}}}, 0, 0 }, { "pz", 251, {0, {{{0, 0}}}}, 0, 0 }, { "gt", 252, {0, {{{0, 0}}}}, 0, 0 }, { "no", 253, {0, {{{0, 0}}}}, 0, 0 }, { "lt", 254, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_cond16 = { & m32c_cgen_opval_h_cond16_entries[0], 18, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_cond16c_entries[] = { { "geu", 0, {0, {{{0, 0}}}}, 0, 0 }, { "c", 0, {0, {{{0, 0}}}}, 0, 0 }, { "gtu", 1, {0, {{{0, 0}}}}, 0, 0 }, { "eq", 2, {0, {{{0, 0}}}}, 0, 0 }, { "z", 2, {0, {{{0, 0}}}}, 0, 0 }, { "n", 3, {0, {{{0, 0}}}}, 0, 0 }, { "ltu", 4, {0, {{{0, 0}}}}, 0, 0 }, { "nc", 4, {0, {{{0, 0}}}}, 0, 0 }, { "leu", 5, {0, {{{0, 0}}}}, 0, 0 }, { "ne", 6, {0, {{{0, 0}}}}, 0, 0 }, { "nz", 6, {0, {{{0, 0}}}}, 0, 0 }, { "pz", 7, {0, {{{0, 0}}}}, 0, 0 }, { "le", 8, {0, {{{0, 0}}}}, 0, 0 }, { "o", 9, {0, {{{0, 0}}}}, 0, 0 }, { "ge", 10, {0, {{{0, 0}}}}, 0, 0 }, { "gt", 12, {0, {{{0, 0}}}}, 0, 0 }, { "no", 13, {0, {{{0, 0}}}}, 0, 0 }, { "lt", 14, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_cond16c = { & m32c_cgen_opval_h_cond16c_entries[0], 18, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_cond16j_entries[] = { { "le", 8, {0, {{{0, 0}}}}, 0, 0 }, { "o", 9, {0, {{{0, 0}}}}, 0, 0 }, { "ge", 10, {0, {{{0, 0}}}}, 0, 0 }, { "gt", 12, {0, {{{0, 0}}}}, 0, 0 }, { "no", 13, {0, {{{0, 0}}}}, 0, 0 }, { "lt", 14, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_cond16j = { & m32c_cgen_opval_h_cond16j_entries[0], 6, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_cond16j_5_entries[] = { { "geu", 0, {0, {{{0, 0}}}}, 0, 0 }, { "c", 0, {0, {{{0, 0}}}}, 0, 0 }, { "gtu", 1, {0, {{{0, 0}}}}, 0, 0 }, { "eq", 2, {0, {{{0, 0}}}}, 0, 0 }, { "z", 2, {0, {{{0, 0}}}}, 0, 0 }, { "n", 3, {0, {{{0, 0}}}}, 0, 0 }, { "ltu", 4, {0, {{{0, 0}}}}, 0, 0 }, { "nc", 4, {0, {{{0, 0}}}}, 0, 0 }, { "leu", 5, {0, {{{0, 0}}}}, 0, 0 }, { "ne", 6, {0, {{{0, 0}}}}, 0, 0 }, { "nz", 6, {0, {{{0, 0}}}}, 0, 0 }, { "pz", 7, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_cond16j_5 = { & m32c_cgen_opval_h_cond16j_5_entries[0], 12, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_cond32_entries[] = { { "ltu", 0, {0, {{{0, 0}}}}, 0, 0 }, { "nc", 0, {0, {{{0, 0}}}}, 0, 0 }, { "leu", 1, {0, {{{0, 0}}}}, 0, 0 }, { "ne", 2, {0, {{{0, 0}}}}, 0, 0 }, { "nz", 2, {0, {{{0, 0}}}}, 0, 0 }, { "pz", 3, {0, {{{0, 0}}}}, 0, 0 }, { "no", 4, {0, {{{0, 0}}}}, 0, 0 }, { "gt", 5, {0, {{{0, 0}}}}, 0, 0 }, { "ge", 6, {0, {{{0, 0}}}}, 0, 0 }, { "geu", 8, {0, {{{0, 0}}}}, 0, 0 }, { "c", 8, {0, {{{0, 0}}}}, 0, 0 }, { "gtu", 9, {0, {{{0, 0}}}}, 0, 0 }, { "eq", 10, {0, {{{0, 0}}}}, 0, 0 }, { "z", 10, {0, {{{0, 0}}}}, 0, 0 }, { "n", 11, {0, {{{0, 0}}}}, 0, 0 }, { "o", 12, {0, {{{0, 0}}}}, 0, 0 }, { "le", 13, {0, {{{0, 0}}}}, 0, 0 }, { "lt", 14, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_cond32 = { & m32c_cgen_opval_h_cond32_entries[0], 18, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_cr1_32_entries[] = { { "dct0", 0, {0, {{{0, 0}}}}, 0, 0 }, { "dct1", 1, {0, {{{0, 0}}}}, 0, 0 }, { "flg", 2, {0, {{{0, 0}}}}, 0, 0 }, { "svf", 3, {0, {{{0, 0}}}}, 0, 0 }, { "drc0", 4, {0, {{{0, 0}}}}, 0, 0 }, { "drc1", 5, {0, {{{0, 0}}}}, 0, 0 }, { "dmd0", 6, {0, {{{0, 0}}}}, 0, 0 }, { "dmd1", 7, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_cr1_32 = { & m32c_cgen_opval_h_cr1_32_entries[0], 8, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_cr2_32_entries[] = { { "intb", 0, {0, {{{0, 0}}}}, 0, 0 }, { "sp", 1, {0, {{{0, 0}}}}, 0, 0 }, { "sb", 2, {0, {{{0, 0}}}}, 0, 0 }, { "fb", 3, {0, {{{0, 0}}}}, 0, 0 }, { "svp", 4, {0, {{{0, 0}}}}, 0, 0 }, { "vct", 5, {0, {{{0, 0}}}}, 0, 0 }, { "isp", 7, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_cr2_32 = { & m32c_cgen_opval_h_cr2_32_entries[0], 7, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_cr3_32_entries[] = { { "dma0", 2, {0, {{{0, 0}}}}, 0, 0 }, { "dma1", 3, {0, {{{0, 0}}}}, 0, 0 }, { "dra0", 4, {0, {{{0, 0}}}}, 0, 0 }, { "dra1", 5, {0, {{{0, 0}}}}, 0, 0 }, { "dsa0", 6, {0, {{{0, 0}}}}, 0, 0 }, { "dsa1", 7, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_cr3_32 = { & m32c_cgen_opval_h_cr3_32_entries[0], 6, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_cr_16_entries[] = { { "intbl", 1, {0, {{{0, 0}}}}, 0, 0 }, { "intbh", 2, {0, {{{0, 0}}}}, 0, 0 }, { "flg", 3, {0, {{{0, 0}}}}, 0, 0 }, { "isp", 4, {0, {{{0, 0}}}}, 0, 0 }, { "sp", 5, {0, {{{0, 0}}}}, 0, 0 }, { "sb", 6, {0, {{{0, 0}}}}, 0, 0 }, { "fb", 7, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_cr_16 = { & m32c_cgen_opval_h_cr_16_entries[0], 7, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_flags_entries[] = { { "c", 0, {0, {{{0, 0}}}}, 0, 0 }, { "d", 1, {0, {{{0, 0}}}}, 0, 0 }, { "z", 2, {0, {{{0, 0}}}}, 0, 0 }, { "s", 3, {0, {{{0, 0}}}}, 0, 0 }, { "b", 4, {0, {{{0, 0}}}}, 0, 0 }, { "o", 5, {0, {{{0, 0}}}}, 0, 0 }, { "i", 6, {0, {{{0, 0}}}}, 0, 0 }, { "u", 7, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_flags = { & m32c_cgen_opval_h_flags_entries[0], 8, 0, 0, 0, 0, "" }; static CGEN_KEYWORD_ENTRY m32c_cgen_opval_h_shimm_entries[] = { { "1", 0, {0, {{{0, 0}}}}, 0, 0 }, { "2", 1, {0, {{{0, 0}}}}, 0, 0 }, { "3", 2, {0, {{{0, 0}}}}, 0, 0 }, { "4", 3, {0, {{{0, 0}}}}, 0, 0 }, { "5", 4, {0, {{{0, 0}}}}, 0, 0 }, { "6", 5, {0, {{{0, 0}}}}, 0, 0 }, { "7", 6, {0, {{{0, 0}}}}, 0, 0 }, { "8", 7, {0, {{{0, 0}}}}, 0, 0 }, { "-1", -8, {0, {{{0, 0}}}}, 0, 0 }, { "-2", -7, {0, {{{0, 0}}}}, 0, 0 }, { "-3", -6, {0, {{{0, 0}}}}, 0, 0 }, { "-4", -5, {0, {{{0, 0}}}}, 0, 0 }, { "-5", -4, {0, {{{0, 0}}}}, 0, 0 }, { "-6", -3, {0, {{{0, 0}}}}, 0, 0 }, { "-7", -2, {0, {{{0, 0}}}}, 0, 0 }, { "-8", -1, {0, {{{0, 0}}}}, 0, 0 } }; CGEN_KEYWORD m32c_cgen_opval_h_shimm = { & m32c_cgen_opval_h_shimm_entries[0], 16, 0, 0, 0, 0, "" }; /* The hardware table. */ #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE) #define A(a) (1 << CGEN_HW_##a) #else #define A(a) (1 << CGEN_HW_/**/a) #endif const CGEN_HW_ENTRY m32c_cgen_hw_table[] = { { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<name) { if (strcmp (name, table->bfd_name) == 0) return table; ++table; } abort (); } /* Subroutine of m32c_cgen_cpu_open to build the hardware table. */ static void build_hw_table (CGEN_CPU_TABLE *cd) { int i; int machs = cd->machs; const CGEN_HW_ENTRY *init = & m32c_cgen_hw_table[0]; /* MAX_HW is only an upper bound on the number of selected entries. However each entry is indexed by it's enum so there can be holes in the table. */ const CGEN_HW_ENTRY **selected = (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *)); cd->hw_table.init_entries = init; cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY); memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *)); /* ??? For now we just use machs to determine which ones we want. */ for (i = 0; init[i].name != NULL; ++i) if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH) & machs) selected[init[i].type] = &init[i]; cd->hw_table.entries = selected; cd->hw_table.num_entries = MAX_HW; } /* Subroutine of m32c_cgen_cpu_open to build the hardware table. */ static void build_ifield_table (CGEN_CPU_TABLE *cd) { cd->ifld_table = & m32c_cgen_ifld_table[0]; } /* Subroutine of m32c_cgen_cpu_open to build the hardware table. */ static void build_operand_table (CGEN_CPU_TABLE *cd) { int i; int machs = cd->machs; const CGEN_OPERAND *init = & m32c_cgen_operand_table[0]; /* MAX_OPERANDS is only an upper bound on the number of selected entries. However each entry is indexed by it's enum so there can be holes in the table. */ const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected)); cd->operand_table.init_entries = init; cd->operand_table.entry_size = sizeof (CGEN_OPERAND); memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *)); /* ??? For now we just use mach to determine which ones we want. */ for (i = 0; init[i].name != NULL; ++i) if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH) & machs) selected[init[i].type] = &init[i]; cd->operand_table.entries = selected; cd->operand_table.num_entries = MAX_OPERANDS; } /* Subroutine of m32c_cgen_cpu_open to build the hardware table. ??? This could leave out insns not supported by the specified mach/isa, but that would cause errors like "foo only supported by bar" to become "unknown insn", so for now we include all insns and require the app to do the checking later. ??? On the other hand, parsing of such insns may require their hardware or operand elements to be in the table [which they mightn't be]. */ static void build_insn_table (CGEN_CPU_TABLE *cd) { int i; const CGEN_IBASE *ib = & m32c_cgen_insn_table[0]; CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN)); memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN)); for (i = 0; i < MAX_INSNS; ++i) insns[i].base = &ib[i]; cd->insn_table.init_entries = insns; cd->insn_table.entry_size = sizeof (CGEN_IBASE); cd->insn_table.num_init_entries = MAX_INSNS; } /* Subroutine of m32c_cgen_cpu_open to rebuild the tables. */ static void m32c_cgen_rebuild_tables (CGEN_CPU_TABLE *cd) { int i; CGEN_BITSET *isas = cd->isas; unsigned int machs = cd->machs; cd->int_insn_p = CGEN_INT_INSN_P; /* Data derived from the isa spec. */ #define UNSET (CGEN_SIZE_UNKNOWN + 1) cd->default_insn_bitsize = UNSET; cd->base_insn_bitsize = UNSET; cd->min_insn_bitsize = 65535; /* Some ridiculously big number. */ cd->max_insn_bitsize = 0; for (i = 0; i < MAX_ISAS; ++i) if (cgen_bitset_contains (isas, i)) { const CGEN_ISA *isa = & m32c_cgen_isa_table[i]; /* Default insn sizes of all selected isas must be equal or we set the result to 0, meaning "unknown". */ if (cd->default_insn_bitsize == UNSET) cd->default_insn_bitsize = isa->default_insn_bitsize; else if (isa->default_insn_bitsize == cd->default_insn_bitsize) ; /* This is ok. */ else cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN; /* Base insn sizes of all selected isas must be equal or we set the result to 0, meaning "unknown". */ if (cd->base_insn_bitsize == UNSET) cd->base_insn_bitsize = isa->base_insn_bitsize; else if (isa->base_insn_bitsize == cd->base_insn_bitsize) ; /* This is ok. */ else cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN; /* Set min,max insn sizes. */ if (isa->min_insn_bitsize < cd->min_insn_bitsize) cd->min_insn_bitsize = isa->min_insn_bitsize; if (isa->max_insn_bitsize > cd->max_insn_bitsize) cd->max_insn_bitsize = isa->max_insn_bitsize; } /* Data derived from the mach spec. */ for (i = 0; i < MAX_MACHS; ++i) if (((1 << i) & machs) != 0) { const CGEN_MACH *mach = & m32c_cgen_mach_table[i]; if (mach->insn_chunk_bitsize != 0) { if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize) { fprintf (stderr, "m32c_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n", cd->insn_chunk_bitsize, mach->insn_chunk_bitsize); abort (); } cd->insn_chunk_bitsize = mach->insn_chunk_bitsize; } } /* Determine which hw elements are used by MACH. */ build_hw_table (cd); /* Build the ifield table. */ build_ifield_table (cd); /* Determine which operands are used by MACH/ISA. */ build_operand_table (cd); /* Build the instruction table. */ build_insn_table (cd); } /* Initialize a cpu table and return a descriptor. It's much like opening a file, and must be the first function called. The arguments are a set of (type/value) pairs, terminated with CGEN_CPU_OPEN_END. Currently supported values: CGEN_CPU_OPEN_ISAS: bitmap of values in enum isa_attr CGEN_CPU_OPEN_MACHS: bitmap of values in enum mach_attr CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name CGEN_CPU_OPEN_ENDIAN: specify endian choice CGEN_CPU_OPEN_END: terminates arguments ??? Simultaneous multiple isas might not make sense, but it's not (yet) precluded. ??? We only support ISO C stdargs here, not K&R. Laziness, plus experiment to see if anything requires K&R - eventually K&R will no longer be supported - e.g. GDB is currently trying this. */ CGEN_CPU_DESC m32c_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...) { CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE)); static int init_p; CGEN_BITSET *isas = 0; /* 0 = "unspecified" */ unsigned int machs = 0; /* 0 = "unspecified" */ enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN; va_list ap; if (! init_p) { init_tables (); init_p = 1; } memset (cd, 0, sizeof (*cd)); va_start (ap, arg_type); while (arg_type != CGEN_CPU_OPEN_END) { switch (arg_type) { case CGEN_CPU_OPEN_ISAS : isas = va_arg (ap, CGEN_BITSET *); break; case CGEN_CPU_OPEN_MACHS : machs = va_arg (ap, unsigned int); break; case CGEN_CPU_OPEN_BFDMACH : { const char *name = va_arg (ap, const char *); const CGEN_MACH *mach = lookup_mach_via_bfd_name (m32c_cgen_mach_table, name); machs |= 1 << mach->num; break; } case CGEN_CPU_OPEN_ENDIAN : endian = va_arg (ap, enum cgen_endian); break; default : fprintf (stderr, "m32c_cgen_cpu_open: unsupported argument `%d'\n", arg_type); abort (); /* ??? return NULL? */ } arg_type = va_arg (ap, enum cgen_cpu_open_arg); } va_end (ap); /* Mach unspecified means "all". */ if (machs == 0) machs = (1 << MAX_MACHS) - 1; /* Base mach is always selected. */ machs |= 1; if (endian == CGEN_ENDIAN_UNKNOWN) { /* ??? If target has only one, could have a default. */ fprintf (stderr, "m32c_cgen_cpu_open: no endianness specified\n"); abort (); } cd->isas = cgen_bitset_copy (isas); cd->machs = machs; cd->endian = endian; /* FIXME: for the sparc case we can determine insn-endianness statically. The worry here is where both data and insn endian can be independently chosen, in which case this function will need another argument. Actually, will want to allow for more arguments in the future anyway. */ cd->insn_endian = endian; /* Table (re)builder. */ cd->rebuild_tables = m32c_cgen_rebuild_tables; m32c_cgen_rebuild_tables (cd); /* Default to not allowing signed overflow. */ cd->signed_overflow_ok_p = 0; return (CGEN_CPU_DESC) cd; } /* Cover fn to m32c_cgen_cpu_open to handle the simple case of 1 isa, 1 mach. MACH_NAME is the bfd name of the mach. */ CGEN_CPU_DESC m32c_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian) { return m32c_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name, CGEN_CPU_OPEN_ENDIAN, endian, CGEN_CPU_OPEN_END); } /* Close a cpu table. ??? This can live in a machine independent file, but there's currently no place to put this file (there's no libcgen). libopcodes is the wrong place as some simulator ports use this but they don't use libopcodes. */ void m32c_cgen_cpu_close (CGEN_CPU_DESC cd) { unsigned int i; const CGEN_INSN *insns; if (cd->macro_insn_table.init_entries) { insns = cd->macro_insn_table.init_entries; for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns) if (CGEN_INSN_RX ((insns))) regfree (CGEN_INSN_RX (insns)); } if (cd->insn_table.init_entries) { insns = cd->insn_table.init_entries; for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns) if (CGEN_INSN_RX (insns)) regfree (CGEN_INSN_RX (insns)); } if (cd->macro_insn_table.init_entries) free ((CGEN_INSN *) cd->macro_insn_table.init_entries); if (cd->insn_table.init_entries) free ((CGEN_INSN *) cd->insn_table.init_entries); if (cd->hw_table.entries) free ((CGEN_HW_ENTRY *) cd->hw_table.entries); if (cd->operand_table.entries) free ((CGEN_HW_ENTRY *) cd->operand_table.entries); free (cd); }