opcodes/fr30-desc.c

   1 /* CPU data for fr30.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright (C) 1996-2017 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 "fr30-desc.h"
  32 #include "fr30-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   { "fr30", MACH_FR30 },
  50   { "max", MACH_MAX },
  51   { 0, 0 }
  52 };
  53
  54 static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
  55 {
  56   { "fr30", ISA_FR30 },
  57   { "max", ISA_MAX },
  58   { 0, 0 }
  59 };
  60
  61 const CGEN_ATTR_TABLE fr30_cgen_ifield_attr_table[] =
  62 {
  63   { "MACH", & MACH_attr[0], & MACH_attr[0] },
  64   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
  65   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
  66   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
  67   { "RESERVED", &bool_attr[0], &bool_attr[0] },
  68   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
  69   { "SIGNED", &bool_attr[0], &bool_attr[0] },
  70   { 0, 0, 0 }
  71 };
  72
  73 const CGEN_ATTR_TABLE fr30_cgen_hardware_attr_table[] =
  74 {
  75   { "MACH", & MACH_attr[0], & MACH_attr[0] },
  76   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
  77   { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
  78   { "PC", &bool_attr[0], &bool_attr[0] },
  79   { "PROFILE", &bool_attr[0], &bool_attr[0] },
  80   { 0, 0, 0 }
  81 };
  82
  83 const CGEN_ATTR_TABLE fr30_cgen_operand_attr_table[] =
  84 {
  85   { "MACH", & MACH_attr[0], & MACH_attr[0] },
  86   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
  87   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
  88   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
  89   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
  90   { "SIGNED", &bool_attr[0], &bool_attr[0] },
  91   { "NEGATIVE", &bool_attr[0], &bool_attr[0] },
  92   { "RELAX", &bool_attr[0], &bool_attr[0] },
  93   { "SEM-ONLY", &bool_attr[0], &bool_attr[0] },
  94   { "HASH-PREFIX", &bool_attr[0], &bool_attr[0] },
  95   { 0, 0, 0 }
  96 };
  97
  98 const CGEN_ATTR_TABLE fr30_cgen_insn_attr_table[] =
  99 {
 100   { "MACH", & MACH_attr[0], & MACH_attr[0] },
 101   { "ALIAS", &bool_attr[0], &bool_attr[0] },
 102   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
 103   { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] },
 104   { "COND-CTI", &bool_attr[0], &bool_attr[0] },
 105   { "SKIP-CTI", &bool_attr[0], &bool_attr[0] },
 106   { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
 107   { "RELAXABLE", &bool_attr[0], &bool_attr[0] },
 108   { "RELAXED", &bool_attr[0], &bool_attr[0] },
 109   { "NO-DIS", &bool_attr[0], &bool_attr[0] },
 110   { "PBB", &bool_attr[0], &bool_attr[0] },
 111   { "NOT-IN-DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
 112   { 0, 0, 0 }
 113 };
 114
 115 /* Instruction set variants.  */
 116
 117 static const CGEN_ISA fr30_cgen_isa_table[] = {
 118   { "fr30", 16, 16, 16, 48 },
 119   { 0, 0, 0, 0, 0 }
 120 };
 121
 122 /* Machine variants.  */
 123
 124 static const CGEN_MACH fr30_cgen_mach_table[] = {
 125   { "fr30", "fr30", MACH_FR30, 0 },
 126   { 0, 0, 0, 0 }
 127 };
 128
 129 static CGEN_KEYWORD_ENTRY fr30_cgen_opval_gr_names_entries[] =
 130 {
 131   { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
 132   { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
 133   { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
 134   { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
 135   { "r4", 4, {0, {{{0, 0}}}}, 0, 0 },
 136   { "r5", 5, {0, {{{0, 0}}}}, 0, 0 },
 137   { "r6", 6, {0, {{{0, 0}}}}, 0, 0 },
 138   { "r7", 7, {0, {{{0, 0}}}}, 0, 0 },
 139   { "r8", 8, {0, {{{0, 0}}}}, 0, 0 },
 140   { "r9", 9, {0, {{{0, 0}}}}, 0, 0 },
 141   { "r10", 10, {0, {{{0, 0}}}}, 0, 0 },
 142   { "r11", 11, {0, {{{0, 0}}}}, 0, 0 },
 143   { "r12", 12, {0, {{{0, 0}}}}, 0, 0 },
 144   { "r13", 13, {0, {{{0, 0}}}}, 0, 0 },
 145   { "r14", 14, {0, {{{0, 0}}}}, 0, 0 },
 146   { "r15", 15, {0, {{{0, 0}}}}, 0, 0 },
 147   { "ac", 13, {0, {{{0, 0}}}}, 0, 0 },
 148   { "fp", 14, {0, {{{0, 0}}}}, 0, 0 },
 149   { "sp", 15, {0, {{{0, 0}}}}, 0, 0 }
 150 };
 151
 152 CGEN_KEYWORD fr30_cgen_opval_gr_names =
 153 {
 154   & fr30_cgen_opval_gr_names_entries[0],
 155   19,
 156   0, 0, 0, 0, ""
 157 };
 158
 159 static CGEN_KEYWORD_ENTRY fr30_cgen_opval_cr_names_entries[] =
 160 {
 161   { "cr0", 0, {0, {{{0, 0}}}}, 0, 0 },
 162   { "cr1", 1, {0, {{{0, 0}}}}, 0, 0 },
 163   { "cr2", 2, {0, {{{0, 0}}}}, 0, 0 },
 164   { "cr3", 3, {0, {{{0, 0}}}}, 0, 0 },
 165   { "cr4", 4, {0, {{{0, 0}}}}, 0, 0 },
 166   { "cr5", 5, {0, {{{0, 0}}}}, 0, 0 },
 167   { "cr6", 6, {0, {{{0, 0}}}}, 0, 0 },
 168   { "cr7", 7, {0, {{{0, 0}}}}, 0, 0 },
 169   { "cr8", 8, {0, {{{0, 0}}}}, 0, 0 },
 170   { "cr9", 9, {0, {{{0, 0}}}}, 0, 0 },
 171   { "cr10", 10, {0, {{{0, 0}}}}, 0, 0 },
 172   { "cr11", 11, {0, {{{0, 0}}}}, 0, 0 },
 173   { "cr12", 12, {0, {{{0, 0}}}}, 0, 0 },
 174   { "cr13", 13, {0, {{{0, 0}}}}, 0, 0 },
 175   { "cr14", 14, {0, {{{0, 0}}}}, 0, 0 },
 176   { "cr15", 15, {0, {{{0, 0}}}}, 0, 0 }
 177 };
 178
 179 CGEN_KEYWORD fr30_cgen_opval_cr_names =
 180 {
 181   & fr30_cgen_opval_cr_names_entries[0],
 182   16,
 183   0, 0, 0, 0, ""
 184 };
 185
 186 static CGEN_KEYWORD_ENTRY fr30_cgen_opval_dr_names_entries[] =
 187 {
 188   { "tbr", 0, {0, {{{0, 0}}}}, 0, 0 },
 189   { "rp", 1, {0, {{{0, 0}}}}, 0, 0 },
 190   { "ssp", 2, {0, {{{0, 0}}}}, 0, 0 },
 191   { "usp", 3, {0, {{{0, 0}}}}, 0, 0 },
 192   { "mdh", 4, {0, {{{0, 0}}}}, 0, 0 },
 193   { "mdl", 5, {0, {{{0, 0}}}}, 0, 0 }
 194 };
 195
 196 CGEN_KEYWORD fr30_cgen_opval_dr_names =
 197 {
 198   & fr30_cgen_opval_dr_names_entries[0],
 199   6,
 200   0, 0, 0, 0, ""
 201 };
 202
 203 static CGEN_KEYWORD_ENTRY fr30_cgen_opval_h_ps_entries[] =
 204 {
 205   { "ps", 0, {0, {{{0, 0}}}}, 0, 0 }
 206 };
 207
 208 CGEN_KEYWORD fr30_cgen_opval_h_ps =
 209 {
 210   & fr30_cgen_opval_h_ps_entries[0],
 211   1,
 212   0, 0, 0, 0, ""
 213 };
 214
 215 static CGEN_KEYWORD_ENTRY fr30_cgen_opval_h_r13_entries[] =
 216 {
 217   { "r13", 0, {0, {{{0, 0}}}}, 0, 0 }
 218 };
 219
 220 CGEN_KEYWORD fr30_cgen_opval_h_r13 =
 221 {
 222   & fr30_cgen_opval_h_r13_entries[0],
 223   1,
 224   0, 0, 0, 0, ""
 225 };
 226
 227 static CGEN_KEYWORD_ENTRY fr30_cgen_opval_h_r14_entries[] =
 228 {
 229   { "r14", 0, {0, {{{0, 0}}}}, 0, 0 }
 230 };
 231
 232 CGEN_KEYWORD fr30_cgen_opval_h_r14 =
 233 {
 234   & fr30_cgen_opval_h_r14_entries[0],
 235   1,
 236   0, 0, 0, 0, ""
 237 };
 238
 239 static CGEN_KEYWORD_ENTRY fr30_cgen_opval_h_r15_entries[] =
 240 {
 241   { "r15", 0, {0, {{{0, 0}}}}, 0, 0 }
 242 };
 243
 244 CGEN_KEYWORD fr30_cgen_opval_h_r15 =
 245 {
 246   & fr30_cgen_opval_h_r15_entries[0],
 247   1,
 248   0, 0, 0, 0, ""
 249 };
 250
 251
 252 /* The hardware table.  */
 253
 254 #define A(a) (1 << CGEN_HW_##a)
 255
 256 const CGEN_HW_ENTRY fr30_cgen_hw_table[] =
 257 {
 258   { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 259   { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 260   { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 261   { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 262   { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 263   { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { { { (1<<MACH_BASE), 0 } } } } },
 264   { "h-gr", HW_H_GR, CGEN_ASM_KEYWORD, (PTR) & fr30_cgen_opval_gr_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
 265   { "h-cr", HW_H_CR, CGEN_ASM_KEYWORD, (PTR) & fr30_cgen_opval_cr_names, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 266   { "h-dr", HW_H_DR, CGEN_ASM_KEYWORD, (PTR) & fr30_cgen_opval_dr_names, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 267   { "h-ps", HW_H_PS, CGEN_ASM_KEYWORD, (PTR) & fr30_cgen_opval_h_ps, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 268   { "h-r13", HW_H_R13, CGEN_ASM_KEYWORD, (PTR) & fr30_cgen_opval_h_r13, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 269   { "h-r14", HW_H_R14, CGEN_ASM_KEYWORD, (PTR) & fr30_cgen_opval_h_r14, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 270   { "h-r15", HW_H_R15, CGEN_ASM_KEYWORD, (PTR) & fr30_cgen_opval_h_r15, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 271   { "h-nbit", HW_H_NBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 272   { "h-zbit", HW_H_ZBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 273   { "h-vbit", HW_H_VBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 274   { "h-cbit", HW_H_CBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 275   { "h-ibit", HW_H_IBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 276   { "h-sbit", HW_H_SBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 277   { "h-tbit", HW_H_TBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 278   { "h-d0bit", HW_H_D0BIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 279   { "h-d1bit", HW_H_D1BIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 280   { "h-ccr", HW_H_CCR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 281   { "h-scr", HW_H_SCR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 282   { "h-ilm", HW_H_ILM, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 283   { 0, 0, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
 284 };
 285
 286 #undef A
 287
 288
 289 /* The instruction field table.  */
 290
 291 #define A(a) (1 << CGEN_IFLD_##a)
 292
 293 const CGEN_IFLD fr30_cgen_ifld_table[] =
 294 {
 295   { FR30_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 296   { FR30_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 297   { FR30_F_OP1, "f-op1", 0, 16, 0, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 298   { FR30_F_OP2, "f-op2", 0, 16, 4, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 299   { FR30_F_OP3, "f-op3", 0, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 300   { FR30_F_OP4, "f-op4", 0, 16, 12, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 301   { FR30_F_OP5, "f-op5", 0, 16, 4, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 302   { FR30_F_CC, "f-cc", 0, 16, 4, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 303   { FR30_F_CCC, "f-ccc", 16, 16, 0, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 304   { FR30_F_RJ, "f-Rj", 0, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 305   { FR30_F_RI, "f-Ri", 0, 16, 12, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 306   { FR30_F_RS1, "f-Rs1", 0, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 307   { FR30_F_RS2, "f-Rs2", 0, 16, 12, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 308   { FR30_F_RJC, "f-Rjc", 16, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 309   { FR30_F_RIC, "f-Ric", 16, 16, 12, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 310   { FR30_F_CRJ, "f-CRj", 16, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 311   { FR30_F_CRI, "f-CRi", 16, 16, 12, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 312   { FR30_F_U4, "f-u4", 0, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 313   { FR30_F_U4C, "f-u4c", 0, 16, 12, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 314   { FR30_F_I4, "f-i4", 0, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 315   { FR30_F_M4, "f-m4", 0, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 316   { FR30_F_U8, "f-u8", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 317   { FR30_F_I8, "f-i8", 0, 16, 4, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 318   { FR30_F_I20_4, "f-i20-4", 0, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 319   { FR30_F_I20_16, "f-i20-16", 16, 16, 0, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 320   { FR30_F_I20, "f-i20", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
 321   { FR30_F_I32, "f-i32", 16, 32, 0, 32, { 0|A(SIGN_OPT), { { { (1<<MACH_BASE), 0 } } } }  },
 322   { FR30_F_UDISP6, "f-udisp6", 0, 16, 8, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 323   { FR30_F_DISP8, "f-disp8", 0, 16, 4, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 324   { FR30_F_DISP9, "f-disp9", 0, 16, 4, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 325   { FR30_F_DISP10, "f-disp10", 0, 16, 4, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 326   { FR30_F_S10, "f-s10", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 327   { FR30_F_U10, "f-u10", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 328   { FR30_F_REL9, "f-rel9", 0, 16, 8, 8, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 329   { FR30_F_DIR8, "f-dir8", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 330   { FR30_F_DIR9, "f-dir9", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 331   { FR30_F_DIR10, "f-dir10", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 332   { FR30_F_REL12, "f-rel12", 0, 16, 5, 11, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 333   { FR30_F_REGLIST_HI_ST, "f-reglist_hi_st", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 334   { FR30_F_REGLIST_LOW_ST, "f-reglist_low_st", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 335   { FR30_F_REGLIST_HI_LD, "f-reglist_hi_ld", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 336   { FR30_F_REGLIST_LOW_LD, "f-reglist_low_ld", 0, 16, 8, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 337   { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
 338 };
 339
 340 #undef A
 341
 342
 343
 344 /* multi ifield declarations */
 345
 346 const CGEN_MAYBE_MULTI_IFLD FR30_F_I20_MULTI_IFIELD [];
 347
 348
 349 /* multi ifield definitions */
 350
 351 const CGEN_MAYBE_MULTI_IFLD FR30_F_I20_MULTI_IFIELD [] =
 352 {
 353     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_I20_4] } },
 354     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_I20_16] } },
 355     { 0, { (const PTR) 0 } }
 356 };
 357
 358 /* The operand table.  */
 359
 360 #define A(a) (1 << CGEN_OPERAND_##a)
 361 #define OPERAND(op) FR30_OPERAND_##op
 362
 363 const CGEN_OPERAND fr30_cgen_operand_table[] =
 364 {
 365 /* pc: program counter */
 366   { "pc", FR30_OPERAND_PC, HW_H_PC, 0, 0,
 367     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_NIL] } },
 368     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 369 /* Ri: destination register */
 370   { "Ri", FR30_OPERAND_RI, HW_H_GR, 12, 4,
 371     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_RI] } },
 372     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 373 /* Rj: source register */
 374   { "Rj", FR30_OPERAND_RJ, HW_H_GR, 8, 4,
 375     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_RJ] } },
 376     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 377 /* Ric: target register coproc insn */
 378   { "Ric", FR30_OPERAND_RIC, HW_H_GR, 12, 4,
 379     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_RIC] } },
 380     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 381 /* Rjc: source register coproc insn */
 382   { "Rjc", FR30_OPERAND_RJC, HW_H_GR, 8, 4,
 383     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_RJC] } },
 384     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 385 /* CRi: coprocessor register */
 386   { "CRi", FR30_OPERAND_CRI, HW_H_CR, 12, 4,
 387     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_CRI] } },
 388     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 389 /* CRj: coprocessor register */
 390   { "CRj", FR30_OPERAND_CRJ, HW_H_CR, 8, 4,
 391     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_CRJ] } },
 392     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 393 /* Rs1: dedicated register */
 394   { "Rs1", FR30_OPERAND_RS1, HW_H_DR, 8, 4,
 395     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_RS1] } },
 396     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 397 /* Rs2: dedicated register */
 398   { "Rs2", FR30_OPERAND_RS2, HW_H_DR, 12, 4,
 399     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_RS2] } },
 400     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 401 /* R13: General Register 13 */
 402   { "R13", FR30_OPERAND_R13, HW_H_R13, 0, 0,
 403     { 0, { (const PTR) 0 } },
 404     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 405 /* R14: General Register 14 */
 406   { "R14", FR30_OPERAND_R14, HW_H_R14, 0, 0,
 407     { 0, { (const PTR) 0 } },
 408     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 409 /* R15: General Register 15 */
 410   { "R15", FR30_OPERAND_R15, HW_H_R15, 0, 0,
 411     { 0, { (const PTR) 0 } },
 412     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 413 /* ps: Program Status register */
 414   { "ps", FR30_OPERAND_PS, HW_H_PS, 0, 0,
 415     { 0, { (const PTR) 0 } },
 416     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 417 /* u4: 4  bit unsigned immediate */
 418   { "u4", FR30_OPERAND_U4, HW_H_UINT, 8, 4,
 419     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_U4] } },
 420     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 421 /* u4c: 4  bit unsigned immediate */
 422   { "u4c", FR30_OPERAND_U4C, HW_H_UINT, 12, 4,
 423     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_U4C] } },
 424     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 425 /* u8: 8  bit unsigned immediate */
 426   { "u8", FR30_OPERAND_U8, HW_H_UINT, 8, 8,
 427     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_U8] } },
 428     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 429 /* i8: 8  bit unsigned immediate */
 430   { "i8", FR30_OPERAND_I8, HW_H_UINT, 4, 8,
 431     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_I8] } },
 432     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 433 /* udisp6: 6  bit unsigned immediate */
 434   { "udisp6", FR30_OPERAND_UDISP6, HW_H_UINT, 8, 4,
 435     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_UDISP6] } },
 436     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 437 /* disp8: 8  bit signed   immediate */
 438   { "disp8", FR30_OPERAND_DISP8, HW_H_SINT, 4, 8,
 439     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_DISP8] } },
 440     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 441 /* disp9: 9  bit signed   immediate */
 442   { "disp9", FR30_OPERAND_DISP9, HW_H_SINT, 4, 8,
 443     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_DISP9] } },
 444     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 445 /* disp10: 10 bit signed   immediate */
 446   { "disp10", FR30_OPERAND_DISP10, HW_H_SINT, 4, 8,
 447     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_DISP10] } },
 448     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 449 /* s10: 10 bit signed   immediate */
 450   { "s10", FR30_OPERAND_S10, HW_H_SINT, 8, 8,
 451     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_S10] } },
 452     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 453 /* u10: 10 bit unsigned immediate */
 454   { "u10", FR30_OPERAND_U10, HW_H_UINT, 8, 8,
 455     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_U10] } },
 456     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 457 /* i32: 32 bit immediate */
 458   { "i32", FR30_OPERAND_I32, HW_H_UINT, 0, 32,
 459     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_I32] } },
 460     { 0|A(HASH_PREFIX)|A(SIGN_OPT), { { { (1<<MACH_BASE), 0 } } } }  },
 461 /* m4: 4  bit negative immediate */
 462   { "m4", FR30_OPERAND_M4, HW_H_SINT, 8, 4,
 463     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_M4] } },
 464     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 465 /* i20: 20 bit immediate */
 466   { "i20", FR30_OPERAND_I20, HW_H_UINT, 0, 20,
 467     { 2, { (const PTR) &FR30_F_I20_MULTI_IFIELD[0] } },
 468     { 0|A(HASH_PREFIX)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
 469 /* dir8: 8  bit direct address */
 470   { "dir8", FR30_OPERAND_DIR8, HW_H_UINT, 8, 8,
 471     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_DIR8] } },
 472     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 473 /* dir9: 9  bit direct address */
 474   { "dir9", FR30_OPERAND_DIR9, HW_H_UINT, 8, 8,
 475     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_DIR9] } },
 476     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 477 /* dir10: 10 bit direct address */
 478   { "dir10", FR30_OPERAND_DIR10, HW_H_UINT, 8, 8,
 479     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_DIR10] } },
 480     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 481 /* label9: 9  bit pc relative address */
 482   { "label9", FR30_OPERAND_LABEL9, HW_H_IADDR, 8, 8,
 483     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_REL9] } },
 484     { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 485 /* label12: 12 bit pc relative address */
 486   { "label12", FR30_OPERAND_LABEL12, HW_H_IADDR, 5, 11,
 487     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_REL12] } },
 488     { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 489 /* reglist_low_ld: 8 bit low register mask for ldm */
 490   { "reglist_low_ld", FR30_OPERAND_REGLIST_LOW_LD, HW_H_UINT, 8, 8,
 491     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_REGLIST_LOW_LD] } },
 492     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 493 /* reglist_hi_ld: 8 bit high register mask for ldm */
 494   { "reglist_hi_ld", FR30_OPERAND_REGLIST_HI_LD, HW_H_UINT, 8, 8,
 495     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_REGLIST_HI_LD] } },
 496     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 497 /* reglist_low_st: 8 bit low register mask for stm */
 498   { "reglist_low_st", FR30_OPERAND_REGLIST_LOW_ST, HW_H_UINT, 8, 8,
 499     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_REGLIST_LOW_ST] } },
 500     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 501 /* reglist_hi_st: 8 bit high register mask for stm */
 502   { "reglist_hi_st", FR30_OPERAND_REGLIST_HI_ST, HW_H_UINT, 8, 8,
 503     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_REGLIST_HI_ST] } },
 504     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 505 /* cc: condition codes */
 506   { "cc", FR30_OPERAND_CC, HW_H_UINT, 4, 4,
 507     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_CC] } },
 508     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 509 /* ccc: coprocessor calc */
 510   { "ccc", FR30_OPERAND_CCC, HW_H_UINT, 0, 8,
 511     { 0, { (const PTR) &fr30_cgen_ifld_table[FR30_F_CCC] } },
 512     { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
 513 /* nbit: negative   bit */
 514   { "nbit", FR30_OPERAND_NBIT, HW_H_NBIT, 0, 0,
 515     { 0, { (const PTR) 0 } },
 516     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 517 /* vbit: overflow   bit */
 518   { "vbit", FR30_OPERAND_VBIT, HW_H_VBIT, 0, 0,
 519     { 0, { (const PTR) 0 } },
 520     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 521 /* zbit: zero       bit */
 522   { "zbit", FR30_OPERAND_ZBIT, HW_H_ZBIT, 0, 0,
 523     { 0, { (const PTR) 0 } },
 524     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 525 /* cbit: carry      bit */
 526   { "cbit", FR30_OPERAND_CBIT, HW_H_CBIT, 0, 0,
 527     { 0, { (const PTR) 0 } },
 528     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 529 /* ibit: interrupt  bit */
 530   { "ibit", FR30_OPERAND_IBIT, HW_H_IBIT, 0, 0,
 531     { 0, { (const PTR) 0 } },
 532     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 533 /* sbit: stack      bit */
 534   { "sbit", FR30_OPERAND_SBIT, HW_H_SBIT, 0, 0,
 535     { 0, { (const PTR) 0 } },
 536     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 537 /* tbit: trace trap bit */
 538   { "tbit", FR30_OPERAND_TBIT, HW_H_TBIT, 0, 0,
 539     { 0, { (const PTR) 0 } },
 540     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 541 /* d0bit: division 0 bit */
 542   { "d0bit", FR30_OPERAND_D0BIT, HW_H_D0BIT, 0, 0,
 543     { 0, { (const PTR) 0 } },
 544     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 545 /* d1bit: division 1 bit */
 546   { "d1bit", FR30_OPERAND_D1BIT, HW_H_D1BIT, 0, 0,
 547     { 0, { (const PTR) 0 } },
 548     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 549 /* ccr: condition code bits */
 550   { "ccr", FR30_OPERAND_CCR, HW_H_CCR, 0, 0,
 551     { 0, { (const PTR) 0 } },
 552     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 553 /* scr: system condition bits */
 554   { "scr", FR30_OPERAND_SCR, HW_H_SCR, 0, 0,
 555     { 0, { (const PTR) 0 } },
 556     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 557 /* ilm: interrupt level mask */
 558   { "ilm", FR30_OPERAND_ILM, HW_H_ILM, 0, 0,
 559     { 0, { (const PTR) 0 } },
 560     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 561 /* sentinel */
 562   { 0, 0, 0, 0, 0,
 563     { 0, { (const PTR) 0 } },
 564     { 0, { { { (1<<MACH_BASE), 0 } } } } }
 565 };
 566
 567 #undef A
 568
 569
 570 /* The instruction table.  */
 571
 572 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
 573 #define A(a) (1 << CGEN_INSN_##a)
 574
 575 static const CGEN_IBASE fr30_cgen_insn_table[MAX_INSNS] =
 576 {
 577   /* Special null first entry.
 578      A `num' value of zero is thus invalid.
 579      Also, the special `invalid' insn resides here.  */
 580   { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 581 /* add $Rj,$Ri */
 582   {
 583     FR30_INSN_ADD, "add", "add", 16,
 584     { 0, { { { (1<<MACH_BASE), 0 } } } }
 585   },
 586 /* add $u4,$Ri */
 587   {
 588     FR30_INSN_ADDI, "addi", "add", 16,
 589     { 0, { { { (1<<MACH_BASE), 0 } } } }
 590   },
 591 /* add2 $m4,$Ri */
 592   {
 593     FR30_INSN_ADD2, "add2", "add2", 16,
 594     { 0, { { { (1<<MACH_BASE), 0 } } } }
 595   },
 596 /* addc $Rj,$Ri */
 597   {
 598     FR30_INSN_ADDC, "addc", "addc", 16,
 599     { 0, { { { (1<<MACH_BASE), 0 } } } }
 600   },
 601 /* addn $Rj,$Ri */
 602   {
 603     FR30_INSN_ADDN, "addn", "addn", 16,
 604     { 0, { { { (1<<MACH_BASE), 0 } } } }
 605   },
 606 /* addn $u4,$Ri */
 607   {
 608     FR30_INSN_ADDNI, "addni", "addn", 16,
 609     { 0, { { { (1<<MACH_BASE), 0 } } } }
 610   },
 611 /* addn2 $m4,$Ri */
 612   {
 613     FR30_INSN_ADDN2, "addn2", "addn2", 16,
 614     { 0, { { { (1<<MACH_BASE), 0 } } } }
 615   },
 616 /* sub $Rj,$Ri */
 617   {
 618     FR30_INSN_SUB, "sub", "sub", 16,
 619     { 0, { { { (1<<MACH_BASE), 0 } } } }
 620   },
 621 /* subc $Rj,$Ri */
 622   {
 623     FR30_INSN_SUBC, "subc", "subc", 16,
 624     { 0, { { { (1<<MACH_BASE), 0 } } } }
 625   },
 626 /* subn $Rj,$Ri */
 627   {
 628     FR30_INSN_SUBN, "subn", "subn", 16,
 629     { 0, { { { (1<<MACH_BASE), 0 } } } }
 630   },
 631 /* cmp $Rj,$Ri */
 632   {
 633     FR30_INSN_CMP, "cmp", "cmp", 16,
 634     { 0, { { { (1<<MACH_BASE), 0 } } } }
 635   },
 636 /* cmp $u4,$Ri */
 637   {
 638     FR30_INSN_CMPI, "cmpi", "cmp", 16,
 639     { 0, { { { (1<<MACH_BASE), 0 } } } }
 640   },
 641 /* cmp2 $m4,$Ri */
 642   {
 643     FR30_INSN_CMP2, "cmp2", "cmp2", 16,
 644     { 0, { { { (1<<MACH_BASE), 0 } } } }
 645   },
 646 /* and $Rj,$Ri */
 647   {
 648     FR30_INSN_AND, "and", "and", 16,
 649     { 0, { { { (1<<MACH_BASE), 0 } } } }
 650   },
 651 /* or $Rj,$Ri */
 652   {
 653     FR30_INSN_OR, "or", "or", 16,
 654     { 0, { { { (1<<MACH_BASE), 0 } } } }
 655   },
 656 /* eor $Rj,$Ri */
 657   {
 658     FR30_INSN_EOR, "eor", "eor", 16,
 659     { 0, { { { (1<<MACH_BASE), 0 } } } }
 660   },
 661 /* and $Rj,@$Ri */
 662   {
 663     FR30_INSN_ANDM, "andm", "and", 16,
 664     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 665   },
 666 /* andh $Rj,@$Ri */
 667   {
 668     FR30_INSN_ANDH, "andh", "andh", 16,
 669     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 670   },
 671 /* andb $Rj,@$Ri */
 672   {
 673     FR30_INSN_ANDB, "andb", "andb", 16,
 674     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 675   },
 676 /* or $Rj,@$Ri */
 677   {
 678     FR30_INSN_ORM, "orm", "or", 16,
 679     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 680   },
 681 /* orh $Rj,@$Ri */
 682   {
 683     FR30_INSN_ORH, "orh", "orh", 16,
 684     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 685   },
 686 /* orb $Rj,@$Ri */
 687   {
 688     FR30_INSN_ORB, "orb", "orb", 16,
 689     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 690   },
 691 /* eor $Rj,@$Ri */
 692   {
 693     FR30_INSN_EORM, "eorm", "eor", 16,
 694     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 695   },
 696 /* eorh $Rj,@$Ri */
 697   {
 698     FR30_INSN_EORH, "eorh", "eorh", 16,
 699     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 700   },
 701 /* eorb $Rj,@$Ri */
 702   {
 703     FR30_INSN_EORB, "eorb", "eorb", 16,
 704     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 705   },
 706 /* bandl $u4,@$Ri */
 707   {
 708     FR30_INSN_BANDL, "bandl", "bandl", 16,
 709     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 710   },
 711 /* borl $u4,@$Ri */
 712   {
 713     FR30_INSN_BORL, "borl", "borl", 16,
 714     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 715   },
 716 /* beorl $u4,@$Ri */
 717   {
 718     FR30_INSN_BEORL, "beorl", "beorl", 16,
 719     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 720   },
 721 /* bandh $u4,@$Ri */
 722   {
 723     FR30_INSN_BANDH, "bandh", "bandh", 16,
 724     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 725   },
 726 /* borh $u4,@$Ri */
 727   {
 728     FR30_INSN_BORH, "borh", "borh", 16,
 729     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 730   },
 731 /* beorh $u4,@$Ri */
 732   {
 733     FR30_INSN_BEORH, "beorh", "beorh", 16,
 734     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 735   },
 736 /* btstl $u4,@$Ri */
 737   {
 738     FR30_INSN_BTSTL, "btstl", "btstl", 16,
 739     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 740   },
 741 /* btsth $u4,@$Ri */
 742   {
 743     FR30_INSN_BTSTH, "btsth", "btsth", 16,
 744     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 745   },
 746 /* mul $Rj,$Ri */
 747   {
 748     FR30_INSN_MUL, "mul", "mul", 16,
 749     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 750   },
 751 /* mulu $Rj,$Ri */
 752   {
 753     FR30_INSN_MULU, "mulu", "mulu", 16,
 754     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 755   },
 756 /* mulh $Rj,$Ri */
 757   {
 758     FR30_INSN_MULH, "mulh", "mulh", 16,
 759     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 760   },
 761 /* muluh $Rj,$Ri */
 762   {
 763     FR30_INSN_MULUH, "muluh", "muluh", 16,
 764     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 765   },
 766 /* div0s $Ri */
 767   {
 768     FR30_INSN_DIV0S, "div0s", "div0s", 16,
 769     { 0, { { { (1<<MACH_BASE), 0 } } } }
 770   },
 771 /* div0u $Ri */
 772   {
 773     FR30_INSN_DIV0U, "div0u", "div0u", 16,
 774     { 0, { { { (1<<MACH_BASE), 0 } } } }
 775   },
 776 /* div1 $Ri */
 777   {
 778     FR30_INSN_DIV1, "div1", "div1", 16,
 779     { 0, { { { (1<<MACH_BASE), 0 } } } }
 780   },
 781 /* div2 $Ri */
 782   {
 783     FR30_INSN_DIV2, "div2", "div2", 16,
 784     { 0, { { { (1<<MACH_BASE), 0 } } } }
 785   },
 786 /* div3 */
 787   {
 788     FR30_INSN_DIV3, "div3", "div3", 16,
 789     { 0, { { { (1<<MACH_BASE), 0 } } } }
 790   },
 791 /* div4s */
 792   {
 793     FR30_INSN_DIV4S, "div4s", "div4s", 16,
 794     { 0, { { { (1<<MACH_BASE), 0 } } } }
 795   },
 796 /* lsl $Rj,$Ri */
 797   {
 798     FR30_INSN_LSL, "lsl", "lsl", 16,
 799     { 0, { { { (1<<MACH_BASE), 0 } } } }
 800   },
 801 /* lsl $u4,$Ri */
 802   {
 803     FR30_INSN_LSLI, "lsli", "lsl", 16,
 804     { 0, { { { (1<<MACH_BASE), 0 } } } }
 805   },
 806 /* lsl2 $u4,$Ri */
 807   {
 808     FR30_INSN_LSL2, "lsl2", "lsl2", 16,
 809     { 0, { { { (1<<MACH_BASE), 0 } } } }
 810   },
 811 /* lsr $Rj,$Ri */
 812   {
 813     FR30_INSN_LSR, "lsr", "lsr", 16,
 814     { 0, { { { (1<<MACH_BASE), 0 } } } }
 815   },
 816 /* lsr $u4,$Ri */
 817   {
 818     FR30_INSN_LSRI, "lsri", "lsr", 16,
 819     { 0, { { { (1<<MACH_BASE), 0 } } } }
 820   },
 821 /* lsr2 $u4,$Ri */
 822   {
 823     FR30_INSN_LSR2, "lsr2", "lsr2", 16,
 824     { 0, { { { (1<<MACH_BASE), 0 } } } }
 825   },
 826 /* asr $Rj,$Ri */
 827   {
 828     FR30_INSN_ASR, "asr", "asr", 16,
 829     { 0, { { { (1<<MACH_BASE), 0 } } } }
 830   },
 831 /* asr $u4,$Ri */
 832   {
 833     FR30_INSN_ASRI, "asri", "asr", 16,
 834     { 0, { { { (1<<MACH_BASE), 0 } } } }
 835   },
 836 /* asr2 $u4,$Ri */
 837   {
 838     FR30_INSN_ASR2, "asr2", "asr2", 16,
 839     { 0, { { { (1<<MACH_BASE), 0 } } } }
 840   },
 841 /* ldi:8 $i8,$Ri */
 842   {
 843     FR30_INSN_LDI8, "ldi8", "ldi:8", 16,
 844     { 0, { { { (1<<MACH_BASE), 0 } } } }
 845   },
 846 /* ldi:20 $i20,$Ri */
 847   {
 848     FR30_INSN_LDI20, "ldi20", "ldi:20", 32,
 849     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 850   },
 851 /* ldi:32 $i32,$Ri */
 852   {
 853     FR30_INSN_LDI32, "ldi32", "ldi:32", 48,
 854     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 855   },
 856 /* ld @$Rj,$Ri */
 857   {
 858     FR30_INSN_LD, "ld", "ld", 16,
 859     { 0, { { { (1<<MACH_BASE), 0 } } } }
 860   },
 861 /* lduh @$Rj,$Ri */
 862   {
 863     FR30_INSN_LDUH, "lduh", "lduh", 16,
 864     { 0, { { { (1<<MACH_BASE), 0 } } } }
 865   },
 866 /* ldub @$Rj,$Ri */
 867   {
 868     FR30_INSN_LDUB, "ldub", "ldub", 16,
 869     { 0, { { { (1<<MACH_BASE), 0 } } } }
 870   },
 871 /* ld @($R13,$Rj),$Ri */
 872   {
 873     FR30_INSN_LDR13, "ldr13", "ld", 16,
 874     { 0, { { { (1<<MACH_BASE), 0 } } } }
 875   },
 876 /* lduh @($R13,$Rj),$Ri */
 877   {
 878     FR30_INSN_LDR13UH, "ldr13uh", "lduh", 16,
 879     { 0, { { { (1<<MACH_BASE), 0 } } } }
 880   },
 881 /* ldub @($R13,$Rj),$Ri */
 882   {
 883     FR30_INSN_LDR13UB, "ldr13ub", "ldub", 16,
 884     { 0, { { { (1<<MACH_BASE), 0 } } } }
 885   },
 886 /* ld @($R14,$disp10),$Ri */
 887   {
 888     FR30_INSN_LDR14, "ldr14", "ld", 16,
 889     { 0, { { { (1<<MACH_BASE), 0 } } } }
 890   },
 891 /* lduh @($R14,$disp9),$Ri */
 892   {
 893     FR30_INSN_LDR14UH, "ldr14uh", "lduh", 16,
 894     { 0, { { { (1<<MACH_BASE), 0 } } } }
 895   },
 896 /* ldub @($R14,$disp8),$Ri */
 897   {
 898     FR30_INSN_LDR14UB, "ldr14ub", "ldub", 16,
 899     { 0, { { { (1<<MACH_BASE), 0 } } } }
 900   },
 901 /* ld @($R15,$udisp6),$Ri */
 902   {
 903     FR30_INSN_LDR15, "ldr15", "ld", 16,
 904     { 0, { { { (1<<MACH_BASE), 0 } } } }
 905   },
 906 /* ld @$R15+,$Ri */
 907   {
 908     FR30_INSN_LDR15GR, "ldr15gr", "ld", 16,
 909     { 0, { { { (1<<MACH_BASE), 0 } } } }
 910   },
 911 /* ld @$R15+,$Rs2 */
 912   {
 913     FR30_INSN_LDR15DR, "ldr15dr", "ld", 16,
 914     { 0, { { { (1<<MACH_BASE), 0 } } } }
 915   },
 916 /* ld @$R15+,$ps */
 917   {
 918     FR30_INSN_LDR15PS, "ldr15ps", "ld", 16,
 919     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 920   },
 921 /* st $Ri,@$Rj */
 922   {
 923     FR30_INSN_ST, "st", "st", 16,
 924     { 0, { { { (1<<MACH_BASE), 0 } } } }
 925   },
 926 /* sth $Ri,@$Rj */
 927   {
 928     FR30_INSN_STH, "sth", "sth", 16,
 929     { 0, { { { (1<<MACH_BASE), 0 } } } }
 930   },
 931 /* stb $Ri,@$Rj */
 932   {
 933     FR30_INSN_STB, "stb", "stb", 16,
 934     { 0, { { { (1<<MACH_BASE), 0 } } } }
 935   },
 936 /* st $Ri,@($R13,$Rj) */
 937   {
 938     FR30_INSN_STR13, "str13", "st", 16,
 939     { 0, { { { (1<<MACH_BASE), 0 } } } }
 940   },
 941 /* sth $Ri,@($R13,$Rj) */
 942   {
 943     FR30_INSN_STR13H, "str13h", "sth", 16,
 944     { 0, { { { (1<<MACH_BASE), 0 } } } }
 945   },
 946 /* stb $Ri,@($R13,$Rj) */
 947   {
 948     FR30_INSN_STR13B, "str13b", "stb", 16,
 949     { 0, { { { (1<<MACH_BASE), 0 } } } }
 950   },
 951 /* st $Ri,@($R14,$disp10) */
 952   {
 953     FR30_INSN_STR14, "str14", "st", 16,
 954     { 0, { { { (1<<MACH_BASE), 0 } } } }
 955   },
 956 /* sth $Ri,@($R14,$disp9) */
 957   {
 958     FR30_INSN_STR14H, "str14h", "sth", 16,
 959     { 0, { { { (1<<MACH_BASE), 0 } } } }
 960   },
 961 /* stb $Ri,@($R14,$disp8) */
 962   {
 963     FR30_INSN_STR14B, "str14b", "stb", 16,
 964     { 0, { { { (1<<MACH_BASE), 0 } } } }
 965   },
 966 /* st $Ri,@($R15,$udisp6) */
 967   {
 968     FR30_INSN_STR15, "str15", "st", 16,
 969     { 0, { { { (1<<MACH_BASE), 0 } } } }
 970   },
 971 /* st $Ri,@-$R15 */
 972   {
 973     FR30_INSN_STR15GR, "str15gr", "st", 16,
 974     { 0, { { { (1<<MACH_BASE), 0 } } } }
 975   },
 976 /* st $Rs2,@-$R15 */
 977   {
 978     FR30_INSN_STR15DR, "str15dr", "st", 16,
 979     { 0, { { { (1<<MACH_BASE), 0 } } } }
 980   },
 981 /* st $ps,@-$R15 */
 982   {
 983     FR30_INSN_STR15PS, "str15ps", "st", 16,
 984     { 0, { { { (1<<MACH_BASE), 0 } } } }
 985   },
 986 /* mov $Rj,$Ri */
 987   {
 988     FR30_INSN_MOV, "mov", "mov", 16,
 989     { 0, { { { (1<<MACH_BASE), 0 } } } }
 990   },
 991 /* mov $Rs1,$Ri */
 992   {
 993     FR30_INSN_MOVDR, "movdr", "mov", 16,
 994     { 0, { { { (1<<MACH_BASE), 0 } } } }
 995   },
 996 /* mov $ps,$Ri */
 997   {
 998     FR30_INSN_MOVPS, "movps", "mov", 16,
 999     { 0, { { { (1<<MACH_BASE), 0 } } } }
1000   },
1001 /* mov $Ri,$Rs1 */
1002   {
1003     FR30_INSN_MOV2DR, "mov2dr", "mov", 16,
1004     { 0, { { { (1<<MACH_BASE), 0 } } } }
1005   },
1006 /* mov $Ri,$ps */
1007   {
1008     FR30_INSN_MOV2PS, "mov2ps", "mov", 16,
1009     { 0, { { { (1<<MACH_BASE), 0 } } } }
1010   },
1011 /* jmp @$Ri */
1012   {
1013     FR30_INSN_JMP, "jmp", "jmp", 16,
1014     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1015   },
1016 /* jmp:d @$Ri */
1017   {
1018     FR30_INSN_JMPD, "jmpd", "jmp:d", 16,
1019     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1020   },
1021 /* call @$Ri */
1022   {
1023     FR30_INSN_CALLR, "callr", "call", 16,
1024     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1025   },
1026 /* call:d @$Ri */
1027   {
1028     FR30_INSN_CALLRD, "callrd", "call:d", 16,
1029     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1030   },
1031 /* call $label12 */
1032   {
1033     FR30_INSN_CALL, "call", "call", 16,
1034     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1035   },
1036 /* call:d $label12 */
1037   {
1038     FR30_INSN_CALLD, "calld", "call:d", 16,
1039     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1040   },
1041 /* ret */
1042   {
1043     FR30_INSN_RET, "ret", "ret", 16,
1044     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1045   },
1046 /* ret:d */
1047   {
1048     FR30_INSN_RET_D, "ret:d", "ret:d", 16,
1049     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1050   },
1051 /* int $u8 */
1052   {
1053     FR30_INSN_INT, "int", "int", 16,
1054     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1055   },
1056 /* inte */
1057   {
1058     FR30_INSN_INTE, "inte", "inte", 16,
1059     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1060   },
1061 /* reti */
1062   {
1063     FR30_INSN_RETI, "reti", "reti", 16,
1064     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1065   },
1066 /* bra:d $label9 */
1067   {
1068     FR30_INSN_BRAD, "brad", "bra:d", 16,
1069     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1070   },
1071 /* bra $label9 */
1072   {
1073     FR30_INSN_BRA, "bra", "bra", 16,
1074     { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1075   },
1076 /* bno:d $label9 */
1077   {
1078     FR30_INSN_BNOD, "bnod", "bno:d", 16,
1079     { 0|A(NOT_IN_DELAY_SLOT)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1080   },
1081 /* bno $label9 */
1082   {
1083     FR30_INSN_BNO, "bno", "bno", 16,
1084     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1085   },
1086 /* beq:d $label9 */
1087   {
1088     FR30_INSN_BEQD, "beqd", "beq:d", 16,
1089     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1090   },
1091 /* beq $label9 */
1092   {
1093     FR30_INSN_BEQ, "beq", "beq", 16,
1094     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1095   },
1096 /* bne:d $label9 */
1097   {
1098     FR30_INSN_BNED, "bned", "bne:d", 16,
1099     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1100   },
1101 /* bne $label9 */
1102   {
1103     FR30_INSN_BNE, "bne", "bne", 16,
1104     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1105   },
1106 /* bc:d $label9 */
1107   {
1108     FR30_INSN_BCD, "bcd", "bc:d", 16,
1109     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1110   },
1111 /* bc $label9 */
1112   {
1113     FR30_INSN_BC, "bc", "bc", 16,
1114     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1115   },
1116 /* bnc:d $label9 */
1117   {
1118     FR30_INSN_BNCD, "bncd", "bnc:d", 16,
1119     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1120   },
1121 /* bnc $label9 */
1122   {
1123     FR30_INSN_BNC, "bnc", "bnc", 16,
1124     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1125   },
1126 /* bn:d $label9 */
1127   {
1128     FR30_INSN_BND, "bnd", "bn:d", 16,
1129     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1130   },
1131 /* bn $label9 */
1132   {
1133     FR30_INSN_BN, "bn", "bn", 16,
1134     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1135   },
1136 /* bp:d $label9 */
1137   {
1138     FR30_INSN_BPD, "bpd", "bp:d", 16,
1139     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1140   },
1141 /* bp $label9 */
1142   {
1143     FR30_INSN_BP, "bp", "bp", 16,
1144     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1145   },
1146 /* bv:d $label9 */
1147   {
1148     FR30_INSN_BVD, "bvd", "bv:d", 16,
1149     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1150   },
1151 /* bv $label9 */
1152   {
1153     FR30_INSN_BV, "bv", "bv", 16,
1154     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1155   },
1156 /* bnv:d $label9 */
1157   {
1158     FR30_INSN_BNVD, "bnvd", "bnv:d", 16,
1159     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1160   },
1161 /* bnv $label9 */
1162   {
1163     FR30_INSN_BNV, "bnv", "bnv", 16,
1164     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1165   },
1166 /* blt:d $label9 */
1167   {
1168     FR30_INSN_BLTD, "bltd", "blt:d", 16,
1169     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1170   },
1171 /* blt $label9 */
1172   {
1173     FR30_INSN_BLT, "blt", "blt", 16,
1174     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1175   },
1176 /* bge:d $label9 */
1177   {
1178     FR30_INSN_BGED, "bged", "bge:d", 16,
1179     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1180   },
1181 /* bge $label9 */
1182   {
1183     FR30_INSN_BGE, "bge", "bge", 16,
1184     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1185   },
1186 /* ble:d $label9 */
1187   {
1188     FR30_INSN_BLED, "bled", "ble:d", 16,
1189     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1190   },
1191 /* ble $label9 */
1192   {
1193     FR30_INSN_BLE, "ble", "ble", 16,
1194     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1195   },
1196 /* bgt:d $label9 */
1197   {
1198     FR30_INSN_BGTD, "bgtd", "bgt:d", 16,
1199     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1200   },
1201 /* bgt $label9 */
1202   {
1203     FR30_INSN_BGT, "bgt", "bgt", 16,
1204     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1205   },
1206 /* bls:d $label9 */
1207   {
1208     FR30_INSN_BLSD, "blsd", "bls:d", 16,
1209     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1210   },
1211 /* bls $label9 */
1212   {
1213     FR30_INSN_BLS, "bls", "bls", 16,
1214     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1215   },
1216 /* bhi:d $label9 */
1217   {
1218     FR30_INSN_BHID, "bhid", "bhi:d", 16,
1219     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1220   },
1221 /* bhi $label9 */
1222   {
1223     FR30_INSN_BHI, "bhi", "bhi", 16,
1224     { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
1225   },
1226 /* dmov $R13,@$dir10 */
1227   {
1228     FR30_INSN_DMOVR13, "dmovr13", "dmov", 16,
1229     { 0, { { { (1<<MACH_BASE), 0 } } } }
1230   },
1231 /* dmovh $R13,@$dir9 */
1232   {
1233     FR30_INSN_DMOVR13H, "dmovr13h", "dmovh", 16,
1234     { 0, { { { (1<<MACH_BASE), 0 } } } }
1235   },
1236 /* dmovb $R13,@$dir8 */
1237   {
1238     FR30_INSN_DMOVR13B, "dmovr13b", "dmovb", 16,
1239     { 0, { { { (1<<MACH_BASE), 0 } } } }
1240   },
1241 /* dmov @$R13+,@$dir10 */
1242   {
1243     FR30_INSN_DMOVR13PI, "dmovr13pi", "dmov", 16,
1244     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1245   },
1246 /* dmovh @$R13+,@$dir9 */
1247   {
1248     FR30_INSN_DMOVR13PIH, "dmovr13pih", "dmovh", 16,
1249     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1250   },
1251 /* dmovb @$R13+,@$dir8 */
1252   {
1253     FR30_INSN_DMOVR13PIB, "dmovr13pib", "dmovb", 16,
1254     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1255   },
1256 /* dmov @$R15+,@$dir10 */
1257   {
1258     FR30_INSN_DMOVR15PI, "dmovr15pi", "dmov", 16,
1259     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1260   },
1261 /* dmov @$dir10,$R13 */
1262   {
1263     FR30_INSN_DMOV2R13, "dmov2r13", "dmov", 16,
1264     { 0, { { { (1<<MACH_BASE), 0 } } } }
1265   },
1266 /* dmovh @$dir9,$R13 */
1267   {
1268     FR30_INSN_DMOV2R13H, "dmov2r13h", "dmovh", 16,
1269     { 0, { { { (1<<MACH_BASE), 0 } } } }
1270   },
1271 /* dmovb @$dir8,$R13 */
1272   {
1273     FR30_INSN_DMOV2R13B, "dmov2r13b", "dmovb", 16,
1274     { 0, { { { (1<<MACH_BASE), 0 } } } }
1275   },
1276 /* dmov @$dir10,@$R13+ */
1277   {
1278     FR30_INSN_DMOV2R13PI, "dmov2r13pi", "dmov", 16,
1279     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1280   },
1281 /* dmovh @$dir9,@$R13+ */
1282   {
1283     FR30_INSN_DMOV2R13PIH, "dmov2r13pih", "dmovh", 16,
1284     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1285   },
1286 /* dmovb @$dir8,@$R13+ */
1287   {
1288     FR30_INSN_DMOV2R13PIB, "dmov2r13pib", "dmovb", 16,
1289     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1290   },
1291 /* dmov @$dir10,@-$R15 */
1292   {
1293     FR30_INSN_DMOV2R15PD, "dmov2r15pd", "dmov", 16,
1294     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1295   },
1296 /* ldres @$Ri+,$u4 */
1297   {
1298     FR30_INSN_LDRES, "ldres", "ldres", 16,
1299     { 0, { { { (1<<MACH_BASE), 0 } } } }
1300   },
1301 /* stres $u4,@$Ri+ */
1302   {
1303     FR30_INSN_STRES, "stres", "stres", 16,
1304     { 0, { { { (1<<MACH_BASE), 0 } } } }
1305   },
1306 /* copop $u4c,$ccc,$CRj,$CRi */
1307   {
1308     FR30_INSN_COPOP, "copop", "copop", 32,
1309     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1310   },
1311 /* copld $u4c,$ccc,$Rjc,$CRi */
1312   {
1313     FR30_INSN_COPLD, "copld", "copld", 32,
1314     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1315   },
1316 /* copst $u4c,$ccc,$CRj,$Ric */
1317   {
1318     FR30_INSN_COPST, "copst", "copst", 32,
1319     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1320   },
1321 /* copsv $u4c,$ccc,$CRj,$Ric */
1322   {
1323     FR30_INSN_COPSV, "copsv", "copsv", 32,
1324     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1325   },
1326 /* nop */
1327   {
1328     FR30_INSN_NOP, "nop", "nop", 16,
1329     { 0, { { { (1<<MACH_BASE), 0 } } } }
1330   },
1331 /* andccr $u8 */
1332   {
1333     FR30_INSN_ANDCCR, "andccr", "andccr", 16,
1334     { 0, { { { (1<<MACH_BASE), 0 } } } }
1335   },
1336 /* orccr $u8 */
1337   {
1338     FR30_INSN_ORCCR, "orccr", "orccr", 16,
1339     { 0, { { { (1<<MACH_BASE), 0 } } } }
1340   },
1341 /* stilm $u8 */
1342   {
1343     FR30_INSN_STILM, "stilm", "stilm", 16,
1344     { 0, { { { (1<<MACH_BASE), 0 } } } }
1345   },
1346 /* addsp $s10 */
1347   {
1348     FR30_INSN_ADDSP, "addsp", "addsp", 16,
1349     { 0, { { { (1<<MACH_BASE), 0 } } } }
1350   },
1351 /* extsb $Ri */
1352   {
1353     FR30_INSN_EXTSB, "extsb", "extsb", 16,
1354     { 0, { { { (1<<MACH_BASE), 0 } } } }
1355   },
1356 /* extub $Ri */
1357   {
1358     FR30_INSN_EXTUB, "extub", "extub", 16,
1359     { 0, { { { (1<<MACH_BASE), 0 } } } }
1360   },
1361 /* extsh $Ri */
1362   {
1363     FR30_INSN_EXTSH, "extsh", "extsh", 16,
1364     { 0, { { { (1<<MACH_BASE), 0 } } } }
1365   },
1366 /* extuh $Ri */
1367   {
1368     FR30_INSN_EXTUH, "extuh", "extuh", 16,
1369     { 0, { { { (1<<MACH_BASE), 0 } } } }
1370   },
1371 /* ldm0 ($reglist_low_ld) */
1372   {
1373     FR30_INSN_LDM0, "ldm0", "ldm0", 16,
1374     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1375   },
1376 /* ldm1 ($reglist_hi_ld) */
1377   {
1378     FR30_INSN_LDM1, "ldm1", "ldm1", 16,
1379     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1380   },
1381 /* stm0 ($reglist_low_st) */
1382   {
1383     FR30_INSN_STM0, "stm0", "stm0", 16,
1384     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1385   },
1386 /* stm1 ($reglist_hi_st) */
1387   {
1388     FR30_INSN_STM1, "stm1", "stm1", 16,
1389     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1390   },
1391 /* enter $u10 */
1392   {
1393     FR30_INSN_ENTER, "enter", "enter", 16,
1394     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1395   },
1396 /* leave */
1397   {
1398     FR30_INSN_LEAVE, "leave", "leave", 16,
1399     { 0, { { { (1<<MACH_BASE), 0 } } } }
1400   },
1401 /* xchb @$Rj,$Ri */
1402   {
1403     FR30_INSN_XCHB, "xchb", "xchb", 16,
1404     { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
1405   },
1406 };
1407
1408 #undef OP
1409 #undef A
1410
1411 /* Initialize anything needed to be done once, before any cpu_open call.  */
1412
1413 static void
1414 init_tables (void)
1415 {
1416 }
1417
1418 static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
1419 static void build_hw_table      (CGEN_CPU_TABLE *);
1420 static void build_ifield_table  (CGEN_CPU_TABLE *);
1421 static void build_operand_table (CGEN_CPU_TABLE *);
1422 static void build_insn_table    (CGEN_CPU_TABLE *);
1423 static void fr30_cgen_rebuild_tables (CGEN_CPU_TABLE *);
1424
1425 /* Subroutine of fr30_cgen_cpu_open to look up a mach via its bfd name.  */
1426
1427 static const CGEN_MACH *
1428 lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
1429 {
1430   while (table->name)
1431     {
1432       if (strcmp (name, table->bfd_name) == 0)
1433         return table;
1434       ++table;
1435     }
1436   return NULL;
1437 }
1438
1439 /* Subroutine of fr30_cgen_cpu_open to build the hardware table.  */
1440
1441 static void
1442 build_hw_table (CGEN_CPU_TABLE *cd)
1443 {
1444   int i;
1445   int machs = cd->machs;
1446   const CGEN_HW_ENTRY *init = & fr30_cgen_hw_table[0];
1447   /* MAX_HW is only an upper bound on the number of selected entries.
1448      However each entry is indexed by it's enum so there can be holes in
1449      the table.  */
1450   const CGEN_HW_ENTRY **selected =
1451     (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
1452
1453   cd->hw_table.init_entries = init;
1454   cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
1455   memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
1456   /* ??? For now we just use machs to determine which ones we want.  */
1457   for (i = 0; init[i].name != NULL; ++i)
1458     if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
1459         & machs)
1460       selected[init[i].type] = &init[i];
1461   cd->hw_table.entries = selected;
1462   cd->hw_table.num_entries = MAX_HW;
1463 }
1464
1465 /* Subroutine of fr30_cgen_cpu_open to build the hardware table.  */
1466
1467 static void
1468 build_ifield_table (CGEN_CPU_TABLE *cd)
1469 {
1470   cd->ifld_table = & fr30_cgen_ifld_table[0];
1471 }
1472
1473 /* Subroutine of fr30_cgen_cpu_open to build the hardware table.  */
1474
1475 static void
1476 build_operand_table (CGEN_CPU_TABLE *cd)
1477 {
1478   int i;
1479   int machs = cd->machs;
1480   const CGEN_OPERAND *init = & fr30_cgen_operand_table[0];
1481   /* MAX_OPERANDS is only an upper bound on the number of selected entries.
1482      However each entry is indexed by it's enum so there can be holes in
1483      the table.  */
1484   const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected));
1485
1486   cd->operand_table.init_entries = init;
1487   cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
1488   memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
1489   /* ??? For now we just use mach to determine which ones we want.  */
1490   for (i = 0; init[i].name != NULL; ++i)
1491     if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
1492         & machs)
1493       selected[init[i].type] = &init[i];
1494   cd->operand_table.entries = selected;
1495   cd->operand_table.num_entries = MAX_OPERANDS;
1496 }
1497
1498 /* Subroutine of fr30_cgen_cpu_open to build the hardware table.
1499    ??? This could leave out insns not supported by the specified mach/isa,
1500    but that would cause errors like "foo only supported by bar" to become
1501    "unknown insn", so for now we include all insns and require the app to
1502    do the checking later.
1503    ??? On the other hand, parsing of such insns may require their hardware or
1504    operand elements to be in the table [which they mightn't be].  */
1505
1506 static void
1507 build_insn_table (CGEN_CPU_TABLE *cd)
1508 {
1509   int i;
1510   const CGEN_IBASE *ib = & fr30_cgen_insn_table[0];
1511   CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
1512
1513   memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
1514   for (i = 0; i < MAX_INSNS; ++i)
1515     insns[i].base = &ib[i];
1516   cd->insn_table.init_entries = insns;
1517   cd->insn_table.entry_size = sizeof (CGEN_IBASE);
1518   cd->insn_table.num_init_entries = MAX_INSNS;
1519 }
1520
1521 /* Subroutine of fr30_cgen_cpu_open to rebuild the tables.  */
1522
1523 static void
1524 fr30_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
1525 {
1526   int i;
1527   CGEN_BITSET *isas = cd->isas;
1528   unsigned int machs = cd->machs;
1529
1530   cd->int_insn_p = CGEN_INT_INSN_P;
1531
1532   /* Data derived from the isa spec.  */
1533 #define UNSET (CGEN_SIZE_UNKNOWN + 1)
1534   cd->default_insn_bitsize = UNSET;
1535   cd->base_insn_bitsize = UNSET;
1536   cd->min_insn_bitsize = 65535; /* Some ridiculously big number.  */
1537   cd->max_insn_bitsize = 0;
1538   for (i = 0; i < MAX_ISAS; ++i)
1539     if (cgen_bitset_contains (isas, i))
1540       {
1541         const CGEN_ISA *isa = & fr30_cgen_isa_table[i];
1542
1543         /* Default insn sizes of all selected isas must be
1544            equal or we set the result to 0, meaning "unknown".  */
1545         if (cd->default_insn_bitsize == UNSET)
1546           cd->default_insn_bitsize = isa->default_insn_bitsize;
1547         else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
1548           ; /* This is ok.  */
1549         else
1550           cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
1551
1552         /* Base insn sizes of all selected isas must be equal
1553            or we set the result to 0, meaning "unknown".  */
1554         if (cd->base_insn_bitsize == UNSET)
1555           cd->base_insn_bitsize = isa->base_insn_bitsize;
1556         else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
1557           ; /* This is ok.  */
1558         else
1559           cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
1560
1561         /* Set min,max insn sizes.  */
1562         if (isa->min_insn_bitsize < cd->min_insn_bitsize)
1563           cd->min_insn_bitsize = isa->min_insn_bitsize;
1564         if (isa->max_insn_bitsize > cd->max_insn_bitsize)
1565           cd->max_insn_bitsize = isa->max_insn_bitsize;
1566       }
1567
1568   /* Data derived from the mach spec.  */
1569   for (i = 0; i < MAX_MACHS; ++i)
1570     if (((1 << i) & machs) != 0)
1571       {
1572         const CGEN_MACH *mach = & fr30_cgen_mach_table[i];
1573
1574         if (mach->insn_chunk_bitsize != 0)
1575         {
1576           if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
1577             {
1578               fprintf (stderr, "fr30_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
1579                        cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
1580               abort ();
1581             }
1582
1583           cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
1584         }
1585       }
1586
1587   /* Determine which hw elements are used by MACH.  */
1588   build_hw_table (cd);
1589
1590   /* Build the ifield table.  */
1591   build_ifield_table (cd);
1592
1593   /* Determine which operands are used by MACH/ISA.  */
1594   build_operand_table (cd);
1595
1596   /* Build the instruction table.  */
1597   build_insn_table (cd);
1598 }
1599
1600 /* Initialize a cpu table and return a descriptor.
1601    It's much like opening a file, and must be the first function called.
1602    The arguments are a set of (type/value) pairs, terminated with
1603    CGEN_CPU_OPEN_END.
1604
1605    Currently supported values:
1606    CGEN_CPU_OPEN_ISAS:    bitmap of values in enum isa_attr
1607    CGEN_CPU_OPEN_MACHS:   bitmap of values in enum mach_attr
1608    CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
1609    CGEN_CPU_OPEN_ENDIAN:  specify endian choice
1610    CGEN_CPU_OPEN_END:     terminates arguments
1611
1612    ??? Simultaneous multiple isas might not make sense, but it's not (yet)
1613    precluded.  */
1614
1615 CGEN_CPU_DESC
1616 fr30_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
1617 {
1618   CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
1619   static int init_p;
1620   CGEN_BITSET *isas = 0;  /* 0 = "unspecified" */
1621   unsigned int machs = 0; /* 0 = "unspecified" */
1622   enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
1623   va_list ap;
1624
1625   if (! init_p)
1626     {
1627       init_tables ();
1628       init_p = 1;
1629     }
1630
1631   memset (cd, 0, sizeof (*cd));
1632
1633   va_start (ap, arg_type);
1634   while (arg_type != CGEN_CPU_OPEN_END)
1635     {
1636       switch (arg_type)
1637         {
1638         case CGEN_CPU_OPEN_ISAS :
1639           isas = va_arg (ap, CGEN_BITSET *);
1640           break;
1641         case CGEN_CPU_OPEN_MACHS :
1642           machs = va_arg (ap, unsigned int);
1643           break;
1644         case CGEN_CPU_OPEN_BFDMACH :
1645           {
1646             const char *name = va_arg (ap, const char *);
1647             const CGEN_MACH *mach =
1648               lookup_mach_via_bfd_name (fr30_cgen_mach_table, name);
1649
1650             if (mach != NULL)
1651               machs |= 1 << mach->num;
1652             break;
1653           }
1654         case CGEN_CPU_OPEN_ENDIAN :
1655           endian = va_arg (ap, enum cgen_endian);
1656           break;
1657         default :
1658           fprintf (stderr, "fr30_cgen_cpu_open: unsupported argument `%d'\n",
1659                    arg_type);
1660           abort (); /* ??? return NULL? */
1661         }
1662       arg_type = va_arg (ap, enum cgen_cpu_open_arg);
1663     }
1664   va_end (ap);
1665
1666   /* Mach unspecified means "all".  */
1667   if (machs == 0)
1668     machs = (1 << MAX_MACHS) - 1;
1669   /* Base mach is always selected.  */
1670   machs |= 1;
1671   if (endian == CGEN_ENDIAN_UNKNOWN)
1672     {
1673       /* ??? If target has only one, could have a default.  */
1674       fprintf (stderr, "fr30_cgen_cpu_open: no endianness specified\n");
1675       abort ();
1676     }
1677
1678   cd->isas = cgen_bitset_copy (isas);
1679   cd->machs = machs;
1680   cd->endian = endian;
1681   /* FIXME: for the sparc case we can determine insn-endianness statically.
1682      The worry here is where both data and insn endian can be independently
1683      chosen, in which case this function will need another argument.
1684      Actually, will want to allow for more arguments in the future anyway.  */
1685   cd->insn_endian = endian;
1686
1687   /* Table (re)builder.  */
1688   cd->rebuild_tables = fr30_cgen_rebuild_tables;
1689   fr30_cgen_rebuild_tables (cd);
1690
1691   /* Default to not allowing signed overflow.  */
1692   cd->signed_overflow_ok_p = 0;
1693
1694   return (CGEN_CPU_DESC) cd;
1695 }
1696
1697 /* Cover fn to fr30_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
1698    MACH_NAME is the bfd name of the mach.  */
1699
1700 CGEN_CPU_DESC
1701 fr30_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
1702 {
1703   return fr30_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
1704                                CGEN_CPU_OPEN_ENDIAN, endian,
1705                                CGEN_CPU_OPEN_END);
1706 }
1707
1708 /* Close a cpu table.
1709    ??? This can live in a machine independent file, but there's currently
1710    no place to put this file (there's no libcgen).  libopcodes is the wrong
1711    place as some simulator ports use this but they don't use libopcodes.  */
1712
1713 void
1714 fr30_cgen_cpu_close (CGEN_CPU_DESC cd)
1715 {
1716   unsigned int i;
1717   const CGEN_INSN *insns;
1718
1719   if (cd->macro_insn_table.init_entries)
1720     {
1721       insns = cd->macro_insn_table.init_entries;
1722       for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
1723         if (CGEN_INSN_RX ((insns)))
1724           regfree (CGEN_INSN_RX (insns));
1725     }
1726
1727   if (cd->insn_table.init_entries)
1728     {
1729       insns = cd->insn_table.init_entries;
1730       for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
1731         if (CGEN_INSN_RX (insns))
1732           regfree (CGEN_INSN_RX (insns));
1733     }
1734
1735   if (cd->macro_insn_table.init_entries)
1736     free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
1737
1738   if (cd->insn_table.init_entries)
1739     free ((CGEN_INSN *) cd->insn_table.init_entries);
1740
1741   if (cd->hw_table.entries)
1742     free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
1743
1744   if (cd->operand_table.entries)
1745     free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
1746
1747   free (cd);
1748 }
1749