Home | History | Annotate | Download | only in opcodes
      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 
   1178