Home | History | Annotate | Download | only in opcodes
      1 /* CPU data for m32r.
      2 
      3 THIS FILE IS MACHINE GENERATED WITH CGEN.
      4 
      5 Copyright (C) 1996-2014 Free Software Foundation, Inc.
      6 
      7 This file is part of the GNU Binutils and/or GDB, the GNU debugger.
      8 
      9    This file is free software; you can redistribute it and/or modify
     10    it under the terms of the GNU General Public License as published by
     11    the Free Software Foundation; either version 3, or (at your option)
     12    any later version.
     13 
     14    It is distributed in the hope that it will be useful, but WITHOUT
     15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
     16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
     17    License for more details.
     18 
     19    You should have received a copy of the GNU General Public License along
     20    with this program; if not, write to the Free Software Foundation, Inc.,
     21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
     22 
     23 */
     24 
     25 #include "sysdep.h"
     26 #include <stdio.h>
     27 #include <stdarg.h>
     28 #include "ansidecl.h"
     29 #include "bfd.h"
     30 #include "symcat.h"
     31 #include "m32r-desc.h"
     32 #include "m32r-opc.h"
     33 #include "opintl.h"
     34 #include "libiberty.h"
     35 #include "xregex.h"
     36 
     37 /* Attributes.  */
     38 
     39 static const CGEN_ATTR_ENTRY bool_attr[] =
     40 {
     41   { "#f", 0 },
     42   { "#t", 1 },
     43   { 0, 0 }
     44 };
     45 
     46 static const CGEN_ATTR_ENTRY MACH_attr[] ATTRIBUTE_UNUSED =
     47 {
     48   { "base", MACH_BASE },
     49   { "m32r", MACH_M32R },
     50   { "m32rx", MACH_M32RX },
     51   { "m32r2", MACH_M32R2 },
     52   { "max", MACH_MAX },
     53   { 0, 0 }
     54 };
     55 
     56 static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
     57 {
     58   { "m32r", ISA_M32R },
     59   { "max", ISA_MAX },
     60   { 0, 0 }
     61 };
     62 
     63 static const CGEN_ATTR_ENTRY PIPE_attr[] ATTRIBUTE_UNUSED =
     64 {
     65   { "NONE", PIPE_NONE },
     66   { "O", PIPE_O },
     67   { "S", PIPE_S },
     68   { "OS", PIPE_OS },
     69   { "O_OS", PIPE_O_OS },
     70   { 0, 0 }
     71 };
     72 
     73 const CGEN_ATTR_TABLE m32r_cgen_ifield_attr_table[] =
     74 {
     75   { "MACH", & MACH_attr[0], & MACH_attr[0] },
     76   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
     77   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
     78   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
     79   { "RESERVED", &bool_attr[0], &bool_attr[0] },
     80   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
     81   { "SIGNED", &bool_attr[0], &bool_attr[0] },
     82   { "RELOC", &bool_attr[0], &bool_attr[0] },
     83   { 0, 0, 0 }
     84 };
     85 
     86 const CGEN_ATTR_TABLE m32r_cgen_hardware_attr_table[] =
     87 {
     88   { "MACH", & MACH_attr[0], & MACH_attr[0] },
     89   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
     90   { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
     91   { "PC", &bool_attr[0], &bool_attr[0] },
     92   { "PROFILE", &bool_attr[0], &bool_attr[0] },
     93   { 0, 0, 0 }
     94 };
     95 
     96 const CGEN_ATTR_TABLE m32r_cgen_operand_attr_table[] =
     97 {
     98   { "MACH", & MACH_attr[0], & MACH_attr[0] },
     99   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
    100   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
    101   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
    102   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
    103   { "SIGNED", &bool_attr[0], &bool_attr[0] },
    104   { "NEGATIVE", &bool_attr[0], &bool_attr[0] },
    105   { "RELAX", &bool_attr[0], &bool_attr[0] },
    106   { "SEM-ONLY", &bool_attr[0], &bool_attr[0] },
    107   { "RELOC", &bool_attr[0], &bool_attr[0] },
    108   { 0, 0, 0 }
    109 };
    110 
    111 const CGEN_ATTR_TABLE m32r_cgen_insn_attr_table[] =
    112 {
    113   { "MACH", & MACH_attr[0], & MACH_attr[0] },
    114   { "PIPE", & PIPE_attr[0], & PIPE_attr[0] },
    115   { "ALIAS", &bool_attr[0], &bool_attr[0] },
    116   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
    117   { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] },
    118   { "COND-CTI", &bool_attr[0], &bool_attr[0] },
    119   { "SKIP-CTI", &bool_attr[0], &bool_attr[0] },
    120   { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
    121   { "RELAXABLE", &bool_attr[0], &bool_attr[0] },
    122   { "RELAXED", &bool_attr[0], &bool_attr[0] },
    123   { "NO-DIS", &bool_attr[0], &bool_attr[0] },
    124   { "PBB", &bool_attr[0], &bool_attr[0] },
    125   { "FILL-SLOT", &bool_attr[0], &bool_attr[0] },
    126   { "SPECIAL", &bool_attr[0], &bool_attr[0] },
    127   { "SPECIAL_M32R", &bool_attr[0], &bool_attr[0] },
    128   { "SPECIAL_FLOAT", &bool_attr[0], &bool_attr[0] },
    129   { 0, 0, 0 }
    130 };
    131 
    132 /* Instruction set variants.  */
    133 
    134 static const CGEN_ISA m32r_cgen_isa_table[] = {
    135   { "m32r", 32, 32, 16, 32 },
    136   { 0, 0, 0, 0, 0 }
    137 };
    138 
    139 /* Machine variants.  */
    140 
    141 static const CGEN_MACH m32r_cgen_mach_table[] = {
    142   { "m32r", "m32r", MACH_M32R, 0 },
    143   { "m32rx", "m32rx", MACH_M32RX, 0 },
    144   { "m32r2", "m32r2", MACH_M32R2, 0 },
    145   { 0, 0, 0, 0 }
    146 };
    147 
    148 static CGEN_KEYWORD_ENTRY m32r_cgen_opval_gr_names_entries[] =
    149 {
    150   { "fp", 13, {0, {{{0, 0}}}}, 0, 0 },
    151   { "lr", 14, {0, {{{0, 0}}}}, 0, 0 },
    152   { "sp", 15, {0, {{{0, 0}}}}, 0, 0 },
    153   { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
    154   { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
    155   { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
    156   { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
    157   { "r4", 4, {0, {{{0, 0}}}}, 0, 0 },
    158   { "r5", 5, {0, {{{0, 0}}}}, 0, 0 },
    159   { "r6", 6, {0, {{{0, 0}}}}, 0, 0 },
    160   { "r7", 7, {0, {{{0, 0}}}}, 0, 0 },
    161   { "r8", 8, {0, {{{0, 0}}}}, 0, 0 },
    162   { "r9", 9, {0, {{{0, 0}}}}, 0, 0 },
    163   { "r10", 10, {0, {{{0, 0}}}}, 0, 0 },
    164   { "r11", 11, {0, {{{0, 0}}}}, 0, 0 },
    165   { "r12", 12, {0, {{{0, 0}}}}, 0, 0 },
    166   { "r13", 13, {0, {{{0, 0}}}}, 0, 0 },
    167   { "r14", 14, {0, {{{0, 0}}}}, 0, 0 },
    168   { "r15", 15, {0, {{{0, 0}}}}, 0, 0 }
    169 };
    170 
    171 CGEN_KEYWORD m32r_cgen_opval_gr_names =
    172 {
    173   & m32r_cgen_opval_gr_names_entries[0],
    174   19,
    175   0, 0, 0, 0, ""
    176 };
    177 
    178 static CGEN_KEYWORD_ENTRY m32r_cgen_opval_cr_names_entries[] =
    179 {
    180   { "psw", 0, {0, {{{0, 0}}}}, 0, 0 },
    181   { "cbr", 1, {0, {{{0, 0}}}}, 0, 0 },
    182   { "spi", 2, {0, {{{0, 0}}}}, 0, 0 },
    183   { "spu", 3, {0, {{{0, 0}}}}, 0, 0 },
    184   { "bpc", 6, {0, {{{0, 0}}}}, 0, 0 },
    185   { "bbpsw", 8, {0, {{{0, 0}}}}, 0, 0 },
    186   { "bbpc", 14, {0, {{{0, 0}}}}, 0, 0 },
    187   { "evb", 5, {0, {{{0, 0}}}}, 0, 0 },
    188   { "cr0", 0, {0, {{{0, 0}}}}, 0, 0 },
    189   { "cr1", 1, {0, {{{0, 0}}}}, 0, 0 },
    190   { "cr2", 2, {0, {{{0, 0}}}}, 0, 0 },
    191   { "cr3", 3, {0, {{{0, 0}}}}, 0, 0 },
    192   { "cr4", 4, {0, {{{0, 0}}}}, 0, 0 },
    193   { "cr5", 5, {0, {{{0, 0}}}}, 0, 0 },
    194   { "cr6", 6, {0, {{{0, 0}}}}, 0, 0 },
    195   { "cr7", 7, {0, {{{0, 0}}}}, 0, 0 },
    196   { "cr8", 8, {0, {{{0, 0}}}}, 0, 0 },
    197   { "cr9", 9, {0, {{{0, 0}}}}, 0, 0 },
    198   { "cr10", 10, {0, {{{0, 0}}}}, 0, 0 },
    199   { "cr11", 11, {0, {{{0, 0}}}}, 0, 0 },
    200   { "cr12", 12, {0, {{{0, 0}}}}, 0, 0 },
    201   { "cr13", 13, {0, {{{0, 0}}}}, 0, 0 },
    202   { "cr14", 14, {0, {{{0, 0}}}}, 0, 0 },
    203   { "cr15", 15, {0, {{{0, 0}}}}, 0, 0 }
    204 };
    205 
    206 CGEN_KEYWORD m32r_cgen_opval_cr_names =
    207 {
    208   & m32r_cgen_opval_cr_names_entries[0],
    209   24,
    210   0, 0, 0, 0, ""
    211 };
    212 
    213 static CGEN_KEYWORD_ENTRY m32r_cgen_opval_h_accums_entries[] =
    214 {
    215   { "a0", 0, {0, {{{0, 0}}}}, 0, 0 },
    216   { "a1", 1, {0, {{{0, 0}}}}, 0, 0 }
    217 };
    218 
    219 CGEN_KEYWORD m32r_cgen_opval_h_accums =
    220 {
    221   & m32r_cgen_opval_h_accums_entries[0],
    222   2,
    223   0, 0, 0, 0, ""
    224 };
    225 
    226 
    227 /* The hardware table.  */
    228 
    229 #define A(a) (1 << CGEN_HW_##a)
    230 
    231 const CGEN_HW_ENTRY m32r_cgen_hw_table[] =
    232 {
    233   { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    234   { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    235   { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    236   { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    237   { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    238   { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { { { (1<<MACH_BASE), 0 } } } } },
    239   { "h-hi16", HW_H_HI16, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    240   { "h-slo16", HW_H_SLO16, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    241   { "h-ulo16", HW_H_ULO16, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    242   { "h-gr", HW_H_GR, CGEN_ASM_KEYWORD, (PTR) & m32r_cgen_opval_gr_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
    243   { "h-cr", HW_H_CR, CGEN_ASM_KEYWORD, (PTR) & m32r_cgen_opval_cr_names, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    244   { "h-accum", HW_H_ACCUM, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    245   { "h-accums", HW_H_ACCUMS, CGEN_ASM_KEYWORD, (PTR) & m32r_cgen_opval_h_accums, { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } } } } },
    246   { "h-cond", HW_H_COND, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    247   { "h-psw", HW_H_PSW, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    248   { "h-bpsw", HW_H_BPSW, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    249   { "h-bbpsw", HW_H_BBPSW, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    250   { "h-lock", HW_H_LOCK, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    251   { 0, 0, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
    252 };
    253 
    254 #undef A
    255 
    256 
    257 /* The instruction field table.  */
    258 
    259 #define A(a) (1 << CGEN_IFLD_##a)
    260 
    261 const CGEN_IFLD m32r_cgen_ifld_table[] =
    262 {
    263   { M32R_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    264   { M32R_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    265   { M32R_F_OP1, "f-op1", 0, 32, 0, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    266   { M32R_F_OP2, "f-op2", 0, 32, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    267   { M32R_F_COND, "f-cond", 0, 32, 4, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    268   { M32R_F_R1, "f-r1", 0, 32, 4, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    269   { M32R_F_R2, "f-r2", 0, 32, 12, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    270   { M32R_F_SIMM8, "f-simm8", 0, 32, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    271   { M32R_F_SIMM16, "f-simm16", 0, 32, 16, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    272   { M32R_F_SHIFT_OP2, "f-shift-op2", 0, 32, 8, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    273   { M32R_F_UIMM3, "f-uimm3", 0, 32, 5, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    274   { M32R_F_UIMM4, "f-uimm4", 0, 32, 12, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    275   { M32R_F_UIMM5, "f-uimm5", 0, 32, 11, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    276   { M32R_F_UIMM8, "f-uimm8", 0, 32, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    277   { M32R_F_UIMM16, "f-uimm16", 0, 32, 16, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    278   { M32R_F_UIMM24, "f-uimm24", 0, 32, 8, 24, { 0|A(RELOC)|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    279   { M32R_F_HI16, "f-hi16", 0, 32, 16, 16, { 0|A(SIGN_OPT), { { { (1<<MACH_BASE), 0 } } } }  },
    280   { M32R_F_DISP8, "f-disp8", 0, 32, 8, 8, { 0|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    281   { M32R_F_DISP16, "f-disp16", 0, 32, 16, 16, { 0|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    282   { M32R_F_DISP24, "f-disp24", 0, 32, 8, 24, { 0|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    283   { M32R_F_OP23, "f-op23", 0, 32, 9, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    284   { M32R_F_OP3, "f-op3", 0, 32, 14, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    285   { M32R_F_ACC, "f-acc", 0, 32, 8, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    286   { M32R_F_ACCS, "f-accs", 0, 32, 12, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    287   { M32R_F_ACCD, "f-accd", 0, 32, 4, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    288   { M32R_F_BITS67, "f-bits67", 0, 32, 6, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    289   { M32R_F_BIT4, "f-bit4", 0, 32, 4, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    290   { M32R_F_BIT14, "f-bit14", 0, 32, 14, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    291   { M32R_F_IMM1, "f-imm1", 0, 32, 15, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    292   { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
    293 };
    294 
    295 #undef A
    296 
    297 
    298 
    299 /* multi ifield declarations */
    300 
    301 
    302 
    303 /* multi ifield definitions */
    304 
    305 
    306 /* The operand table.  */
    307 
    308 #define A(a) (1 << CGEN_OPERAND_##a)
    309 #define OPERAND(op) M32R_OPERAND_##op
    310 
    311 const CGEN_OPERAND m32r_cgen_operand_table[] =
    312 {
    313 /* pc: program counter */
    314   { "pc", M32R_OPERAND_PC, HW_H_PC, 0, 0,
    315     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_NIL] } },
    316     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
    317 /* sr: source register */
    318   { "sr", M32R_OPERAND_SR, HW_H_GR, 12, 4,
    319     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_R2] } },
    320     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    321 /* dr: destination register */
    322   { "dr", M32R_OPERAND_DR, HW_H_GR, 4, 4,
    323     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_R1] } },
    324     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    325 /* src1: source register 1 */
    326   { "src1", M32R_OPERAND_SRC1, HW_H_GR, 4, 4,
    327     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_R1] } },
    328     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    329 /* src2: source register 2 */
    330   { "src2", M32R_OPERAND_SRC2, HW_H_GR, 12, 4,
    331     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_R2] } },
    332     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    333 /* scr: source control register */
    334   { "scr", M32R_OPERAND_SCR, HW_H_CR, 12, 4,
    335     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_R2] } },
    336     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    337 /* dcr: destination control register */
    338   { "dcr", M32R_OPERAND_DCR, HW_H_CR, 4, 4,
    339     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_R1] } },
    340     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    341 /* simm8: 8 bit signed immediate */
    342   { "simm8", M32R_OPERAND_SIMM8, HW_H_SINT, 8, 8,
    343     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_SIMM8] } },
    344     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    345 /* simm16: 16 bit signed immediate */
    346   { "simm16", M32R_OPERAND_SIMM16, HW_H_SINT, 16, 16,
    347     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_SIMM16] } },
    348     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    349 /* uimm3: 3 bit unsigned number */
    350   { "uimm3", M32R_OPERAND_UIMM3, HW_H_UINT, 5, 3,
    351     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_UIMM3] } },
    352     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    353 /* uimm4: 4 bit trap number */
    354   { "uimm4", M32R_OPERAND_UIMM4, HW_H_UINT, 12, 4,
    355     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_UIMM4] } },
    356     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    357 /* uimm5: 5 bit shift count */
    358   { "uimm5", M32R_OPERAND_UIMM5, HW_H_UINT, 11, 5,
    359     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_UIMM5] } },
    360     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    361 /* uimm8: 8 bit unsigned immediate */
    362   { "uimm8", M32R_OPERAND_UIMM8, HW_H_UINT, 8, 8,
    363     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_UIMM8] } },
    364     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    365 /* uimm16: 16 bit unsigned immediate */
    366   { "uimm16", M32R_OPERAND_UIMM16, HW_H_UINT, 16, 16,
    367     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_UIMM16] } },
    368     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    369 /* imm1: 1 bit immediate */
    370   { "imm1", M32R_OPERAND_IMM1, HW_H_UINT, 15, 1,
    371     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_IMM1] } },
    372     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } } } }  },
    373 /* accd: accumulator destination register */
    374   { "accd", M32R_OPERAND_ACCD, HW_H_ACCUMS, 4, 2,
    375     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_ACCD] } },
    376     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } } } }  },
    377 /* accs: accumulator source register */
    378   { "accs", M32R_OPERAND_ACCS, HW_H_ACCUMS, 12, 2,
    379     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_ACCS] } },
    380     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } } } }  },
    381 /* acc: accumulator reg (d) */
    382   { "acc", M32R_OPERAND_ACC, HW_H_ACCUMS, 8, 1,
    383     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_ACC] } },
    384     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } } } }  },
    385 /* hash: # prefix */
    386   { "hash", M32R_OPERAND_HASH, HW_H_SINT, 0, 0,
    387     { 0, { (const PTR) 0 } },
    388     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    389 /* hi16: high 16 bit immediate, sign optional */
    390   { "hi16", M32R_OPERAND_HI16, HW_H_HI16, 16, 16,
    391     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_HI16] } },
    392     { 0|A(SIGN_OPT), { { { (1<<MACH_BASE), 0 } } } }  },
    393 /* slo16: 16 bit signed immediate, for low() */
    394   { "slo16", M32R_OPERAND_SLO16, HW_H_SLO16, 16, 16,
    395     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_SIMM16] } },
    396     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    397 /* ulo16: 16 bit unsigned immediate, for low() */
    398   { "ulo16", M32R_OPERAND_ULO16, HW_H_ULO16, 16, 16,
    399     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_UIMM16] } },
    400     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    401 /* uimm24: 24 bit address */
    402   { "uimm24", M32R_OPERAND_UIMM24, HW_H_ADDR, 8, 24,
    403     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_UIMM24] } },
    404     { 0|A(RELOC)|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    405 /* disp8: 8 bit displacement */
    406   { "disp8", M32R_OPERAND_DISP8, HW_H_IADDR, 8, 8,
    407     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_DISP8] } },
    408     { 0|A(RELAX)|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    409 /* disp16: 16 bit displacement */
    410   { "disp16", M32R_OPERAND_DISP16, HW_H_IADDR, 16, 16,
    411     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_DISP16] } },
    412     { 0|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    413 /* disp24: 24 bit displacement */
    414   { "disp24", M32R_OPERAND_DISP24, HW_H_IADDR, 8, 24,
    415     { 0, { (const PTR) &m32r_cgen_ifld_table[M32R_F_DISP24] } },
    416     { 0|A(RELAX)|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    417 /* condbit: condition bit */
    418   { "condbit", M32R_OPERAND_CONDBIT, HW_H_COND, 0, 0,
    419     { 0, { (const PTR) 0 } },
    420     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
    421 /* accum: accumulator */
    422   { "accum", M32R_OPERAND_ACCUM, HW_H_ACCUM, 0, 0,
    423     { 0, { (const PTR) 0 } },
    424     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
    425 /* sentinel */
    426   { 0, 0, 0, 0, 0,
    427     { 0, { (const PTR) 0 } },
    428     { 0, { { { (1<<MACH_BASE), 0 } } } } }
    429 };
    430 
    431 #undef A
    432 
    433 
    434 /* The instruction table.  */
    435 
    436 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
    437 #define A(a) (1 << CGEN_INSN_##a)
    438 
    439 static const CGEN_IBASE m32r_cgen_insn_table[MAX_INSNS] =
    440 {
    441   /* Special null first entry.
    442      A `num' value of zero is thus invalid.
    443      Also, the special `invalid' insn resides here.  */
    444   { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } } },
    445 /* add $dr,$sr */
    446   {
    447     M32R_INSN_ADD, "add", "add", 16,
    448     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    449   },
    450 /* add3 $dr,$sr,$hash$slo16 */
    451   {
    452     M32R_INSN_ADD3, "add3", "add3", 32,
    453     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    454   },
    455 /* and $dr,$sr */
    456   {
    457     M32R_INSN_AND, "and", "and", 16,
    458     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    459   },
    460 /* and3 $dr,$sr,$uimm16 */
    461   {
    462     M32R_INSN_AND3, "and3", "and3", 32,
    463     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    464   },
    465 /* or $dr,$sr */
    466   {
    467     M32R_INSN_OR, "or", "or", 16,
    468     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    469   },
    470 /* or3 $dr,$sr,$hash$ulo16 */
    471   {
    472     M32R_INSN_OR3, "or3", "or3", 32,
    473     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    474   },
    475 /* xor $dr,$sr */
    476   {
    477     M32R_INSN_XOR, "xor", "xor", 16,
    478     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    479   },
    480 /* xor3 $dr,$sr,$uimm16 */
    481   {
    482     M32R_INSN_XOR3, "xor3", "xor3", 32,
    483     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    484   },
    485 /* addi $dr,$simm8 */
    486   {
    487     M32R_INSN_ADDI, "addi", "addi", 16,
    488     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    489   },
    490 /* addv $dr,$sr */
    491   {
    492     M32R_INSN_ADDV, "addv", "addv", 16,
    493     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    494   },
    495 /* addv3 $dr,$sr,$simm16 */
    496   {
    497     M32R_INSN_ADDV3, "addv3", "addv3", 32,
    498     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    499   },
    500 /* addx $dr,$sr */
    501   {
    502     M32R_INSN_ADDX, "addx", "addx", 16,
    503     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    504   },
    505 /* bc.s $disp8 */
    506   {
    507     M32R_INSN_BC8, "bc8", "bc.s", 16,
    508     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    509   },
    510 /* bc.l $disp24 */
    511   {
    512     M32R_INSN_BC24, "bc24", "bc.l", 32,
    513     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    514   },
    515 /* beq $src1,$src2,$disp16 */
    516   {
    517     M32R_INSN_BEQ, "beq", "beq", 32,
    518     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    519   },
    520 /* beqz $src2,$disp16 */
    521   {
    522     M32R_INSN_BEQZ, "beqz", "beqz", 32,
    523     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    524   },
    525 /* bgez $src2,$disp16 */
    526   {
    527     M32R_INSN_BGEZ, "bgez", "bgez", 32,
    528     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    529   },
    530 /* bgtz $src2,$disp16 */
    531   {
    532     M32R_INSN_BGTZ, "bgtz", "bgtz", 32,
    533     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    534   },
    535 /* blez $src2,$disp16 */
    536   {
    537     M32R_INSN_BLEZ, "blez", "blez", 32,
    538     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    539   },
    540 /* bltz $src2,$disp16 */
    541   {
    542     M32R_INSN_BLTZ, "bltz", "bltz", 32,
    543     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    544   },
    545 /* bnez $src2,$disp16 */
    546   {
    547     M32R_INSN_BNEZ, "bnez", "bnez", 32,
    548     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    549   },
    550 /* bl.s $disp8 */
    551   {
    552     M32R_INSN_BL8, "bl8", "bl.s", 16,
    553     { 0|A(FILL_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    554   },
    555 /* bl.l $disp24 */
    556   {
    557     M32R_INSN_BL24, "bl24", "bl.l", 32,
    558     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    559   },
    560 /* bcl.s $disp8 */
    561   {
    562     M32R_INSN_BCL8, "bcl8", "bcl.s", 16,
    563     { 0|A(FILL_SLOT)|A(COND_CTI), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
    564   },
    565 /* bcl.l $disp24 */
    566   {
    567     M32R_INSN_BCL24, "bcl24", "bcl.l", 32,
    568     { 0|A(COND_CTI), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    569   },
    570 /* bnc.s $disp8 */
    571   {
    572     M32R_INSN_BNC8, "bnc8", "bnc.s", 16,
    573     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    574   },
    575 /* bnc.l $disp24 */
    576   {
    577     M32R_INSN_BNC24, "bnc24", "bnc.l", 32,
    578     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    579   },
    580 /* bne $src1,$src2,$disp16 */
    581   {
    582     M32R_INSN_BNE, "bne", "bne", 32,
    583     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    584   },
    585 /* bra.s $disp8 */
    586   {
    587     M32R_INSN_BRA8, "bra8", "bra.s", 16,
    588     { 0|A(FILL_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    589   },
    590 /* bra.l $disp24 */
    591   {
    592     M32R_INSN_BRA24, "bra24", "bra.l", 32,
    593     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    594   },
    595 /* bncl.s $disp8 */
    596   {
    597     M32R_INSN_BNCL8, "bncl8", "bncl.s", 16,
    598     { 0|A(FILL_SLOT)|A(COND_CTI), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
    599   },
    600 /* bncl.l $disp24 */
    601   {
    602     M32R_INSN_BNCL24, "bncl24", "bncl.l", 32,
    603     { 0|A(COND_CTI), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    604   },
    605 /* cmp $src1,$src2 */
    606   {
    607     M32R_INSN_CMP, "cmp", "cmp", 16,
    608     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    609   },
    610 /* cmpi $src2,$simm16 */
    611   {
    612     M32R_INSN_CMPI, "cmpi", "cmpi", 32,
    613     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    614   },
    615 /* cmpu $src1,$src2 */
    616   {
    617     M32R_INSN_CMPU, "cmpu", "cmpu", 16,
    618     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    619   },
    620 /* cmpui $src2,$simm16 */
    621   {
    622     M32R_INSN_CMPUI, "cmpui", "cmpui", 32,
    623     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    624   },
    625 /* cmpeq $src1,$src2 */
    626   {
    627     M32R_INSN_CMPEQ, "cmpeq", "cmpeq", 16,
    628     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_OS, 0 } } } }
    629   },
    630 /* cmpz $src2 */
    631   {
    632     M32R_INSN_CMPZ, "cmpz", "cmpz", 16,
    633     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_OS, 0 } } } }
    634   },
    635 /* div $dr,$sr */
    636   {
    637     M32R_INSN_DIV, "div", "div", 32,
    638     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    639   },
    640 /* divu $dr,$sr */
    641   {
    642     M32R_INSN_DIVU, "divu", "divu", 32,
    643     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    644   },
    645 /* rem $dr,$sr */
    646   {
    647     M32R_INSN_REM, "rem", "rem", 32,
    648     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    649   },
    650 /* remu $dr,$sr */
    651   {
    652     M32R_INSN_REMU, "remu", "remu", 32,
    653     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    654   },
    655 /* remh $dr,$sr */
    656   {
    657     M32R_INSN_REMH, "remh", "remh", 32,
    658     { 0, { { { (1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    659   },
    660 /* remuh $dr,$sr */
    661   {
    662     M32R_INSN_REMUH, "remuh", "remuh", 32,
    663     { 0, { { { (1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    664   },
    665 /* remb $dr,$sr */
    666   {
    667     M32R_INSN_REMB, "remb", "remb", 32,
    668     { 0, { { { (1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    669   },
    670 /* remub $dr,$sr */
    671   {
    672     M32R_INSN_REMUB, "remub", "remub", 32,
    673     { 0, { { { (1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    674   },
    675 /* divuh $dr,$sr */
    676   {
    677     M32R_INSN_DIVUH, "divuh", "divuh", 32,
    678     { 0, { { { (1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    679   },
    680 /* divb $dr,$sr */
    681   {
    682     M32R_INSN_DIVB, "divb", "divb", 32,
    683     { 0, { { { (1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    684   },
    685 /* divub $dr,$sr */
    686   {
    687     M32R_INSN_DIVUB, "divub", "divub", 32,
    688     { 0, { { { (1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    689   },
    690 /* divh $dr,$sr */
    691   {
    692     M32R_INSN_DIVH, "divh", "divh", 32,
    693     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
    694   },
    695 /* jc $sr */
    696   {
    697     M32R_INSN_JC, "jc", "jc", 16,
    698     { 0|A(SPECIAL)|A(COND_CTI), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
    699   },
    700 /* jnc $sr */
    701   {
    702     M32R_INSN_JNC, "jnc", "jnc", 16,
    703     { 0|A(SPECIAL)|A(COND_CTI), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
    704   },
    705 /* jl $sr */
    706   {
    707     M32R_INSN_JL, "jl", "jl", 16,
    708     { 0|A(FILL_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    709   },
    710 /* jmp $sr */
    711   {
    712     M32R_INSN_JMP, "jmp", "jmp", 16,
    713     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    714   },
    715 /* ld $dr,@$sr */
    716   {
    717     M32R_INSN_LD, "ld", "ld", 16,
    718     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    719   },
    720 /* ld $dr,@($slo16,$sr) */
    721   {
    722     M32R_INSN_LD_D, "ld-d", "ld", 32,
    723     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    724   },
    725 /* ldb $dr,@$sr */
    726   {
    727     M32R_INSN_LDB, "ldb", "ldb", 16,
    728     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    729   },
    730 /* ldb $dr,@($slo16,$sr) */
    731   {
    732     M32R_INSN_LDB_D, "ldb-d", "ldb", 32,
    733     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    734   },
    735 /* ldh $dr,@$sr */
    736   {
    737     M32R_INSN_LDH, "ldh", "ldh", 16,
    738     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    739   },
    740 /* ldh $dr,@($slo16,$sr) */
    741   {
    742     M32R_INSN_LDH_D, "ldh-d", "ldh", 32,
    743     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    744   },
    745 /* ldub $dr,@$sr */
    746   {
    747     M32R_INSN_LDUB, "ldub", "ldub", 16,
    748     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    749   },
    750 /* ldub $dr,@($slo16,$sr) */
    751   {
    752     M32R_INSN_LDUB_D, "ldub-d", "ldub", 32,
    753     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    754   },
    755 /* lduh $dr,@$sr */
    756   {
    757     M32R_INSN_LDUH, "lduh", "lduh", 16,
    758     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    759   },
    760 /* lduh $dr,@($slo16,$sr) */
    761   {
    762     M32R_INSN_LDUH_D, "lduh-d", "lduh", 32,
    763     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    764   },
    765 /* ld $dr,@$sr+ */
    766   {
    767     M32R_INSN_LD_PLUS, "ld-plus", "ld", 16,
    768     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    769   },
    770 /* ld24 $dr,$uimm24 */
    771   {
    772     M32R_INSN_LD24, "ld24", "ld24", 32,
    773     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    774   },
    775 /* ldi8 $dr,$simm8 */
    776   {
    777     M32R_INSN_LDI8, "ldi8", "ldi8", 16,
    778     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    779   },
    780 /* ldi16 $dr,$hash$slo16 */
    781   {
    782     M32R_INSN_LDI16, "ldi16", "ldi16", 32,
    783     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    784   },
    785 /* lock $dr,@$sr */
    786   {
    787     M32R_INSN_LOCK, "lock", "lock", 16,
    788     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    789   },
    790 /* machi $src1,$src2 */
    791   {
    792     M32R_INSN_MACHI, "machi", "machi", 16,
    793     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    794   },
    795 /* machi $src1,$src2,$acc */
    796   {
    797     M32R_INSN_MACHI_A, "machi-a", "machi", 16,
    798     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    799   },
    800 /* maclo $src1,$src2 */
    801   {
    802     M32R_INSN_MACLO, "maclo", "maclo", 16,
    803     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    804   },
    805 /* maclo $src1,$src2,$acc */
    806   {
    807     M32R_INSN_MACLO_A, "maclo-a", "maclo", 16,
    808     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    809   },
    810 /* macwhi $src1,$src2 */
    811   {
    812     M32R_INSN_MACWHI, "macwhi", "macwhi", 16,
    813     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    814   },
    815 /* macwhi $src1,$src2,$acc */
    816   {
    817     M32R_INSN_MACWHI_A, "macwhi-a", "macwhi", 16,
    818     { 0|A(SPECIAL), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    819   },
    820 /* macwlo $src1,$src2 */
    821   {
    822     M32R_INSN_MACWLO, "macwlo", "macwlo", 16,
    823     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    824   },
    825 /* macwlo $src1,$src2,$acc */
    826   {
    827     M32R_INSN_MACWLO_A, "macwlo-a", "macwlo", 16,
    828     { 0|A(SPECIAL), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    829   },
    830 /* mul $dr,$sr */
    831   {
    832     M32R_INSN_MUL, "mul", "mul", 16,
    833     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_S, 0 } } } }
    834   },
    835 /* mulhi $src1,$src2 */
    836   {
    837     M32R_INSN_MULHI, "mulhi", "mulhi", 16,
    838     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    839   },
    840 /* mulhi $src1,$src2,$acc */
    841   {
    842     M32R_INSN_MULHI_A, "mulhi-a", "mulhi", 16,
    843     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    844   },
    845 /* mullo $src1,$src2 */
    846   {
    847     M32R_INSN_MULLO, "mullo", "mullo", 16,
    848     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    849   },
    850 /* mullo $src1,$src2,$acc */
    851   {
    852     M32R_INSN_MULLO_A, "mullo-a", "mullo", 16,
    853     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    854   },
    855 /* mulwhi $src1,$src2 */
    856   {
    857     M32R_INSN_MULWHI, "mulwhi", "mulwhi", 16,
    858     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    859   },
    860 /* mulwhi $src1,$src2,$acc */
    861   {
    862     M32R_INSN_MULWHI_A, "mulwhi-a", "mulwhi", 16,
    863     { 0|A(SPECIAL), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    864   },
    865 /* mulwlo $src1,$src2 */
    866   {
    867     M32R_INSN_MULWLO, "mulwlo", "mulwlo", 16,
    868     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    869   },
    870 /* mulwlo $src1,$src2,$acc */
    871   {
    872     M32R_INSN_MULWLO_A, "mulwlo-a", "mulwlo", 16,
    873     { 0|A(SPECIAL), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    874   },
    875 /* mv $dr,$sr */
    876   {
    877     M32R_INSN_MV, "mv", "mv", 16,
    878     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    879   },
    880 /* mvfachi $dr */
    881   {
    882     M32R_INSN_MVFACHI, "mvfachi", "mvfachi", 16,
    883     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    884   },
    885 /* mvfachi $dr,$accs */
    886   {
    887     M32R_INSN_MVFACHI_A, "mvfachi-a", "mvfachi", 16,
    888     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    889   },
    890 /* mvfaclo $dr */
    891   {
    892     M32R_INSN_MVFACLO, "mvfaclo", "mvfaclo", 16,
    893     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    894   },
    895 /* mvfaclo $dr,$accs */
    896   {
    897     M32R_INSN_MVFACLO_A, "mvfaclo-a", "mvfaclo", 16,
    898     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    899   },
    900 /* mvfacmi $dr */
    901   {
    902     M32R_INSN_MVFACMI, "mvfacmi", "mvfacmi", 16,
    903     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    904   },
    905 /* mvfacmi $dr,$accs */
    906   {
    907     M32R_INSN_MVFACMI_A, "mvfacmi-a", "mvfacmi", 16,
    908     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    909   },
    910 /* mvfc $dr,$scr */
    911   {
    912     M32R_INSN_MVFC, "mvfc", "mvfc", 16,
    913     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    914   },
    915 /* mvtachi $src1 */
    916   {
    917     M32R_INSN_MVTACHI, "mvtachi", "mvtachi", 16,
    918     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    919   },
    920 /* mvtachi $src1,$accs */
    921   {
    922     M32R_INSN_MVTACHI_A, "mvtachi-a", "mvtachi", 16,
    923     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    924   },
    925 /* mvtaclo $src1 */
    926   {
    927     M32R_INSN_MVTACLO, "mvtaclo", "mvtaclo", 16,
    928     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    929   },
    930 /* mvtaclo $src1,$accs */
    931   {
    932     M32R_INSN_MVTACLO_A, "mvtaclo-a", "mvtaclo", 16,
    933     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    934   },
    935 /* mvtc $sr,$dcr */
    936   {
    937     M32R_INSN_MVTC, "mvtc", "mvtc", 16,
    938     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    939   },
    940 /* neg $dr,$sr */
    941   {
    942     M32R_INSN_NEG, "neg", "neg", 16,
    943     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    944   },
    945 /* nop */
    946   {
    947     M32R_INSN_NOP, "nop", "nop", 16,
    948     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    949   },
    950 /* not $dr,$sr */
    951   {
    952     M32R_INSN_NOT, "not", "not", 16,
    953     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
    954   },
    955 /* rac */
    956   {
    957     M32R_INSN_RAC, "rac", "rac", 16,
    958     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    959   },
    960 /* rac $accd,$accs,$imm1 */
    961   {
    962     M32R_INSN_RAC_DSI, "rac-dsi", "rac", 16,
    963     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    964   },
    965 /* rach */
    966   {
    967     M32R_INSN_RACH, "rach", "rach", 16,
    968     { 0, { { { (1<<MACH_M32R), 0 } }, { { PIPE_S, 0 } } } }
    969   },
    970 /* rach $accd,$accs,$imm1 */
    971   {
    972     M32R_INSN_RACH_DSI, "rach-dsi", "rach", 16,
    973     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
    974   },
    975 /* rte */
    976   {
    977     M32R_INSN_RTE, "rte", "rte", 16,
    978     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
    979   },
    980 /* seth $dr,$hash$hi16 */
    981   {
    982     M32R_INSN_SETH, "seth", "seth", 32,
    983     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    984   },
    985 /* sll $dr,$sr */
    986   {
    987     M32R_INSN_SLL, "sll", "sll", 16,
    988     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O_OS, 0 } } } }
    989   },
    990 /* sll3 $dr,$sr,$simm16 */
    991   {
    992     M32R_INSN_SLL3, "sll3", "sll3", 32,
    993     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
    994   },
    995 /* slli $dr,$uimm5 */
    996   {
    997     M32R_INSN_SLLI, "slli", "slli", 16,
    998     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O_OS, 0 } } } }
    999   },
   1000 /* sra $dr,$sr */
   1001   {
   1002     M32R_INSN_SRA, "sra", "sra", 16,
   1003     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O_OS, 0 } } } }
   1004   },
   1005 /* sra3 $dr,$sr,$simm16 */
   1006   {
   1007     M32R_INSN_SRA3, "sra3", "sra3", 32,
   1008     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
   1009   },
   1010 /* srai $dr,$uimm5 */
   1011   {
   1012     M32R_INSN_SRAI, "srai", "srai", 16,
   1013     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O_OS, 0 } } } }
   1014   },
   1015 /* srl $dr,$sr */
   1016   {
   1017     M32R_INSN_SRL, "srl", "srl", 16,
   1018     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O_OS, 0 } } } }
   1019   },
   1020 /* srl3 $dr,$sr,$simm16 */
   1021   {
   1022     M32R_INSN_SRL3, "srl3", "srl3", 32,
   1023     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
   1024   },
   1025 /* srli $dr,$uimm5 */
   1026   {
   1027     M32R_INSN_SRLI, "srli", "srli", 16,
   1028     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O_OS, 0 } } } }
   1029   },
   1030 /* st $src1,@$src2 */
   1031   {
   1032     M32R_INSN_ST, "st", "st", 16,
   1033     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1034   },
   1035 /* st $src1,@($slo16,$src2) */
   1036   {
   1037     M32R_INSN_ST_D, "st-d", "st", 32,
   1038     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
   1039   },
   1040 /* stb $src1,@$src2 */
   1041   {
   1042     M32R_INSN_STB, "stb", "stb", 16,
   1043     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1044   },
   1045 /* stb $src1,@($slo16,$src2) */
   1046   {
   1047     M32R_INSN_STB_D, "stb-d", "stb", 32,
   1048     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
   1049   },
   1050 /* sth $src1,@$src2 */
   1051   {
   1052     M32R_INSN_STH, "sth", "sth", 16,
   1053     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1054   },
   1055 /* sth $src1,@($slo16,$src2) */
   1056   {
   1057     M32R_INSN_STH_D, "sth-d", "sth", 32,
   1058     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
   1059   },
   1060 /* st $src1,@+$src2 */
   1061   {
   1062     M32R_INSN_ST_PLUS, "st-plus", "st", 16,
   1063     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1064   },
   1065 /* sth $src1,@$src2+ */
   1066   {
   1067     M32R_INSN_STH_PLUS, "sth-plus", "sth", 16,
   1068     { 0|A(SPECIAL), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
   1069   },
   1070 /* stb $src1,@$src2+ */
   1071   {
   1072     M32R_INSN_STB_PLUS, "stb-plus", "stb", 16,
   1073     { 0|A(SPECIAL), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
   1074   },
   1075 /* st $src1,@-$src2 */
   1076   {
   1077     M32R_INSN_ST_MINUS, "st-minus", "st", 16,
   1078     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1079   },
   1080 /* sub $dr,$sr */
   1081   {
   1082     M32R_INSN_SUB, "sub", "sub", 16,
   1083     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
   1084   },
   1085 /* subv $dr,$sr */
   1086   {
   1087     M32R_INSN_SUBV, "subv", "subv", 16,
   1088     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
   1089   },
   1090 /* subx $dr,$sr */
   1091   {
   1092     M32R_INSN_SUBX, "subx", "subx", 16,
   1093     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
   1094   },
   1095 /* trap $uimm4 */
   1096   {
   1097     M32R_INSN_TRAP, "trap", "trap", 16,
   1098     { 0|A(FILL_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1099   },
   1100 /* unlock $src1,@$src2 */
   1101   {
   1102     M32R_INSN_UNLOCK, "unlock", "unlock", 16,
   1103     { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1104   },
   1105 /* satb $dr,$sr */
   1106   {
   1107     M32R_INSN_SATB, "satb", "satb", 32,
   1108     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
   1109   },
   1110 /* sath $dr,$sr */
   1111   {
   1112     M32R_INSN_SATH, "sath", "sath", 32,
   1113     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
   1114   },
   1115 /* sat $dr,$sr */
   1116   {
   1117     M32R_INSN_SAT, "sat", "sat", 32,
   1118     { 0|A(SPECIAL), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
   1119   },
   1120 /* pcmpbz $src2 */
   1121   {
   1122     M32R_INSN_PCMPBZ, "pcmpbz", "pcmpbz", 16,
   1123     { 0|A(SPECIAL), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_OS, 0 } } } }
   1124   },
   1125 /* sadd */
   1126   {
   1127     M32R_INSN_SADD, "sadd", "sadd", 16,
   1128     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
   1129   },
   1130 /* macwu1 $src1,$src2 */
   1131   {
   1132     M32R_INSN_MACWU1, "macwu1", "macwu1", 16,
   1133     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
   1134   },
   1135 /* msblo $src1,$src2 */
   1136   {
   1137     M32R_INSN_MSBLO, "msblo", "msblo", 16,
   1138     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
   1139   },
   1140 /* mulwu1 $src1,$src2 */
   1141   {
   1142     M32R_INSN_MULWU1, "mulwu1", "mulwu1", 16,
   1143     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
   1144   },
   1145 /* maclh1 $src1,$src2 */
   1146   {
   1147     M32R_INSN_MACLH1, "maclh1", "maclh1", 16,
   1148     { 0, { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
   1149   },
   1150 /* sc */
   1151   {
   1152     M32R_INSN_SC, "sc", "sc", 16,
   1153     { 0|A(SPECIAL)|A(SKIP_CTI), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
   1154   },
   1155 /* snc */
   1156   {
   1157     M32R_INSN_SNC, "snc", "snc", 16,
   1158     { 0|A(SPECIAL)|A(SKIP_CTI), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
   1159   },
   1160 /* clrpsw $uimm8 */
   1161   {
   1162     M32R_INSN_CLRPSW, "clrpsw", "clrpsw", 16,
   1163     { 0|A(SPECIAL_M32R), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1164   },
   1165 /* setpsw $uimm8 */
   1166   {
   1167     M32R_INSN_SETPSW, "setpsw", "setpsw", 16,
   1168     { 0|A(SPECIAL_M32R), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1169   },
   1170 /* bset $uimm3,@($slo16,$sr) */
   1171   {
   1172     M32R_INSN_BSET, "bset", "bset", 32,
   1173     { 0|A(SPECIAL_M32R), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
   1174   },
   1175 /* bclr $uimm3,@($slo16,$sr) */
   1176   {
   1177     M32R_INSN_BCLR, "bclr", "bclr", 32,
   1178     { 0|A(SPECIAL_M32R), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
   1179   },
   1180 /* btst $uimm3,$sr */
   1181   {
   1182     M32R_INSN_BTST, "btst", "btst", 16,
   1183     { 0|A(SPECIAL_M32R), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
   1184   },
   1185 };
   1186 
   1187 #undef OP
   1188 #undef A
   1189 
   1190 /* Initialize anything needed to be done once, before any cpu_open call.  */
   1191 
   1192 static void
   1193 init_tables (void)
   1194 {
   1195 }
   1196 
   1197 static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
   1198 static void build_hw_table      (CGEN_CPU_TABLE *);
   1199 static void build_ifield_table  (CGEN_CPU_TABLE *);
   1200 static void build_operand_table (CGEN_CPU_TABLE *);
   1201 static void build_insn_table    (CGEN_CPU_TABLE *);
   1202 static void m32r_cgen_rebuild_tables (CGEN_CPU_TABLE *);
   1203 
   1204 /* Subroutine of m32r_cgen_cpu_open to look up a mach via its bfd name.  */
   1205 
   1206 static const CGEN_MACH *
   1207 lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
   1208 {
   1209   while (table->name)
   1210     {
   1211       if (strcmp (name, table->bfd_name) == 0)
   1212 	return table;
   1213       ++table;
   1214     }
   1215   abort ();
   1216 }
   1217 
   1218 /* Subroutine of m32r_cgen_cpu_open to build the hardware table.  */
   1219 
   1220 static void
   1221 build_hw_table (CGEN_CPU_TABLE *cd)
   1222 {
   1223   int i;
   1224   int machs = cd->machs;
   1225   const CGEN_HW_ENTRY *init = & m32r_cgen_hw_table[0];
   1226   /* MAX_HW is only an upper bound on the number of selected entries.
   1227      However each entry is indexed by it's enum so there can be holes in
   1228      the table.  */
   1229   const CGEN_HW_ENTRY **selected =
   1230     (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
   1231 
   1232   cd->hw_table.init_entries = init;
   1233   cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
   1234   memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
   1235   /* ??? For now we just use machs to determine which ones we want.  */
   1236   for (i = 0; init[i].name != NULL; ++i)
   1237     if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
   1238 	& machs)
   1239       selected[init[i].type] = &init[i];
   1240   cd->hw_table.entries = selected;
   1241   cd->hw_table.num_entries = MAX_HW;
   1242 }
   1243 
   1244 /* Subroutine of m32r_cgen_cpu_open to build the hardware table.  */
   1245 
   1246 static void
   1247 build_ifield_table (CGEN_CPU_TABLE *cd)
   1248 {
   1249   cd->ifld_table = & m32r_cgen_ifld_table[0];
   1250 }
   1251 
   1252 /* Subroutine of m32r_cgen_cpu_open to build the hardware table.  */
   1253 
   1254 static void
   1255 build_operand_table (CGEN_CPU_TABLE *cd)
   1256 {
   1257   int i;
   1258   int machs = cd->machs;
   1259   const CGEN_OPERAND *init = & m32r_cgen_operand_table[0];
   1260   /* MAX_OPERANDS is only an upper bound on the number of selected entries.
   1261      However each entry is indexed by it's enum so there can be holes in
   1262      the table.  */
   1263   const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected));
   1264 
   1265   cd->operand_table.init_entries = init;
   1266   cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
   1267   memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
   1268   /* ??? For now we just use mach to determine which ones we want.  */
   1269   for (i = 0; init[i].name != NULL; ++i)
   1270     if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
   1271 	& machs)
   1272       selected[init[i].type] = &init[i];
   1273   cd->operand_table.entries = selected;
   1274   cd->operand_table.num_entries = MAX_OPERANDS;
   1275 }
   1276 
   1277 /* Subroutine of m32r_cgen_cpu_open to build the hardware table.
   1278    ??? This could leave out insns not supported by the specified mach/isa,
   1279    but that would cause errors like "foo only supported by bar" to become
   1280    "unknown insn", so for now we include all insns and require the app to
   1281    do the checking later.
   1282    ??? On the other hand, parsing of such insns may require their hardware or
   1283    operand elements to be in the table [which they mightn't be].  */
   1284 
   1285 static void
   1286 build_insn_table (CGEN_CPU_TABLE *cd)
   1287 {
   1288   int i;
   1289   const CGEN_IBASE *ib = & m32r_cgen_insn_table[0];
   1290   CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
   1291 
   1292   memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
   1293   for (i = 0; i < MAX_INSNS; ++i)
   1294     insns[i].base = &ib[i];
   1295   cd->insn_table.init_entries = insns;
   1296   cd->insn_table.entry_size = sizeof (CGEN_IBASE);
   1297   cd->insn_table.num_init_entries = MAX_INSNS;
   1298 }
   1299 
   1300 /* Subroutine of m32r_cgen_cpu_open to rebuild the tables.  */
   1301 
   1302 static void
   1303 m32r_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
   1304 {
   1305   int i;
   1306   CGEN_BITSET *isas = cd->isas;
   1307   unsigned int machs = cd->machs;
   1308 
   1309   cd->int_insn_p = CGEN_INT_INSN_P;
   1310 
   1311   /* Data derived from the isa spec.  */
   1312 #define UNSET (CGEN_SIZE_UNKNOWN + 1)
   1313   cd->default_insn_bitsize = UNSET;
   1314   cd->base_insn_bitsize = UNSET;
   1315   cd->min_insn_bitsize = 65535; /* Some ridiculously big number.  */
   1316   cd->max_insn_bitsize = 0;
   1317   for (i = 0; i < MAX_ISAS; ++i)
   1318     if (cgen_bitset_contains (isas, i))
   1319       {
   1320 	const CGEN_ISA *isa = & m32r_cgen_isa_table[i];
   1321 
   1322 	/* Default insn sizes of all selected isas must be
   1323 	   equal or we set the result to 0, meaning "unknown".  */
   1324 	if (cd->default_insn_bitsize == UNSET)
   1325 	  cd->default_insn_bitsize = isa->default_insn_bitsize;
   1326 	else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
   1327 	  ; /* This is ok.  */
   1328 	else
   1329 	  cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
   1330 
   1331 	/* Base insn sizes of all selected isas must be equal
   1332 	   or we set the result to 0, meaning "unknown".  */
   1333 	if (cd->base_insn_bitsize == UNSET)
   1334 	  cd->base_insn_bitsize = isa->base_insn_bitsize;
   1335 	else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
   1336 	  ; /* This is ok.  */
   1337 	else
   1338 	  cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
   1339 
   1340 	/* Set min,max insn sizes.  */
   1341 	if (isa->min_insn_bitsize < cd->min_insn_bitsize)
   1342 	  cd->min_insn_bitsize = isa->min_insn_bitsize;
   1343 	if (isa->max_insn_bitsize > cd->max_insn_bitsize)
   1344 	  cd->max_insn_bitsize = isa->max_insn_bitsize;
   1345       }
   1346 
   1347   /* Data derived from the mach spec.  */
   1348   for (i = 0; i < MAX_MACHS; ++i)
   1349     if (((1 << i) & machs) != 0)
   1350       {
   1351 	const CGEN_MACH *mach = & m32r_cgen_mach_table[i];
   1352 
   1353 	if (mach->insn_chunk_bitsize != 0)
   1354 	{
   1355 	  if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
   1356 	    {
   1357 	      fprintf (stderr, "m32r_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
   1358 		       cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
   1359 	      abort ();
   1360 	    }
   1361 
   1362  	  cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
   1363 	}
   1364       }
   1365 
   1366   /* Determine which hw elements are used by MACH.  */
   1367   build_hw_table (cd);
   1368 
   1369   /* Build the ifield table.  */
   1370   build_ifield_table (cd);
   1371 
   1372   /* Determine which operands are used by MACH/ISA.  */
   1373   build_operand_table (cd);
   1374 
   1375   /* Build the instruction table.  */
   1376   build_insn_table (cd);
   1377 }
   1378 
   1379 /* Initialize a cpu table and return a descriptor.
   1380    It's much like opening a file, and must be the first function called.
   1381    The arguments are a set of (type/value) pairs, terminated with
   1382    CGEN_CPU_OPEN_END.
   1383 
   1384    Currently supported values:
   1385    CGEN_CPU_OPEN_ISAS:    bitmap of values in enum isa_attr
   1386    CGEN_CPU_OPEN_MACHS:   bitmap of values in enum mach_attr
   1387    CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
   1388    CGEN_CPU_OPEN_ENDIAN:  specify endian choice
   1389    CGEN_CPU_OPEN_END:     terminates arguments
   1390 
   1391    ??? Simultaneous multiple isas might not make sense, but it's not (yet)
   1392    precluded.  */
   1393 
   1394 CGEN_CPU_DESC
   1395 m32r_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
   1396 {
   1397   CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
   1398   static int init_p;
   1399   CGEN_BITSET *isas = 0;  /* 0 = "unspecified" */
   1400   unsigned int machs = 0; /* 0 = "unspecified" */
   1401   enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
   1402   va_list ap;
   1403 
   1404   if (! init_p)
   1405     {
   1406       init_tables ();
   1407       init_p = 1;
   1408     }
   1409 
   1410   memset (cd, 0, sizeof (*cd));
   1411 
   1412   va_start (ap, arg_type);
   1413   while (arg_type != CGEN_CPU_OPEN_END)
   1414     {
   1415       switch (arg_type)
   1416 	{
   1417 	case CGEN_CPU_OPEN_ISAS :
   1418 	  isas = va_arg (ap, CGEN_BITSET *);
   1419 	  break;
   1420 	case CGEN_CPU_OPEN_MACHS :
   1421 	  machs = va_arg (ap, unsigned int);
   1422 	  break;
   1423 	case CGEN_CPU_OPEN_BFDMACH :
   1424 	  {
   1425 	    const char *name = va_arg (ap, const char *);
   1426 	    const CGEN_MACH *mach =
   1427 	      lookup_mach_via_bfd_name (m32r_cgen_mach_table, name);
   1428 
   1429 	    machs |= 1 << mach->num;
   1430 	    break;
   1431 	  }
   1432 	case CGEN_CPU_OPEN_ENDIAN :
   1433 	  endian = va_arg (ap, enum cgen_endian);
   1434 	  break;
   1435 	default :
   1436 	  fprintf (stderr, "m32r_cgen_cpu_open: unsupported argument `%d'\n",
   1437 		   arg_type);
   1438 	  abort (); /* ??? return NULL? */
   1439 	}
   1440       arg_type = va_arg (ap, enum cgen_cpu_open_arg);
   1441     }
   1442   va_end (ap);
   1443 
   1444   /* Mach unspecified means "all".  */
   1445   if (machs == 0)
   1446     machs = (1 << MAX_MACHS) - 1;
   1447   /* Base mach is always selected.  */
   1448   machs |= 1;
   1449   if (endian == CGEN_ENDIAN_UNKNOWN)
   1450     {
   1451       /* ??? If target has only one, could have a default.  */
   1452       fprintf (stderr, "m32r_cgen_cpu_open: no endianness specified\n");
   1453       abort ();
   1454     }
   1455 
   1456   cd->isas = cgen_bitset_copy (isas);
   1457   cd->machs = machs;
   1458   cd->endian = endian;
   1459   /* FIXME: for the sparc case we can determine insn-endianness statically.
   1460      The worry here is where both data and insn endian can be independently
   1461      chosen, in which case this function will need another argument.
   1462      Actually, will want to allow for more arguments in the future anyway.  */
   1463   cd->insn_endian = endian;
   1464 
   1465   /* Table (re)builder.  */
   1466   cd->rebuild_tables = m32r_cgen_rebuild_tables;
   1467   m32r_cgen_rebuild_tables (cd);
   1468 
   1469   /* Default to not allowing signed overflow.  */
   1470   cd->signed_overflow_ok_p = 0;
   1471 
   1472   return (CGEN_CPU_DESC) cd;
   1473 }
   1474 
   1475 /* Cover fn to m32r_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
   1476    MACH_NAME is the bfd name of the mach.  */
   1477 
   1478 CGEN_CPU_DESC
   1479 m32r_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
   1480 {
   1481   return m32r_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
   1482 			       CGEN_CPU_OPEN_ENDIAN, endian,
   1483 			       CGEN_CPU_OPEN_END);
   1484 }
   1485 
   1486 /* Close a cpu table.
   1487    ??? This can live in a machine independent file, but there's currently
   1488    no place to put this file (there's no libcgen).  libopcodes is the wrong
   1489    place as some simulator ports use this but they don't use libopcodes.  */
   1490 
   1491 void
   1492 m32r_cgen_cpu_close (CGEN_CPU_DESC cd)
   1493 {
   1494   unsigned int i;
   1495   const CGEN_INSN *insns;
   1496 
   1497   if (cd->macro_insn_table.init_entries)
   1498     {
   1499       insns = cd->macro_insn_table.init_entries;
   1500       for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
   1501 	if (CGEN_INSN_RX ((insns)))
   1502 	  regfree (CGEN_INSN_RX (insns));
   1503     }
   1504 
   1505   if (cd->insn_table.init_entries)
   1506     {
   1507       insns = cd->insn_table.init_entries;
   1508       for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
   1509 	if (CGEN_INSN_RX (insns))
   1510 	  regfree (CGEN_INSN_RX (insns));
   1511     }
   1512 
   1513   if (cd->macro_insn_table.init_entries)
   1514     free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
   1515 
   1516   if (cd->insn_table.init_entries)
   1517     free ((CGEN_INSN *) cd->insn_table.init_entries);
   1518 
   1519   if (cd->hw_table.entries)
   1520     free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
   1521 
   1522   if (cd->operand_table.entries)
   1523     free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
   1524 
   1525   free (cd);
   1526 }
   1527 
   1528