opcodes/ip2k-desc.c

   1 /* CPU data for ip2k.
   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 "ip2k-desc.h"
  32 #include "ip2k-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   { "ip2022", MACH_IP2022 },
  50   { "ip2022ext", MACH_IP2022EXT },
  51   { "max", MACH_MAX },
  52   { 0, 0 }
  53 };
  54
  55 static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
  56 {
  57   { "ip2k", ISA_IP2K },
  58   { "max", ISA_MAX },
  59   { 0, 0 }
  60 };
  61
  62 const CGEN_ATTR_TABLE ip2k_cgen_ifield_attr_table[] =
  63 {
  64   { "MACH", & MACH_attr[0], & MACH_attr[0] },
  65   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
  66   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
  67   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
  68   { "RESERVED", &bool_attr[0], &bool_attr[0] },
  69   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
  70   { "SIGNED", &bool_attr[0], &bool_attr[0] },
  71   { 0, 0, 0 }
  72 };
  73
  74 const CGEN_ATTR_TABLE ip2k_cgen_hardware_attr_table[] =
  75 {
  76   { "MACH", & MACH_attr[0], & MACH_attr[0] },
  77   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
  78   { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
  79   { "PC", &bool_attr[0], &bool_attr[0] },
  80   { "PROFILE", &bool_attr[0], &bool_attr[0] },
  81   { 0, 0, 0 }
  82 };
  83
  84 const CGEN_ATTR_TABLE ip2k_cgen_operand_attr_table[] =
  85 {
  86   { "MACH", & MACH_attr[0], & MACH_attr[0] },
  87   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
  88   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
  89   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
  90   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
  91   { "SIGNED", &bool_attr[0], &bool_attr[0] },
  92   { "NEGATIVE", &bool_attr[0], &bool_attr[0] },
  93   { "RELAX", &bool_attr[0], &bool_attr[0] },
  94   { "SEM-ONLY", &bool_attr[0], &bool_attr[0] },
  95   { 0, 0, 0 }
  96 };
  97
  98 const CGEN_ATTR_TABLE ip2k_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   { "EXT-SKIP-INSN", &bool_attr[0], &bool_attr[0] },
 112   { "SKIPA", &bool_attr[0], &bool_attr[0] },
 113   { 0, 0, 0 }
 114 };
 115
 116 /* Instruction set variants.  */
 117
 118 static const CGEN_ISA ip2k_cgen_isa_table[] = {
 119   { "ip2k", 16, 16, 16, 16 },
 120   { 0, 0, 0, 0, 0 }
 121 };
 122
 123 /* Machine variants.  */
 124
 125 static const CGEN_MACH ip2k_cgen_mach_table[] = {
 126   { "ip2022", "ip2022", MACH_IP2022, 0 },
 127   { "ip2022ext", "ip2022ext", MACH_IP2022EXT, 0 },
 128   { 0, 0, 0, 0 }
 129 };
 130
 131 static CGEN_KEYWORD_ENTRY ip2k_cgen_opval_register_names_entries[] =
 132 {
 133   { "ADDRSEL", 2, {0, {{{0, 0}}}}, 0, 0 },
 134   { "ADDRX", 3, {0, {{{0, 0}}}}, 0, 0 },
 135   { "IPH", 4, {0, {{{0, 0}}}}, 0, 0 },
 136   { "IPL", 5, {0, {{{0, 0}}}}, 0, 0 },
 137   { "SPH", 6, {0, {{{0, 0}}}}, 0, 0 },
 138   { "SPL", 7, {0, {{{0, 0}}}}, 0, 0 },
 139   { "PCH", 8, {0, {{{0, 0}}}}, 0, 0 },
 140   { "PCL", 9, {0, {{{0, 0}}}}, 0, 0 },
 141   { "WREG", 10, {0, {{{0, 0}}}}, 0, 0 },
 142   { "STATUS", 11, {0, {{{0, 0}}}}, 0, 0 },
 143   { "DPH", 12, {0, {{{0, 0}}}}, 0, 0 },
 144   { "DPL", 13, {0, {{{0, 0}}}}, 0, 0 },
 145   { "SPDREG", 14, {0, {{{0, 0}}}}, 0, 0 },
 146   { "MULH", 15, {0, {{{0, 0}}}}, 0, 0 },
 147   { "ADDRH", 16, {0, {{{0, 0}}}}, 0, 0 },
 148   { "ADDRL", 17, {0, {{{0, 0}}}}, 0, 0 },
 149   { "DATAH", 18, {0, {{{0, 0}}}}, 0, 0 },
 150   { "DATAL", 19, {0, {{{0, 0}}}}, 0, 0 },
 151   { "INTVECH", 20, {0, {{{0, 0}}}}, 0, 0 },
 152   { "INTVECL", 21, {0, {{{0, 0}}}}, 0, 0 },
 153   { "INTSPD", 22, {0, {{{0, 0}}}}, 0, 0 },
 154   { "INTF", 23, {0, {{{0, 0}}}}, 0, 0 },
 155   { "INTE", 24, {0, {{{0, 0}}}}, 0, 0 },
 156   { "INTED", 25, {0, {{{0, 0}}}}, 0, 0 },
 157   { "FCFG", 26, {0, {{{0, 0}}}}, 0, 0 },
 158   { "TCTRL", 27, {0, {{{0, 0}}}}, 0, 0 },
 159   { "XCFG", 28, {0, {{{0, 0}}}}, 0, 0 },
 160   { "EMCFG", 29, {0, {{{0, 0}}}}, 0, 0 },
 161   { "IPCH", 30, {0, {{{0, 0}}}}, 0, 0 },
 162   { "IPCL", 31, {0, {{{0, 0}}}}, 0, 0 },
 163   { "RAIN", 32, {0, {{{0, 0}}}}, 0, 0 },
 164   { "RAOUT", 33, {0, {{{0, 0}}}}, 0, 0 },
 165   { "RADIR", 34, {0, {{{0, 0}}}}, 0, 0 },
 166   { "LFSRH", 35, {0, {{{0, 0}}}}, 0, 0 },
 167   { "RBIN", 36, {0, {{{0, 0}}}}, 0, 0 },
 168   { "RBOUT", 37, {0, {{{0, 0}}}}, 0, 0 },
 169   { "RBDIR", 38, {0, {{{0, 0}}}}, 0, 0 },
 170   { "LFSRL", 39, {0, {{{0, 0}}}}, 0, 0 },
 171   { "RCIN", 40, {0, {{{0, 0}}}}, 0, 0 },
 172   { "RCOUT", 41, {0, {{{0, 0}}}}, 0, 0 },
 173   { "RCDIR", 42, {0, {{{0, 0}}}}, 0, 0 },
 174   { "LFSRA", 43, {0, {{{0, 0}}}}, 0, 0 },
 175   { "RDIN", 44, {0, {{{0, 0}}}}, 0, 0 },
 176   { "RDOUT", 45, {0, {{{0, 0}}}}, 0, 0 },
 177   { "RDDIR", 46, {0, {{{0, 0}}}}, 0, 0 },
 178   { "REIN", 48, {0, {{{0, 0}}}}, 0, 0 },
 179   { "REOUT", 49, {0, {{{0, 0}}}}, 0, 0 },
 180   { "REDIR", 50, {0, {{{0, 0}}}}, 0, 0 },
 181   { "RFIN", 52, {0, {{{0, 0}}}}, 0, 0 },
 182   { "RFOUT", 53, {0, {{{0, 0}}}}, 0, 0 },
 183   { "RFDIR", 54, {0, {{{0, 0}}}}, 0, 0 },
 184   { "RGOUT", 57, {0, {{{0, 0}}}}, 0, 0 },
 185   { "RGDIR", 58, {0, {{{0, 0}}}}, 0, 0 },
 186   { "RTTMR", 64, {0, {{{0, 0}}}}, 0, 0 },
 187   { "RTCFG", 65, {0, {{{0, 0}}}}, 0, 0 },
 188   { "T0TMR", 66, {0, {{{0, 0}}}}, 0, 0 },
 189   { "T0CFG", 67, {0, {{{0, 0}}}}, 0, 0 },
 190   { "T1CNTH", 68, {0, {{{0, 0}}}}, 0, 0 },
 191   { "T1CNTL", 69, {0, {{{0, 0}}}}, 0, 0 },
 192   { "T1CAP1H", 70, {0, {{{0, 0}}}}, 0, 0 },
 193   { "T1CAP1L", 71, {0, {{{0, 0}}}}, 0, 0 },
 194   { "T1CAP2H", 72, {0, {{{0, 0}}}}, 0, 0 },
 195   { "T1CMP2H", 72, {0, {{{0, 0}}}}, 0, 0 },
 196   { "T1CAP2L", 73, {0, {{{0, 0}}}}, 0, 0 },
 197   { "T1CMP2L", 73, {0, {{{0, 0}}}}, 0, 0 },
 198   { "T1CMP1H", 74, {0, {{{0, 0}}}}, 0, 0 },
 199   { "T1CMP1L", 75, {0, {{{0, 0}}}}, 0, 0 },
 200   { "T1CFG1H", 76, {0, {{{0, 0}}}}, 0, 0 },
 201   { "T1CFG1L", 77, {0, {{{0, 0}}}}, 0, 0 },
 202   { "T1CFG2H", 78, {0, {{{0, 0}}}}, 0, 0 },
 203   { "T1CFG2L", 79, {0, {{{0, 0}}}}, 0, 0 },
 204   { "ADCH", 80, {0, {{{0, 0}}}}, 0, 0 },
 205   { "ADCL", 81, {0, {{{0, 0}}}}, 0, 0 },
 206   { "ADCCFG", 82, {0, {{{0, 0}}}}, 0, 0 },
 207   { "ADCTMR", 83, {0, {{{0, 0}}}}, 0, 0 },
 208   { "T2CNTH", 84, {0, {{{0, 0}}}}, 0, 0 },
 209   { "T2CNTL", 85, {0, {{{0, 0}}}}, 0, 0 },
 210   { "T2CAP1H", 86, {0, {{{0, 0}}}}, 0, 0 },
 211   { "T2CAP1L", 87, {0, {{{0, 0}}}}, 0, 0 },
 212   { "T2CAP2H", 88, {0, {{{0, 0}}}}, 0, 0 },
 213   { "T2CMP2H", 88, {0, {{{0, 0}}}}, 0, 0 },
 214   { "T2CAP2L", 89, {0, {{{0, 0}}}}, 0, 0 },
 215   { "T2CMP2L", 89, {0, {{{0, 0}}}}, 0, 0 },
 216   { "T2CMP1H", 90, {0, {{{0, 0}}}}, 0, 0 },
 217   { "T2CMP1L", 91, {0, {{{0, 0}}}}, 0, 0 },
 218   { "T2CFG1H", 92, {0, {{{0, 0}}}}, 0, 0 },
 219   { "T2CFG1L", 93, {0, {{{0, 0}}}}, 0, 0 },
 220   { "T2CFG2H", 94, {0, {{{0, 0}}}}, 0, 0 },
 221   { "T2CFG2L", 95, {0, {{{0, 0}}}}, 0, 0 },
 222   { "S1TMRH", 96, {0, {{{0, 0}}}}, 0, 0 },
 223   { "S1TMRL", 97, {0, {{{0, 0}}}}, 0, 0 },
 224   { "S1TBUFH", 98, {0, {{{0, 0}}}}, 0, 0 },
 225   { "S1TBUFL", 99, {0, {{{0, 0}}}}, 0, 0 },
 226   { "S1TCFG", 100, {0, {{{0, 0}}}}, 0, 0 },
 227   { "S1RCNT", 101, {0, {{{0, 0}}}}, 0, 0 },
 228   { "S1RBUFH", 102, {0, {{{0, 0}}}}, 0, 0 },
 229   { "S1RBUFL", 103, {0, {{{0, 0}}}}, 0, 0 },
 230   { "S1RCFG", 104, {0, {{{0, 0}}}}, 0, 0 },
 231   { "S1RSYNC", 105, {0, {{{0, 0}}}}, 0, 0 },
 232   { "S1INTF", 106, {0, {{{0, 0}}}}, 0, 0 },
 233   { "S1INTE", 107, {0, {{{0, 0}}}}, 0, 0 },
 234   { "S1MODE", 108, {0, {{{0, 0}}}}, 0, 0 },
 235   { "S1SMASK", 109, {0, {{{0, 0}}}}, 0, 0 },
 236   { "PSPCFG", 110, {0, {{{0, 0}}}}, 0, 0 },
 237   { "CMPCFG", 111, {0, {{{0, 0}}}}, 0, 0 },
 238   { "S2TMRH", 112, {0, {{{0, 0}}}}, 0, 0 },
 239   { "S2TMRL", 113, {0, {{{0, 0}}}}, 0, 0 },
 240   { "S2TBUFH", 114, {0, {{{0, 0}}}}, 0, 0 },
 241   { "S2TBUFL", 115, {0, {{{0, 0}}}}, 0, 0 },
 242   { "S2TCFG", 116, {0, {{{0, 0}}}}, 0, 0 },
 243   { "S2RCNT", 117, {0, {{{0, 0}}}}, 0, 0 },
 244   { "S2RBUFH", 118, {0, {{{0, 0}}}}, 0, 0 },
 245   { "S2RBUFL", 119, {0, {{{0, 0}}}}, 0, 0 },
 246   { "S2RCFG", 120, {0, {{{0, 0}}}}, 0, 0 },
 247   { "S2RSYNC", 121, {0, {{{0, 0}}}}, 0, 0 },
 248   { "S2INTF", 122, {0, {{{0, 0}}}}, 0, 0 },
 249   { "S2INTE", 123, {0, {{{0, 0}}}}, 0, 0 },
 250   { "S2MODE", 124, {0, {{{0, 0}}}}, 0, 0 },
 251   { "S2SMASK", 125, {0, {{{0, 0}}}}, 0, 0 },
 252   { "CALLH", 126, {0, {{{0, 0}}}}, 0, 0 },
 253   { "CALLL", 127, {0, {{{0, 0}}}}, 0, 0 }
 254 };
 255
 256 CGEN_KEYWORD ip2k_cgen_opval_register_names =
 257 {
 258   & ip2k_cgen_opval_register_names_entries[0],
 259   121,
 260   0, 0, 0, 0, ""
 261 };
 262
 263
 264 /* The hardware table.  */
 265
 266 #define A(a) (1 << CGEN_HW_##a)
 267
 268 const CGEN_HW_ENTRY ip2k_cgen_hw_table[] =
 269 {
 270   { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 271   { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 272   { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 273   { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 274   { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 275   { "h-spr", HW_H_SPR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 276   { "h-registers", HW_H_REGISTERS, CGEN_ASM_NONE, 0, { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
 277   { "h-stack", HW_H_STACK, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 278   { "h-pabits", HW_H_PABITS, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 279   { "h-zbit", HW_H_ZBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 280   { "h-cbit", HW_H_CBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 281   { "h-dcbit", HW_H_DCBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 282   { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { { { (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 ip2k_cgen_ifld_table[] =
 294 {
 295   { IP2K_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 296   { IP2K_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 297   { IP2K_F_IMM8, "f-imm8", 0, 16, 7, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 298   { IP2K_F_REG, "f-reg", 0, 16, 8, 9, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 299   { IP2K_F_ADDR16CJP, "f-addr16cjp", 0, 16, 12, 13, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 300   { IP2K_F_DIR, "f-dir", 0, 16, 9, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 301   { IP2K_F_BITNO, "f-bitno", 0, 16, 11, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 302   { IP2K_F_OP3, "f-op3", 0, 16, 15, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 303   { IP2K_F_OP4, "f-op4", 0, 16, 15, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 304   { IP2K_F_OP4MID, "f-op4mid", 0, 16, 11, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 305   { IP2K_F_OP6, "f-op6", 0, 16, 15, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 306   { IP2K_F_OP8, "f-op8", 0, 16, 15, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 307   { IP2K_F_OP6_10LOW, "f-op6-10low", 0, 16, 9, 10, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 308   { IP2K_F_OP6_7LOW, "f-op6-7low", 0, 16, 9, 7, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 309   { IP2K_F_RETI3, "f-reti3", 0, 16, 2, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 310   { IP2K_F_SKIPB, "f-skipb", 0, 16, 12, 1, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 311   { IP2K_F_PAGE3, "f-page3", 0, 16, 2, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 312   { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
 313 };
 314
 315 #undef A
 316
 317
 318
 319 /* multi ifield declarations */
 320
 321
 322
 323 /* multi ifield definitions */
 324
 325
 326 /* The operand table.  */
 327
 328 #define A(a) (1 << CGEN_OPERAND_##a)
 329 #define OPERAND(op) IP2K_OPERAND_##op
 330
 331 const CGEN_OPERAND ip2k_cgen_operand_table[] =
 332 {
 333 /* pc: program counter */
 334   { "pc", IP2K_OPERAND_PC, HW_H_PC, 0, 0,
 335     { 0, { (const PTR) &ip2k_cgen_ifld_table[IP2K_F_NIL] } },
 336     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 337 /* addr16cjp: 13-bit address */
 338   { "addr16cjp", IP2K_OPERAND_ADDR16CJP, HW_H_UINT, 12, 13,
 339     { 0, { (const PTR) &ip2k_cgen_ifld_table[IP2K_F_ADDR16CJP] } },
 340     { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 341 /* fr: register */
 342   { "fr", IP2K_OPERAND_FR, HW_H_REGISTERS, 8, 9,
 343     { 0, { (const PTR) &ip2k_cgen_ifld_table[IP2K_F_REG] } },
 344     { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 345 /* lit8: 8-bit signed literal */
 346   { "lit8", IP2K_OPERAND_LIT8, HW_H_SINT, 7, 8,
 347     { 0, { (const PTR) &ip2k_cgen_ifld_table[IP2K_F_IMM8] } },
 348     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 349 /* bitno: bit number */
 350   { "bitno", IP2K_OPERAND_BITNO, HW_H_UINT, 11, 3,
 351     { 0, { (const PTR) &ip2k_cgen_ifld_table[IP2K_F_BITNO] } },
 352     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 353 /* addr16p: page number */
 354   { "addr16p", IP2K_OPERAND_ADDR16P, HW_H_UINT, 2, 3,
 355     { 0, { (const PTR) &ip2k_cgen_ifld_table[IP2K_F_PAGE3] } },
 356     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 357 /* addr16h: high 8 bits of address */
 358   { "addr16h", IP2K_OPERAND_ADDR16H, HW_H_UINT, 7, 8,
 359     { 0, { (const PTR) &ip2k_cgen_ifld_table[IP2K_F_IMM8] } },
 360     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 361 /* addr16l: low 8 bits of address */
 362   { "addr16l", IP2K_OPERAND_ADDR16L, HW_H_UINT, 7, 8,
 363     { 0, { (const PTR) &ip2k_cgen_ifld_table[IP2K_F_IMM8] } },
 364     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 365 /* reti3: reti flags */
 366   { "reti3", IP2K_OPERAND_RETI3, HW_H_UINT, 2, 3,
 367     { 0, { (const PTR) &ip2k_cgen_ifld_table[IP2K_F_RETI3] } },
 368     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 369 /* pabits: page bits */
 370   { "pabits", IP2K_OPERAND_PABITS, HW_H_PABITS, 0, 0,
 371     { 0, { (const PTR) 0 } },
 372     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 373 /* zbit: zero bit */
 374   { "zbit", IP2K_OPERAND_ZBIT, HW_H_ZBIT, 0, 0,
 375     { 0, { (const PTR) 0 } },
 376     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 377 /* cbit: carry bit */
 378   { "cbit", IP2K_OPERAND_CBIT, HW_H_CBIT, 0, 0,
 379     { 0, { (const PTR) 0 } },
 380     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 381 /* dcbit: digit carry bit */
 382   { "dcbit", IP2K_OPERAND_DCBIT, HW_H_DCBIT, 0, 0,
 383     { 0, { (const PTR) 0 } },
 384     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 385 /* sentinel */
 386   { 0, 0, 0, 0, 0,
 387     { 0, { (const PTR) 0 } },
 388     { 0, { { { (1<<MACH_BASE), 0 } } } } }
 389 };
 390
 391 #undef A
 392
 393
 394 /* The instruction table.  */
 395
 396 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
 397 #define A(a) (1 << CGEN_INSN_##a)
 398
 399 static const CGEN_IBASE ip2k_cgen_insn_table[MAX_INSNS] =
 400 {
 401   /* Special null first entry.
 402      A `num' value of zero is thus invalid.
 403      Also, the special `invalid' insn resides here.  */
 404   { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 405 /* jmp $addr16cjp */
 406   {
 407     IP2K_INSN_JMP, "jmp", "jmp", 16,
 408     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
 409   },
 410 /* call $addr16cjp */
 411   {
 412     IP2K_INSN_CALL, "call", "call", 16,
 413     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
 414   },
 415 /* sb $fr,$bitno */
 416   {
 417     IP2K_INSN_SB, "sb", "sb", 16,
 418     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 419   },
 420 /* snb $fr,$bitno */
 421   {
 422     IP2K_INSN_SNB, "snb", "snb", 16,
 423     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 424   },
 425 /* setb $fr,$bitno */
 426   {
 427     IP2K_INSN_SETB, "setb", "setb", 16,
 428     { 0, { { { (1<<MACH_BASE), 0 } } } }
 429   },
 430 /* clrb $fr,$bitno */
 431   {
 432     IP2K_INSN_CLRB, "clrb", "clrb", 16,
 433     { 0, { { { (1<<MACH_BASE), 0 } } } }
 434   },
 435 /* xor W,#$lit8 */
 436   {
 437     IP2K_INSN_XORW_L, "xorw_l", "xor", 16,
 438     { 0, { { { (1<<MACH_BASE), 0 } } } }
 439   },
 440 /* and W,#$lit8 */
 441   {
 442     IP2K_INSN_ANDW_L, "andw_l", "and", 16,
 443     { 0, { { { (1<<MACH_BASE), 0 } } } }
 444   },
 445 /* or W,#$lit8 */
 446   {
 447     IP2K_INSN_ORW_L, "orw_l", "or", 16,
 448     { 0, { { { (1<<MACH_BASE), 0 } } } }
 449   },
 450 /* add W,#$lit8 */
 451   {
 452     IP2K_INSN_ADDW_L, "addw_l", "add", 16,
 453     { 0, { { { (1<<MACH_BASE), 0 } } } }
 454   },
 455 /* sub W,#$lit8 */
 456   {
 457     IP2K_INSN_SUBW_L, "subw_l", "sub", 16,
 458     { 0, { { { (1<<MACH_BASE), 0 } } } }
 459   },
 460 /* cmp W,#$lit8 */
 461   {
 462     IP2K_INSN_CMPW_L, "cmpw_l", "cmp", 16,
 463     { 0, { { { (1<<MACH_BASE), 0 } } } }
 464   },
 465 /* retw #$lit8 */
 466   {
 467     IP2K_INSN_RETW_L, "retw_l", "retw", 16,
 468     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
 469   },
 470 /* cse W,#$lit8 */
 471   {
 472     IP2K_INSN_CSEW_L, "csew_l", "cse", 16,
 473     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 474   },
 475 /* csne W,#$lit8 */
 476   {
 477     IP2K_INSN_CSNEW_L, "csnew_l", "csne", 16,
 478     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 479   },
 480 /* push #$lit8 */
 481   {
 482     IP2K_INSN_PUSH_L, "push_l", "push", 16,
 483     { 0, { { { (1<<MACH_BASE), 0 } } } }
 484   },
 485 /* muls W,#$lit8 */
 486   {
 487     IP2K_INSN_MULSW_L, "mulsw_l", "muls", 16,
 488     { 0, { { { (1<<MACH_BASE), 0 } } } }
 489   },
 490 /* mulu W,#$lit8 */
 491   {
 492     IP2K_INSN_MULUW_L, "muluw_l", "mulu", 16,
 493     { 0, { { { (1<<MACH_BASE), 0 } } } }
 494   },
 495 /* loadl #$lit8 */
 496   {
 497     IP2K_INSN_LOADL_L, "loadl_l", "loadl", 16,
 498     { 0|A(EXT_SKIP_INSN), { { { (1<<MACH_BASE), 0 } } } }
 499   },
 500 /* loadh #$lit8 */
 501   {
 502     IP2K_INSN_LOADH_L, "loadh_l", "loadh", 16,
 503     { 0|A(EXT_SKIP_INSN), { { { (1<<MACH_BASE), 0 } } } }
 504   },
 505 /* loadl $addr16l */
 506   {
 507     IP2K_INSN_LOADL_A, "loadl_a", "loadl", 16,
 508     { 0|A(EXT_SKIP_INSN), { { { (1<<MACH_BASE), 0 } } } }
 509   },
 510 /* loadh $addr16h */
 511   {
 512     IP2K_INSN_LOADH_A, "loadh_a", "loadh", 16,
 513     { 0|A(EXT_SKIP_INSN), { { { (1<<MACH_BASE), 0 } } } }
 514   },
 515 /* addc $fr,W */
 516   {
 517     IP2K_INSN_ADDCFR_W, "addcfr_w", "addc", 16,
 518     { 0, { { { (1<<MACH_BASE), 0 } } } }
 519   },
 520 /* addc W,$fr */
 521   {
 522     IP2K_INSN_ADDCW_FR, "addcw_fr", "addc", 16,
 523     { 0, { { { (1<<MACH_BASE), 0 } } } }
 524   },
 525 /* incsnz $fr */
 526   {
 527     IP2K_INSN_INCSNZ_FR, "incsnz_fr", "incsnz", 16,
 528     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 529   },
 530 /* incsnz W,$fr */
 531   {
 532     IP2K_INSN_INCSNZW_FR, "incsnzw_fr", "incsnz", 16,
 533     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 534   },
 535 /* muls W,$fr */
 536   {
 537     IP2K_INSN_MULSW_FR, "mulsw_fr", "muls", 16,
 538     { 0, { { { (1<<MACH_BASE), 0 } } } }
 539   },
 540 /* mulu W,$fr */
 541   {
 542     IP2K_INSN_MULUW_FR, "muluw_fr", "mulu", 16,
 543     { 0, { { { (1<<MACH_BASE), 0 } } } }
 544   },
 545 /* decsnz $fr */
 546   {
 547     IP2K_INSN_DECSNZ_FR, "decsnz_fr", "decsnz", 16,
 548     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 549   },
 550 /* decsnz W,$fr */
 551   {
 552     IP2K_INSN_DECSNZW_FR, "decsnzw_fr", "decsnz", 16,
 553     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 554   },
 555 /* subc W,$fr */
 556   {
 557     IP2K_INSN_SUBCW_FR, "subcw_fr", "subc", 16,
 558     { 0, { { { (1<<MACH_BASE), 0 } } } }
 559   },
 560 /* subc $fr,W */
 561   {
 562     IP2K_INSN_SUBCFR_W, "subcfr_w", "subc", 16,
 563     { 0, { { { (1<<MACH_BASE), 0 } } } }
 564   },
 565 /* pop $fr */
 566   {
 567     IP2K_INSN_POP_FR, "pop_fr", "pop", 16,
 568     { 0, { { { (1<<MACH_BASE), 0 } } } }
 569   },
 570 /* push $fr */
 571   {
 572     IP2K_INSN_PUSH_FR, "push_fr", "push", 16,
 573     { 0, { { { (1<<MACH_BASE), 0 } } } }
 574   },
 575 /* cse W,$fr */
 576   {
 577     IP2K_INSN_CSEW_FR, "csew_fr", "cse", 16,
 578     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 579   },
 580 /* csne W,$fr */
 581   {
 582     IP2K_INSN_CSNEW_FR, "csnew_fr", "csne", 16,
 583     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 584   },
 585 /* incsz $fr */
 586   {
 587     IP2K_INSN_INCSZ_FR, "incsz_fr", "incsz", 16,
 588     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 589   },
 590 /* incsz W,$fr */
 591   {
 592     IP2K_INSN_INCSZW_FR, "incszw_fr", "incsz", 16,
 593     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 594   },
 595 /* swap $fr */
 596   {
 597     IP2K_INSN_SWAP_FR, "swap_fr", "swap", 16,
 598     { 0, { { { (1<<MACH_BASE), 0 } } } }
 599   },
 600 /* swap W,$fr */
 601   {
 602     IP2K_INSN_SWAPW_FR, "swapw_fr", "swap", 16,
 603     { 0, { { { (1<<MACH_BASE), 0 } } } }
 604   },
 605 /* rl $fr */
 606   {
 607     IP2K_INSN_RL_FR, "rl_fr", "rl", 16,
 608     { 0, { { { (1<<MACH_BASE), 0 } } } }
 609   },
 610 /* rl W,$fr */
 611   {
 612     IP2K_INSN_RLW_FR, "rlw_fr", "rl", 16,
 613     { 0, { { { (1<<MACH_BASE), 0 } } } }
 614   },
 615 /* rr $fr */
 616   {
 617     IP2K_INSN_RR_FR, "rr_fr", "rr", 16,
 618     { 0, { { { (1<<MACH_BASE), 0 } } } }
 619   },
 620 /* rr W,$fr */
 621   {
 622     IP2K_INSN_RRW_FR, "rrw_fr", "rr", 16,
 623     { 0, { { { (1<<MACH_BASE), 0 } } } }
 624   },
 625 /* decsz $fr */
 626   {
 627     IP2K_INSN_DECSZ_FR, "decsz_fr", "decsz", 16,
 628     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 629   },
 630 /* decsz W,$fr */
 631   {
 632     IP2K_INSN_DECSZW_FR, "decszw_fr", "decsz", 16,
 633     { 0|A(SKIP_CTI), { { { (1<<MACH_BASE), 0 } } } }
 634   },
 635 /* inc $fr */
 636   {
 637     IP2K_INSN_INC_FR, "inc_fr", "inc", 16,
 638     { 0, { { { (1<<MACH_BASE), 0 } } } }
 639   },
 640 /* inc W,$fr */
 641   {
 642     IP2K_INSN_INCW_FR, "incw_fr", "inc", 16,
 643     { 0, { { { (1<<MACH_BASE), 0 } } } }
 644   },
 645 /* not $fr */
 646   {
 647     IP2K_INSN_NOT_FR, "not_fr", "not", 16,
 648     { 0, { { { (1<<MACH_BASE), 0 } } } }
 649   },
 650 /* not W,$fr */
 651   {
 652     IP2K_INSN_NOTW_FR, "notw_fr", "not", 16,
 653     { 0, { { { (1<<MACH_BASE), 0 } } } }
 654   },
 655 /* test $fr */
 656   {
 657     IP2K_INSN_TEST_FR, "test_fr", "test", 16,
 658     { 0, { { { (1<<MACH_BASE), 0 } } } }
 659   },
 660 /* mov W,#$lit8 */
 661   {
 662     IP2K_INSN_MOVW_L, "movw_l", "mov", 16,
 663     { 0, { { { (1<<MACH_BASE), 0 } } } }
 664   },
 665 /* mov $fr,W */
 666   {
 667     IP2K_INSN_MOVFR_W, "movfr_w", "mov", 16,
 668     { 0, { { { (1<<MACH_BASE), 0 } } } }
 669   },
 670 /* mov W,$fr */
 671   {
 672     IP2K_INSN_MOVW_FR, "movw_fr", "mov", 16,
 673     { 0, { { { (1<<MACH_BASE), 0 } } } }
 674   },
 675 /* add $fr,W */
 676   {
 677     IP2K_INSN_ADDFR_W, "addfr_w", "add", 16,
 678     { 0, { { { (1<<MACH_BASE), 0 } } } }
 679   },
 680 /* add W,$fr */
 681   {
 682     IP2K_INSN_ADDW_FR, "addw_fr", "add", 16,
 683     { 0, { { { (1<<MACH_BASE), 0 } } } }
 684   },
 685 /* xor $fr,W */
 686   {
 687     IP2K_INSN_XORFR_W, "xorfr_w", "xor", 16,
 688     { 0, { { { (1<<MACH_BASE), 0 } } } }
 689   },
 690 /* xor W,$fr */
 691   {
 692     IP2K_INSN_XORW_FR, "xorw_fr", "xor", 16,
 693     { 0, { { { (1<<MACH_BASE), 0 } } } }
 694   },
 695 /* and $fr,W */
 696   {
 697     IP2K_INSN_ANDFR_W, "andfr_w", "and", 16,
 698     { 0, { { { (1<<MACH_BASE), 0 } } } }
 699   },
 700 /* and W,$fr */
 701   {
 702     IP2K_INSN_ANDW_FR, "andw_fr", "and", 16,
 703     { 0, { { { (1<<MACH_BASE), 0 } } } }
 704   },
 705 /* or $fr,W */
 706   {
 707     IP2K_INSN_ORFR_W, "orfr_w", "or", 16,
 708     { 0, { { { (1<<MACH_BASE), 0 } } } }
 709   },
 710 /* or W,$fr */
 711   {
 712     IP2K_INSN_ORW_FR, "orw_fr", "or", 16,
 713     { 0, { { { (1<<MACH_BASE), 0 } } } }
 714   },
 715 /* dec $fr */
 716   {
 717     IP2K_INSN_DEC_FR, "dec_fr", "dec", 16,
 718     { 0, { { { (1<<MACH_BASE), 0 } } } }
 719   },
 720 /* dec W,$fr */
 721   {
 722     IP2K_INSN_DECW_FR, "decw_fr", "dec", 16,
 723     { 0, { { { (1<<MACH_BASE), 0 } } } }
 724   },
 725 /* sub $fr,W */
 726   {
 727     IP2K_INSN_SUBFR_W, "subfr_w", "sub", 16,
 728     { 0, { { { (1<<MACH_BASE), 0 } } } }
 729   },
 730 /* sub W,$fr */
 731   {
 732     IP2K_INSN_SUBW_FR, "subw_fr", "sub", 16,
 733     { 0, { { { (1<<MACH_BASE), 0 } } } }
 734   },
 735 /* clr $fr */
 736   {
 737     IP2K_INSN_CLR_FR, "clr_fr", "clr", 16,
 738     { 0, { { { (1<<MACH_BASE), 0 } } } }
 739   },
 740 /* cmp W,$fr */
 741   {
 742     IP2K_INSN_CMPW_FR, "cmpw_fr", "cmp", 16,
 743     { 0, { { { (1<<MACH_BASE), 0 } } } }
 744   },
 745 /* speed #$lit8 */
 746   {
 747     IP2K_INSN_SPEED, "speed", "speed", 16,
 748     { 0, { { { (1<<MACH_BASE), 0 } } } }
 749   },
 750 /* ireadi */
 751   {
 752     IP2K_INSN_IREADI, "ireadi", "ireadi", 16,
 753     { 0, { { { (1<<MACH_BASE), 0 } } } }
 754   },
 755 /* iwritei */
 756   {
 757     IP2K_INSN_IWRITEI, "iwritei", "iwritei", 16,
 758     { 0, { { { (1<<MACH_BASE), 0 } } } }
 759   },
 760 /* fread */
 761   {
 762     IP2K_INSN_FREAD, "fread", "fread", 16,
 763     { 0, { { { (1<<MACH_BASE), 0 } } } }
 764   },
 765 /* fwrite */
 766   {
 767     IP2K_INSN_FWRITE, "fwrite", "fwrite", 16,
 768     { 0, { { { (1<<MACH_BASE), 0 } } } }
 769   },
 770 /* iread */
 771   {
 772     IP2K_INSN_IREAD, "iread", "iread", 16,
 773     { 0, { { { (1<<MACH_BASE), 0 } } } }
 774   },
 775 /* iwrite */
 776   {
 777     IP2K_INSN_IWRITE, "iwrite", "iwrite", 16,
 778     { 0, { { { (1<<MACH_BASE), 0 } } } }
 779   },
 780 /* page $addr16p */
 781   {
 782     IP2K_INSN_PAGE, "page", "page", 16,
 783     { 0|A(EXT_SKIP_INSN), { { { (1<<MACH_BASE), 0 } } } }
 784   },
 785 /* system */
 786   {
 787     IP2K_INSN_SYSTEM, "system", "system", 16,
 788     { 0, { { { (1<<MACH_BASE), 0 } } } }
 789   },
 790 /* reti #$reti3 */
 791   {
 792     IP2K_INSN_RETI, "reti", "reti", 16,
 793     { 0, { { { (1<<MACH_BASE), 0 } } } }
 794   },
 795 /* ret */
 796   {
 797     IP2K_INSN_RET, "ret", "ret", 16,
 798     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
 799   },
 800 /* int */
 801   {
 802     IP2K_INSN_INT, "int", "int", 16,
 803     { 0, { { { (1<<MACH_BASE), 0 } } } }
 804   },
 805 /* breakx */
 806   {
 807     IP2K_INSN_BREAKX, "breakx", "breakx", 16,
 808     { 0|A(EXT_SKIP_INSN), { { { (1<<MACH_BASE), 0 } } } }
 809   },
 810 /* cwdt */
 811   {
 812     IP2K_INSN_CWDT, "cwdt", "cwdt", 16,
 813     { 0, { { { (1<<MACH_BASE), 0 } } } }
 814   },
 815 /* ferase */
 816   {
 817     IP2K_INSN_FERASE, "ferase", "ferase", 16,
 818     { 0, { { { (1<<MACH_BASE), 0 } } } }
 819   },
 820 /* retnp */
 821   {
 822     IP2K_INSN_RETNP, "retnp", "retnp", 16,
 823     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
 824   },
 825 /* break */
 826   {
 827     IP2K_INSN_BREAK, "break", "break", 16,
 828     { 0, { { { (1<<MACH_BASE), 0 } } } }
 829   },
 830 /* nop */
 831   {
 832     IP2K_INSN_NOP, "nop", "nop", 16,
 833     { 0, { { { (1<<MACH_BASE), 0 } } } }
 834   },
 835 };
 836
 837 #undef OP
 838 #undef A
 839
 840 /* Initialize anything needed to be done once, before any cpu_open call.  */
 841
 842 static void
 843 init_tables (void)
 844 {
 845 }
 846
 847 static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
 848 static void build_hw_table      (CGEN_CPU_TABLE *);
 849 static void build_ifield_table  (CGEN_CPU_TABLE *);
 850 static void build_operand_table (CGEN_CPU_TABLE *);
 851 static void build_insn_table    (CGEN_CPU_TABLE *);
 852 static void ip2k_cgen_rebuild_tables (CGEN_CPU_TABLE *);
 853
 854 /* Subroutine of ip2k_cgen_cpu_open to look up a mach via its bfd name.  */
 855
 856 static const CGEN_MACH *
 857 lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
 858 {
 859   while (table->name)
 860     {
 861       if (strcmp (name, table->bfd_name) == 0)
 862         return table;
 863       ++table;
 864     }
 865   abort ();
 866 }
 867
 868 /* Subroutine of ip2k_cgen_cpu_open to build the hardware table.  */
 869
 870 static void
 871 build_hw_table (CGEN_CPU_TABLE *cd)
 872 {
 873   int i;
 874   int machs = cd->machs;
 875   const CGEN_HW_ENTRY *init = & ip2k_cgen_hw_table[0];
 876   /* MAX_HW is only an upper bound on the number of selected entries.
 877      However each entry is indexed by it's enum so there can be holes in
 878      the table.  */
 879   const CGEN_HW_ENTRY **selected =
 880     (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
 881
 882   cd->hw_table.init_entries = init;
 883   cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
 884   memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
 885   /* ??? For now we just use machs to determine which ones we want.  */
 886   for (i = 0; init[i].name != NULL; ++i)
 887     if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
 888         & machs)
 889       selected[init[i].type] = &init[i];
 890   cd->hw_table.entries = selected;
 891   cd->hw_table.num_entries = MAX_HW;
 892 }
 893
 894 /* Subroutine of ip2k_cgen_cpu_open to build the hardware table.  */
 895
 896 static void
 897 build_ifield_table (CGEN_CPU_TABLE *cd)
 898 {
 899   cd->ifld_table = & ip2k_cgen_ifld_table[0];
 900 }
 901
 902 /* Subroutine of ip2k_cgen_cpu_open to build the hardware table.  */
 903
 904 static void
 905 build_operand_table (CGEN_CPU_TABLE *cd)
 906 {
 907   int i;
 908   int machs = cd->machs;
 909   const CGEN_OPERAND *init = & ip2k_cgen_operand_table[0];
 910   /* MAX_OPERANDS is only an upper bound on the number of selected entries.
 911      However each entry is indexed by it's enum so there can be holes in
 912      the table.  */
 913   const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected));
 914
 915   cd->operand_table.init_entries = init;
 916   cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
 917   memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
 918   /* ??? For now we just use mach to determine which ones we want.  */
 919   for (i = 0; init[i].name != NULL; ++i)
 920     if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
 921         & machs)
 922       selected[init[i].type] = &init[i];
 923   cd->operand_table.entries = selected;
 924   cd->operand_table.num_entries = MAX_OPERANDS;
 925 }
 926
 927 /* Subroutine of ip2k_cgen_cpu_open to build the hardware table.
 928    ??? This could leave out insns not supported by the specified mach/isa,
 929    but that would cause errors like "foo only supported by bar" to become
 930    "unknown insn", so for now we include all insns and require the app to
 931    do the checking later.
 932    ??? On the other hand, parsing of such insns may require their hardware or
 933    operand elements to be in the table [which they mightn't be].  */
 934
 935 static void
 936 build_insn_table (CGEN_CPU_TABLE *cd)
 937 {
 938   int i;
 939   const CGEN_IBASE *ib = & ip2k_cgen_insn_table[0];
 940   CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
 941
 942   memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
 943   for (i = 0; i < MAX_INSNS; ++i)
 944     insns[i].base = &ib[i];
 945   cd->insn_table.init_entries = insns;
 946   cd->insn_table.entry_size = sizeof (CGEN_IBASE);
 947   cd->insn_table.num_init_entries = MAX_INSNS;
 948 }
 949
 950 /* Subroutine of ip2k_cgen_cpu_open to rebuild the tables.  */
 951
 952 static void
 953 ip2k_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
 954 {
 955   int i;
 956   CGEN_BITSET *isas = cd->isas;
 957   unsigned int machs = cd->machs;
 958
 959   cd->int_insn_p = CGEN_INT_INSN_P;
 960
 961   /* Data derived from the isa spec.  */
 962 #define UNSET (CGEN_SIZE_UNKNOWN + 1)
 963   cd->default_insn_bitsize = UNSET;
 964   cd->base_insn_bitsize = UNSET;
 965   cd->min_insn_bitsize = 65535; /* Some ridiculously big number.  */
 966   cd->max_insn_bitsize = 0;
 967   for (i = 0; i < MAX_ISAS; ++i)
 968     if (cgen_bitset_contains (isas, i))
 969       {
 970         const CGEN_ISA *isa = & ip2k_cgen_isa_table[i];
 971
 972         /* Default insn sizes of all selected isas must be
 973            equal or we set the result to 0, meaning "unknown".  */
 974         if (cd->default_insn_bitsize == UNSET)
 975           cd->default_insn_bitsize = isa->default_insn_bitsize;
 976         else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
 977           ; /* This is ok.  */
 978         else
 979           cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
 980
 981         /* Base insn sizes of all selected isas must be equal
 982            or we set the result to 0, meaning "unknown".  */
 983         if (cd->base_insn_bitsize == UNSET)
 984           cd->base_insn_bitsize = isa->base_insn_bitsize;
 985         else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
 986           ; /* This is ok.  */
 987         else
 988           cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
 989
 990         /* Set min,max insn sizes.  */
 991         if (isa->min_insn_bitsize < cd->min_insn_bitsize)
 992           cd->min_insn_bitsize = isa->min_insn_bitsize;
 993         if (isa->max_insn_bitsize > cd->max_insn_bitsize)
 994           cd->max_insn_bitsize = isa->max_insn_bitsize;
 995       }
 996
 997   /* Data derived from the mach spec.  */
 998   for (i = 0; i < MAX_MACHS; ++i)
 999     if (((1 << i) & machs) != 0)
1000       {
1001         const CGEN_MACH *mach = & ip2k_cgen_mach_table[i];
1002
1003         if (mach->insn_chunk_bitsize != 0)
1004         {
1005           if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
1006             {
1007               fprintf (stderr, "ip2k_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
1008                        cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
1009               abort ();
1010             }
1011
1012           cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
1013         }
1014       }
1015
1016   /* Determine which hw elements are used by MACH.  */
1017   build_hw_table (cd);
1018
1019   /* Build the ifield table.  */
1020   build_ifield_table (cd);
1021
1022   /* Determine which operands are used by MACH/ISA.  */
1023   build_operand_table (cd);
1024
1025   /* Build the instruction table.  */
1026   build_insn_table (cd);
1027 }
1028
1029 /* Initialize a cpu table and return a descriptor.
1030    It's much like opening a file, and must be the first function called.
1031    The arguments are a set of (type/value) pairs, terminated with
1032    CGEN_CPU_OPEN_END.
1033
1034    Currently supported values:
1035    CGEN_CPU_OPEN_ISAS:    bitmap of values in enum isa_attr
1036    CGEN_CPU_OPEN_MACHS:   bitmap of values in enum mach_attr
1037    CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
1038    CGEN_CPU_OPEN_ENDIAN:  specify endian choice
1039    CGEN_CPU_OPEN_END:     terminates arguments
1040
1041    ??? Simultaneous multiple isas might not make sense, but it's not (yet)
1042    precluded.  */
1043
1044 CGEN_CPU_DESC
1045 ip2k_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
1046 {
1047   CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
1048   static int init_p;
1049   CGEN_BITSET *isas = 0;  /* 0 = "unspecified" */
1050   unsigned int machs = 0; /* 0 = "unspecified" */
1051   enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
1052   va_list ap;
1053
1054   if (! init_p)
1055     {
1056       init_tables ();
1057       init_p = 1;
1058     }
1059
1060   memset (cd, 0, sizeof (*cd));
1061
1062   va_start (ap, arg_type);
1063   while (arg_type != CGEN_CPU_OPEN_END)
1064     {
1065       switch (arg_type)
1066         {
1067         case CGEN_CPU_OPEN_ISAS :
1068           isas = va_arg (ap, CGEN_BITSET *);
1069           break;
1070         case CGEN_CPU_OPEN_MACHS :
1071           machs = va_arg (ap, unsigned int);
1072           break;
1073         case CGEN_CPU_OPEN_BFDMACH :
1074           {
1075             const char *name = va_arg (ap, const char *);
1076             const CGEN_MACH *mach =
1077               lookup_mach_via_bfd_name (ip2k_cgen_mach_table, name);
1078
1079             machs |= 1 << mach->num;
1080             break;
1081           }
1082         case CGEN_CPU_OPEN_ENDIAN :
1083           endian = va_arg (ap, enum cgen_endian);
1084           break;
1085         default :
1086           fprintf (stderr, "ip2k_cgen_cpu_open: unsupported argument `%d'\n",
1087                    arg_type);
1088           abort (); /* ??? return NULL? */
1089         }
1090       arg_type = va_arg (ap, enum cgen_cpu_open_arg);
1091     }
1092   va_end (ap);
1093
1094   /* Mach unspecified means "all".  */
1095   if (machs == 0)
1096     machs = (1 << MAX_MACHS) - 1;
1097   /* Base mach is always selected.  */
1098   machs |= 1;
1099   if (endian == CGEN_ENDIAN_UNKNOWN)
1100     {
1101       /* ??? If target has only one, could have a default.  */
1102       fprintf (stderr, "ip2k_cgen_cpu_open: no endianness specified\n");
1103       abort ();
1104     }
1105
1106   cd->isas = cgen_bitset_copy (isas);
1107   cd->machs = machs;
1108   cd->endian = endian;
1109   /* FIXME: for the sparc case we can determine insn-endianness statically.
1110      The worry here is where both data and insn endian can be independently
1111      chosen, in which case this function will need another argument.
1112      Actually, will want to allow for more arguments in the future anyway.  */
1113   cd->insn_endian = endian;
1114
1115   /* Table (re)builder.  */
1116   cd->rebuild_tables = ip2k_cgen_rebuild_tables;
1117   ip2k_cgen_rebuild_tables (cd);
1118
1119   /* Default to not allowing signed overflow.  */
1120   cd->signed_overflow_ok_p = 0;
1121
1122   return (CGEN_CPU_DESC) cd;
1123 }
1124
1125 /* Cover fn to ip2k_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
1126    MACH_NAME is the bfd name of the mach.  */
1127
1128 CGEN_CPU_DESC
1129 ip2k_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
1130 {
1131   return ip2k_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
1132                                CGEN_CPU_OPEN_ENDIAN, endian,
1133                                CGEN_CPU_OPEN_END);
1134 }
1135
1136 /* Close a cpu table.
1137    ??? This can live in a machine independent file, but there's currently
1138    no place to put this file (there's no libcgen).  libopcodes is the wrong
1139    place as some simulator ports use this but they don't use libopcodes.  */
1140
1141 void
1142 ip2k_cgen_cpu_close (CGEN_CPU_DESC cd)
1143 {
1144   unsigned int i;
1145   const CGEN_INSN *insns;
1146
1147   if (cd->macro_insn_table.init_entries)
1148     {
1149       insns = cd->macro_insn_table.init_entries;
1150       for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
1151         if (CGEN_INSN_RX ((insns)))
1152           regfree (CGEN_INSN_RX (insns));
1153     }
1154
1155   if (cd->insn_table.init_entries)
1156     {
1157       insns = cd->insn_table.init_entries;
1158       for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
1159         if (CGEN_INSN_RX (insns))
1160           regfree (CGEN_INSN_RX (insns));
1161     }
1162
1163   if (cd->macro_insn_table.init_entries)
1164     free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
1165
1166   if (cd->insn_table.init_entries)
1167     free ((CGEN_INSN *) cd->insn_table.init_entries);
1168
1169   if (cd->hw_table.entries)
1170     free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
1171
1172   if (cd->operand_table.entries)
1173     free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
1174
1175   free (cd);
1176 }
1177