Home | History | Annotate | Download | only in opcodes
      1 /* CPU data for lm32.
      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 "lm32-desc.h"
     32 #include "lm32-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   { "lm32", MACH_LM32 },
     50   { "max", MACH_MAX },
     51   { 0, 0 }
     52 };
     53 
     54 static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
     55 {
     56   { "lm32", ISA_LM32 },
     57   { "max", ISA_MAX },
     58   { 0, 0 }
     59 };
     60 
     61 const CGEN_ATTR_TABLE lm32_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 lm32_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 lm32_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   { 0, 0, 0 }
     95 };
     96 
     97 const CGEN_ATTR_TABLE lm32_cgen_insn_attr_table[] =
     98 {
     99   { "MACH", & MACH_attr[0], & MACH_attr[0] },
    100   { "ALIAS", &bool_attr[0], &bool_attr[0] },
    101   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
    102   { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] },
    103   { "COND-CTI", &bool_attr[0], &bool_attr[0] },
    104   { "SKIP-CTI", &bool_attr[0], &bool_attr[0] },
    105   { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
    106   { "RELAXABLE", &bool_attr[0], &bool_attr[0] },
    107   { "RELAXED", &bool_attr[0], &bool_attr[0] },
    108   { "NO-DIS", &bool_attr[0], &bool_attr[0] },
    109   { "PBB", &bool_attr[0], &bool_attr[0] },
    110   { 0, 0, 0 }
    111 };
    112 
    113 /* Instruction set variants.  */
    114 
    115 static const CGEN_ISA lm32_cgen_isa_table[] = {
    116   { "lm32", 32, 32, 32, 32 },
    117   { 0, 0, 0, 0, 0 }
    118 };
    119 
    120 /* Machine variants.  */
    121 
    122 static const CGEN_MACH lm32_cgen_mach_table[] = {
    123   { "lm32", "lm32", MACH_LM32, 0 },
    124   { 0, 0, 0, 0 }
    125 };
    126 
    127 static CGEN_KEYWORD_ENTRY lm32_cgen_opval_h_gr_entries[] =
    128 {
    129   { "gp", 26, {0, {{{0, 0}}}}, 0, 0 },
    130   { "fp", 27, {0, {{{0, 0}}}}, 0, 0 },
    131   { "sp", 28, {0, {{{0, 0}}}}, 0, 0 },
    132   { "ra", 29, {0, {{{0, 0}}}}, 0, 0 },
    133   { "ea", 30, {0, {{{0, 0}}}}, 0, 0 },
    134   { "ba", 31, {0, {{{0, 0}}}}, 0, 0 },
    135   { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
    136   { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
    137   { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
    138   { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
    139   { "r4", 4, {0, {{{0, 0}}}}, 0, 0 },
    140   { "r5", 5, {0, {{{0, 0}}}}, 0, 0 },
    141   { "r6", 6, {0, {{{0, 0}}}}, 0, 0 },
    142   { "r7", 7, {0, {{{0, 0}}}}, 0, 0 },
    143   { "r8", 8, {0, {{{0, 0}}}}, 0, 0 },
    144   { "r9", 9, {0, {{{0, 0}}}}, 0, 0 },
    145   { "r10", 10, {0, {{{0, 0}}}}, 0, 0 },
    146   { "r11", 11, {0, {{{0, 0}}}}, 0, 0 },
    147   { "r12", 12, {0, {{{0, 0}}}}, 0, 0 },
    148   { "r13", 13, {0, {{{0, 0}}}}, 0, 0 },
    149   { "r14", 14, {0, {{{0, 0}}}}, 0, 0 },
    150   { "r15", 15, {0, {{{0, 0}}}}, 0, 0 },
    151   { "r16", 16, {0, {{{0, 0}}}}, 0, 0 },
    152   { "r17", 17, {0, {{{0, 0}}}}, 0, 0 },
    153   { "r18", 18, {0, {{{0, 0}}}}, 0, 0 },
    154   { "r19", 19, {0, {{{0, 0}}}}, 0, 0 },
    155   { "r20", 20, {0, {{{0, 0}}}}, 0, 0 },
    156   { "r21", 21, {0, {{{0, 0}}}}, 0, 0 },
    157   { "r22", 22, {0, {{{0, 0}}}}, 0, 0 },
    158   { "r23", 23, {0, {{{0, 0}}}}, 0, 0 },
    159   { "r24", 24, {0, {{{0, 0}}}}, 0, 0 },
    160   { "r25", 25, {0, {{{0, 0}}}}, 0, 0 },
    161   { "r26", 26, {0, {{{0, 0}}}}, 0, 0 },
    162   { "r27", 27, {0, {{{0, 0}}}}, 0, 0 },
    163   { "r28", 28, {0, {{{0, 0}}}}, 0, 0 },
    164   { "r29", 29, {0, {{{0, 0}}}}, 0, 0 },
    165   { "r30", 30, {0, {{{0, 0}}}}, 0, 0 },
    166   { "r31", 31, {0, {{{0, 0}}}}, 0, 0 }
    167 };
    168 
    169 CGEN_KEYWORD lm32_cgen_opval_h_gr =
    170 {
    171   & lm32_cgen_opval_h_gr_entries[0],
    172   38,
    173   0, 0, 0, 0, ""
    174 };
    175 
    176 static CGEN_KEYWORD_ENTRY lm32_cgen_opval_h_csr_entries[] =
    177 {
    178   { "IE", 0, {0, {{{0, 0}}}}, 0, 0 },
    179   { "IM", 1, {0, {{{0, 0}}}}, 0, 0 },
    180   { "IP", 2, {0, {{{0, 0}}}}, 0, 0 },
    181   { "ICC", 3, {0, {{{0, 0}}}}, 0, 0 },
    182   { "DCC", 4, {0, {{{0, 0}}}}, 0, 0 },
    183   { "CC", 5, {0, {{{0, 0}}}}, 0, 0 },
    184   { "CFG", 6, {0, {{{0, 0}}}}, 0, 0 },
    185   { "EBA", 7, {0, {{{0, 0}}}}, 0, 0 },
    186   { "DC", 8, {0, {{{0, 0}}}}, 0, 0 },
    187   { "DEBA", 9, {0, {{{0, 0}}}}, 0, 0 },
    188   { "CFG2", 10, {0, {{{0, 0}}}}, 0, 0 },
    189   { "JTX", 14, {0, {{{0, 0}}}}, 0, 0 },
    190   { "JRX", 15, {0, {{{0, 0}}}}, 0, 0 },
    191   { "BP0", 16, {0, {{{0, 0}}}}, 0, 0 },
    192   { "BP1", 17, {0, {{{0, 0}}}}, 0, 0 },
    193   { "BP2", 18, {0, {{{0, 0}}}}, 0, 0 },
    194   { "BP3", 19, {0, {{{0, 0}}}}, 0, 0 },
    195   { "WP0", 24, {0, {{{0, 0}}}}, 0, 0 },
    196   { "WP1", 25, {0, {{{0, 0}}}}, 0, 0 },
    197   { "WP2", 26, {0, {{{0, 0}}}}, 0, 0 },
    198   { "WP3", 27, {0, {{{0, 0}}}}, 0, 0 },
    199   { "PSW", 29, {0, {{{0, 0}}}}, 0, 0 },
    200   { "TLBVADDR", 30, {0, {{{0, 0}}}}, 0, 0 },
    201   { "TLBPADDR", 31, {0, {{{0, 0}}}}, 0, 0 },
    202   { "TLBBADVADDR", 31, {0, {{{0, 0}}}}, 0, 0 }
    203 };
    204 
    205 CGEN_KEYWORD lm32_cgen_opval_h_csr =
    206 {
    207   & lm32_cgen_opval_h_csr_entries[0],
    208   25,
    209   0, 0, 0, 0, ""
    210 };
    211 
    212 
    213 /* The hardware table.  */
    214 
    215 #define A(a) (1 << CGEN_HW_##a)
    216 
    217 const CGEN_HW_ENTRY lm32_cgen_hw_table[] =
    218 {
    219   { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    220   { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    221   { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    222   { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    223   { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    224   { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PC), { { { (1<<MACH_BASE), 0 } } } } },
    225   { "h-gr", HW_H_GR, CGEN_ASM_KEYWORD, (PTR) & lm32_cgen_opval_h_gr, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    226   { "h-csr", HW_H_CSR, CGEN_ASM_KEYWORD, (PTR) & lm32_cgen_opval_h_csr, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    227   { 0, 0, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
    228 };
    229 
    230 #undef A
    231 
    232 
    233 /* The instruction field table.  */
    234 
    235 #define A(a) (1 << CGEN_IFLD_##a)
    236 
    237 const CGEN_IFLD lm32_cgen_ifld_table[] =
    238 {
    239   { LM32_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    240   { LM32_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    241   { LM32_F_OPCODE, "f-opcode", 0, 32, 31, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    242   { LM32_F_R0, "f-r0", 0, 32, 25, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    243   { LM32_F_R1, "f-r1", 0, 32, 20, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    244   { LM32_F_R2, "f-r2", 0, 32, 15, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    245   { LM32_F_RESV0, "f-resv0", 0, 32, 10, 11, { 0|A(RESERVED), { { { (1<<MACH_BASE), 0 } } } }  },
    246   { LM32_F_SHIFT, "f-shift", 0, 32, 4, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    247   { LM32_F_IMM, "f-imm", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    248   { LM32_F_UIMM, "f-uimm", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    249   { LM32_F_CSR, "f-csr", 0, 32, 25, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    250   { LM32_F_USER, "f-user", 0, 32, 10, 11, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    251   { LM32_F_EXCEPTION, "f-exception", 0, 32, 25, 26, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    252   { LM32_F_BRANCH, "f-branch", 0, 32, 15, 16, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    253   { LM32_F_CALL, "f-call", 0, 32, 25, 26, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    254   { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
    255 };
    256 
    257 #undef A
    258 
    259 
    260 
    261 /* multi ifield declarations */
    262 
    263 
    264 
    265 /* multi ifield definitions */
    266 
    267 
    268 /* The operand table.  */
    269 
    270 #define A(a) (1 << CGEN_OPERAND_##a)
    271 #define OPERAND(op) LM32_OPERAND_##op
    272 
    273 const CGEN_OPERAND lm32_cgen_operand_table[] =
    274 {
    275 /* pc: program counter */
    276   { "pc", LM32_OPERAND_PC, HW_H_PC, 0, 0,
    277     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_NIL] } },
    278     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
    279 /* r0: register 0 */
    280   { "r0", LM32_OPERAND_R0, HW_H_GR, 25, 5,
    281     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_R0] } },
    282     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    283 /* r1: register 1 */
    284   { "r1", LM32_OPERAND_R1, HW_H_GR, 20, 5,
    285     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_R1] } },
    286     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    287 /* r2: register 2 */
    288   { "r2", LM32_OPERAND_R2, HW_H_GR, 15, 5,
    289     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_R2] } },
    290     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    291 /* shift: shift amout */
    292   { "shift", LM32_OPERAND_SHIFT, HW_H_UINT, 4, 5,
    293     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_SHIFT] } },
    294     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    295 /* imm: signed immediate */
    296   { "imm", LM32_OPERAND_IMM, HW_H_SINT, 15, 16,
    297     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_IMM] } },
    298     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    299 /* uimm: unsigned immediate */
    300   { "uimm", LM32_OPERAND_UIMM, HW_H_UINT, 15, 16,
    301     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_UIMM] } },
    302     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    303 /* branch: branch offset */
    304   { "branch", LM32_OPERAND_BRANCH, HW_H_IADDR, 15, 16,
    305     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_BRANCH] } },
    306     { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    307 /* call: call offset */
    308   { "call", LM32_OPERAND_CALL, HW_H_IADDR, 25, 26,
    309     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_CALL] } },
    310     { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
    311 /* csr: csr */
    312   { "csr", LM32_OPERAND_CSR, HW_H_CSR, 25, 5,
    313     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_CSR] } },
    314     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    315 /* user: user */
    316   { "user", LM32_OPERAND_USER, HW_H_UINT, 10, 11,
    317     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_USER] } },
    318     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    319 /* exception: exception */
    320   { "exception", LM32_OPERAND_EXCEPTION, HW_H_UINT, 25, 26,
    321     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_EXCEPTION] } },
    322     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    323 /* hi16: high 16-bit immediate */
    324   { "hi16", LM32_OPERAND_HI16, HW_H_UINT, 15, 16,
    325     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_UIMM] } },
    326     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    327 /* lo16: low 16-bit immediate */
    328   { "lo16", LM32_OPERAND_LO16, HW_H_UINT, 15, 16,
    329     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_UIMM] } },
    330     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    331 /* gp16: gp relative 16-bit immediate */
    332   { "gp16", LM32_OPERAND_GP16, HW_H_SINT, 15, 16,
    333     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_IMM] } },
    334     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    335 /* got16: got 16-bit immediate */
    336   { "got16", LM32_OPERAND_GOT16, HW_H_SINT, 15, 16,
    337     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_IMM] } },
    338     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    339 /* gotoffhi16: got offset high 16-bit immediate */
    340   { "gotoffhi16", LM32_OPERAND_GOTOFFHI16, HW_H_SINT, 15, 16,
    341     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_IMM] } },
    342     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    343 /* gotofflo16: got offset low 16-bit immediate */
    344   { "gotofflo16", LM32_OPERAND_GOTOFFLO16, HW_H_SINT, 15, 16,
    345     { 0, { (const PTR) &lm32_cgen_ifld_table[LM32_F_IMM] } },
    346     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
    347 /* sentinel */
    348   { 0, 0, 0, 0, 0,
    349     { 0, { (const PTR) 0 } },
    350     { 0, { { { (1<<MACH_BASE), 0 } } } } }
    351 };
    352 
    353 #undef A
    354 
    355 
    356 /* The instruction table.  */
    357 
    358 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
    359 #define A(a) (1 << CGEN_INSN_##a)
    360 
    361 static const CGEN_IBASE lm32_cgen_insn_table[MAX_INSNS] =
    362 {
    363   /* Special null first entry.
    364      A `num' value of zero is thus invalid.
    365      Also, the special `invalid' insn resides here.  */
    366   { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
    367 /* add $r2,$r0,$r1 */
    368   {
    369     LM32_INSN_ADD, "add", "add", 32,
    370     { 0, { { { (1<<MACH_BASE), 0 } } } }
    371   },
    372 /* addi $r1,$r0,$imm */
    373   {
    374     LM32_INSN_ADDI, "addi", "addi", 32,
    375     { 0, { { { (1<<MACH_BASE), 0 } } } }
    376   },
    377 /* and $r2,$r0,$r1 */
    378   {
    379     LM32_INSN_AND, "and", "and", 32,
    380     { 0, { { { (1<<MACH_BASE), 0 } } } }
    381   },
    382 /* andi $r1,$r0,$uimm */
    383   {
    384     LM32_INSN_ANDI, "andi", "andi", 32,
    385     { 0, { { { (1<<MACH_BASE), 0 } } } }
    386   },
    387 /* andhi $r1,$r0,$hi16 */
    388   {
    389     LM32_INSN_ANDHII, "andhii", "andhi", 32,
    390     { 0, { { { (1<<MACH_BASE), 0 } } } }
    391   },
    392 /* b $r0 */
    393   {
    394     LM32_INSN_B, "b", "b", 32,
    395     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    396   },
    397 /* bi $call */
    398   {
    399     LM32_INSN_BI, "bi", "bi", 32,
    400     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    401   },
    402 /* be $r0,$r1,$branch */
    403   {
    404     LM32_INSN_BE, "be", "be", 32,
    405     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    406   },
    407 /* bg $r0,$r1,$branch */
    408   {
    409     LM32_INSN_BG, "bg", "bg", 32,
    410     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    411   },
    412 /* bge $r0,$r1,$branch */
    413   {
    414     LM32_INSN_BGE, "bge", "bge", 32,
    415     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    416   },
    417 /* bgeu $r0,$r1,$branch */
    418   {
    419     LM32_INSN_BGEU, "bgeu", "bgeu", 32,
    420     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    421   },
    422 /* bgu $r0,$r1,$branch */
    423   {
    424     LM32_INSN_BGU, "bgu", "bgu", 32,
    425     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    426   },
    427 /* bne $r0,$r1,$branch */
    428   {
    429     LM32_INSN_BNE, "bne", "bne", 32,
    430     { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    431   },
    432 /* call $r0 */
    433   {
    434     LM32_INSN_CALL, "call", "call", 32,
    435     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    436   },
    437 /* calli $call */
    438   {
    439     LM32_INSN_CALLI, "calli", "calli", 32,
    440     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    441   },
    442 /* cmpe $r2,$r0,$r1 */
    443   {
    444     LM32_INSN_CMPE, "cmpe", "cmpe", 32,
    445     { 0, { { { (1<<MACH_BASE), 0 } } } }
    446   },
    447 /* cmpei $r1,$r0,$imm */
    448   {
    449     LM32_INSN_CMPEI, "cmpei", "cmpei", 32,
    450     { 0, { { { (1<<MACH_BASE), 0 } } } }
    451   },
    452 /* cmpg $r2,$r0,$r1 */
    453   {
    454     LM32_INSN_CMPG, "cmpg", "cmpg", 32,
    455     { 0, { { { (1<<MACH_BASE), 0 } } } }
    456   },
    457 /* cmpgi $r1,$r0,$imm */
    458   {
    459     LM32_INSN_CMPGI, "cmpgi", "cmpgi", 32,
    460     { 0, { { { (1<<MACH_BASE), 0 } } } }
    461   },
    462 /* cmpge $r2,$r0,$r1 */
    463   {
    464     LM32_INSN_CMPGE, "cmpge", "cmpge", 32,
    465     { 0, { { { (1<<MACH_BASE), 0 } } } }
    466   },
    467 /* cmpgei $r1,$r0,$imm */
    468   {
    469     LM32_INSN_CMPGEI, "cmpgei", "cmpgei", 32,
    470     { 0, { { { (1<<MACH_BASE), 0 } } } }
    471   },
    472 /* cmpgeu $r2,$r0,$r1 */
    473   {
    474     LM32_INSN_CMPGEU, "cmpgeu", "cmpgeu", 32,
    475     { 0, { { { (1<<MACH_BASE), 0 } } } }
    476   },
    477 /* cmpgeui $r1,$r0,$uimm */
    478   {
    479     LM32_INSN_CMPGEUI, "cmpgeui", "cmpgeui", 32,
    480     { 0, { { { (1<<MACH_BASE), 0 } } } }
    481   },
    482 /* cmpgu $r2,$r0,$r1 */
    483   {
    484     LM32_INSN_CMPGU, "cmpgu", "cmpgu", 32,
    485     { 0, { { { (1<<MACH_BASE), 0 } } } }
    486   },
    487 /* cmpgui $r1,$r0,$uimm */
    488   {
    489     LM32_INSN_CMPGUI, "cmpgui", "cmpgui", 32,
    490     { 0, { { { (1<<MACH_BASE), 0 } } } }
    491   },
    492 /* cmpne $r2,$r0,$r1 */
    493   {
    494     LM32_INSN_CMPNE, "cmpne", "cmpne", 32,
    495     { 0, { { { (1<<MACH_BASE), 0 } } } }
    496   },
    497 /* cmpnei $r1,$r0,$imm */
    498   {
    499     LM32_INSN_CMPNEI, "cmpnei", "cmpnei", 32,
    500     { 0, { { { (1<<MACH_BASE), 0 } } } }
    501   },
    502 /* divu $r2,$r0,$r1 */
    503   {
    504     LM32_INSN_DIVU, "divu", "divu", 32,
    505     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    506   },
    507 /* lb $r1,($r0+$imm) */
    508   {
    509     LM32_INSN_LB, "lb", "lb", 32,
    510     { 0, { { { (1<<MACH_BASE), 0 } } } }
    511   },
    512 /* lbu $r1,($r0+$imm) */
    513   {
    514     LM32_INSN_LBU, "lbu", "lbu", 32,
    515     { 0, { { { (1<<MACH_BASE), 0 } } } }
    516   },
    517 /* lh $r1,($r0+$imm) */
    518   {
    519     LM32_INSN_LH, "lh", "lh", 32,
    520     { 0, { { { (1<<MACH_BASE), 0 } } } }
    521   },
    522 /* lhu $r1,($r0+$imm) */
    523   {
    524     LM32_INSN_LHU, "lhu", "lhu", 32,
    525     { 0, { { { (1<<MACH_BASE), 0 } } } }
    526   },
    527 /* lw $r1,($r0+$imm) */
    528   {
    529     LM32_INSN_LW, "lw", "lw", 32,
    530     { 0, { { { (1<<MACH_BASE), 0 } } } }
    531   },
    532 /* modu $r2,$r0,$r1 */
    533   {
    534     LM32_INSN_MODU, "modu", "modu", 32,
    535     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    536   },
    537 /* mul $r2,$r0,$r1 */
    538   {
    539     LM32_INSN_MUL, "mul", "mul", 32,
    540     { 0, { { { (1<<MACH_BASE), 0 } } } }
    541   },
    542 /* muli $r1,$r0,$imm */
    543   {
    544     LM32_INSN_MULI, "muli", "muli", 32,
    545     { 0, { { { (1<<MACH_BASE), 0 } } } }
    546   },
    547 /* nor $r2,$r0,$r1 */
    548   {
    549     LM32_INSN_NOR, "nor", "nor", 32,
    550     { 0, { { { (1<<MACH_BASE), 0 } } } }
    551   },
    552 /* nori $r1,$r0,$uimm */
    553   {
    554     LM32_INSN_NORI, "nori", "nori", 32,
    555     { 0, { { { (1<<MACH_BASE), 0 } } } }
    556   },
    557 /* or $r2,$r0,$r1 */
    558   {
    559     LM32_INSN_OR, "or", "or", 32,
    560     { 0, { { { (1<<MACH_BASE), 0 } } } }
    561   },
    562 /* ori $r1,$r0,$lo16 */
    563   {
    564     LM32_INSN_ORI, "ori", "ori", 32,
    565     { 0, { { { (1<<MACH_BASE), 0 } } } }
    566   },
    567 /* orhi $r1,$r0,$hi16 */
    568   {
    569     LM32_INSN_ORHII, "orhii", "orhi", 32,
    570     { 0, { { { (1<<MACH_BASE), 0 } } } }
    571   },
    572 /* rcsr $r2,$csr */
    573   {
    574     LM32_INSN_RCSR, "rcsr", "rcsr", 32,
    575     { 0, { { { (1<<MACH_BASE), 0 } } } }
    576   },
    577 /* sb ($r0+$imm),$r1 */
    578   {
    579     LM32_INSN_SB, "sb", "sb", 32,
    580     { 0, { { { (1<<MACH_BASE), 0 } } } }
    581   },
    582 /* sextb $r2,$r0 */
    583   {
    584     LM32_INSN_SEXTB, "sextb", "sextb", 32,
    585     { 0, { { { (1<<MACH_BASE), 0 } } } }
    586   },
    587 /* sexth $r2,$r0 */
    588   {
    589     LM32_INSN_SEXTH, "sexth", "sexth", 32,
    590     { 0, { { { (1<<MACH_BASE), 0 } } } }
    591   },
    592 /* sh ($r0+$imm),$r1 */
    593   {
    594     LM32_INSN_SH, "sh", "sh", 32,
    595     { 0, { { { (1<<MACH_BASE), 0 } } } }
    596   },
    597 /* sl $r2,$r0,$r1 */
    598   {
    599     LM32_INSN_SL, "sl", "sl", 32,
    600     { 0, { { { (1<<MACH_BASE), 0 } } } }
    601   },
    602 /* sli $r1,$r0,$imm */
    603   {
    604     LM32_INSN_SLI, "sli", "sli", 32,
    605     { 0, { { { (1<<MACH_BASE), 0 } } } }
    606   },
    607 /* sr $r2,$r0,$r1 */
    608   {
    609     LM32_INSN_SR, "sr", "sr", 32,
    610     { 0, { { { (1<<MACH_BASE), 0 } } } }
    611   },
    612 /* sri $r1,$r0,$imm */
    613   {
    614     LM32_INSN_SRI, "sri", "sri", 32,
    615     { 0, { { { (1<<MACH_BASE), 0 } } } }
    616   },
    617 /* sru $r2,$r0,$r1 */
    618   {
    619     LM32_INSN_SRU, "sru", "sru", 32,
    620     { 0, { { { (1<<MACH_BASE), 0 } } } }
    621   },
    622 /* srui $r1,$r0,$imm */
    623   {
    624     LM32_INSN_SRUI, "srui", "srui", 32,
    625     { 0, { { { (1<<MACH_BASE), 0 } } } }
    626   },
    627 /* sub $r2,$r0,$r1 */
    628   {
    629     LM32_INSN_SUB, "sub", "sub", 32,
    630     { 0, { { { (1<<MACH_BASE), 0 } } } }
    631   },
    632 /* sw ($r0+$imm),$r1 */
    633   {
    634     LM32_INSN_SW, "sw", "sw", 32,
    635     { 0, { { { (1<<MACH_BASE), 0 } } } }
    636   },
    637 /* user $r2,$r0,$r1,$user */
    638   {
    639     LM32_INSN_USER, "user", "user", 32,
    640     { 0, { { { (1<<MACH_BASE), 0 } } } }
    641   },
    642 /* wcsr $csr,$r1 */
    643   {
    644     LM32_INSN_WCSR, "wcsr", "wcsr", 32,
    645     { 0, { { { (1<<MACH_BASE), 0 } } } }
    646   },
    647 /* xor $r2,$r0,$r1 */
    648   {
    649     LM32_INSN_XOR, "xor", "xor", 32,
    650     { 0, { { { (1<<MACH_BASE), 0 } } } }
    651   },
    652 /* xori $r1,$r0,$uimm */
    653   {
    654     LM32_INSN_XORI, "xori", "xori", 32,
    655     { 0, { { { (1<<MACH_BASE), 0 } } } }
    656   },
    657 /* xnor $r2,$r0,$r1 */
    658   {
    659     LM32_INSN_XNOR, "xnor", "xnor", 32,
    660     { 0, { { { (1<<MACH_BASE), 0 } } } }
    661   },
    662 /* xnori $r1,$r0,$uimm */
    663   {
    664     LM32_INSN_XNORI, "xnori", "xnori", 32,
    665     { 0, { { { (1<<MACH_BASE), 0 } } } }
    666   },
    667 /* break */
    668   {
    669     LM32_INSN_BREAK, "break", "break", 32,
    670     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    671   },
    672 /* scall */
    673   {
    674     LM32_INSN_SCALL, "scall", "scall", 32,
    675     { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    676   },
    677 /* bret */
    678   {
    679     -1, "bret", "bret", 32,
    680     { 0|A(ALIAS)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    681   },
    682 /* eret */
    683   {
    684     -1, "eret", "eret", 32,
    685     { 0|A(ALIAS)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    686   },
    687 /* ret */
    688   {
    689     -1, "ret", "ret", 32,
    690     { 0|A(ALIAS)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } } } }
    691   },
    692 /* mv $r2,$r0 */
    693   {
    694     -1, "mv", "mv", 32,
    695     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    696   },
    697 /* mvi $r1,$imm */
    698   {
    699     -1, "mvi", "mvi", 32,
    700     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    701   },
    702 /* mvu $r1,$lo16 */
    703   {
    704     -1, "mvui", "mvu", 32,
    705     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    706   },
    707 /* mvhi $r1,$hi16 */
    708   {
    709     -1, "mvhi", "mvhi", 32,
    710     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    711   },
    712 /* mva $r1,$gp16 */
    713   {
    714     -1, "mva", "mva", 32,
    715     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    716   },
    717 /* not $r2,$r0 */
    718   {
    719     -1, "not", "not", 32,
    720     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    721   },
    722 /* nop */
    723   {
    724     -1, "nop", "nop", 32,
    725     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    726   },
    727 /* lb $r1,$gp16 */
    728   {
    729     -1, "lbgprel", "lb", 32,
    730     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    731   },
    732 /* lbu $r1,$gp16 */
    733   {
    734     -1, "lbugprel", "lbu", 32,
    735     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    736   },
    737 /* lh $r1,$gp16 */
    738   {
    739     -1, "lhgprel", "lh", 32,
    740     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    741   },
    742 /* lhu $r1,$gp16 */
    743   {
    744     -1, "lhugprel", "lhu", 32,
    745     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    746   },
    747 /* lw $r1,$gp16 */
    748   {
    749     -1, "lwgprel", "lw", 32,
    750     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    751   },
    752 /* sb $gp16,$r1 */
    753   {
    754     -1, "sbgprel", "sb", 32,
    755     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    756   },
    757 /* sh $gp16,$r1 */
    758   {
    759     -1, "shgprel", "sh", 32,
    760     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    761   },
    762 /* sw $gp16,$r1 */
    763   {
    764     -1, "swgprel", "sw", 32,
    765     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    766   },
    767 /* lw $r1,(gp+$got16) */
    768   {
    769     -1, "lwgotrel", "lw", 32,
    770     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    771   },
    772 /* orhi $r1,$r0,$gotoffhi16 */
    773   {
    774     -1, "orhigotoffi", "orhi", 32,
    775     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    776   },
    777 /* addi $r1,$r0,$gotofflo16 */
    778   {
    779     -1, "addgotoff", "addi", 32,
    780     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    781   },
    782 /* sw ($r0+$gotofflo16),$r1 */
    783   {
    784     -1, "swgotoff", "sw", 32,
    785     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    786   },
    787 /* lw $r1,($r0+$gotofflo16) */
    788   {
    789     -1, "lwgotoff", "lw", 32,
    790     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    791   },
    792 /* sh ($r0+$gotofflo16),$r1 */
    793   {
    794     -1, "shgotoff", "sh", 32,
    795     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    796   },
    797 /* lh $r1,($r0+$gotofflo16) */
    798   {
    799     -1, "lhgotoff", "lh", 32,
    800     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    801   },
    802 /* lhu $r1,($r0+$gotofflo16) */
    803   {
    804     -1, "lhugotoff", "lhu", 32,
    805     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    806   },
    807 /* sb ($r0+$gotofflo16),$r1 */
    808   {
    809     -1, "sbgotoff", "sb", 32,
    810     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    811   },
    812 /* lb $r1,($r0+$gotofflo16) */
    813   {
    814     -1, "lbgotoff", "lb", 32,
    815     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    816   },
    817 /* lbu $r1,($r0+$gotofflo16) */
    818   {
    819     -1, "lbugotoff", "lbu", 32,
    820     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
    821   },
    822 };
    823 
    824 #undef OP
    825 #undef A
    826 
    827 /* Initialize anything needed to be done once, before any cpu_open call.  */
    828 
    829 static void
    830 init_tables (void)
    831 {
    832 }
    833 
    834 static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
    835 static void build_hw_table      (CGEN_CPU_TABLE *);
    836 static void build_ifield_table  (CGEN_CPU_TABLE *);
    837 static void build_operand_table (CGEN_CPU_TABLE *);
    838 static void build_insn_table    (CGEN_CPU_TABLE *);
    839 static void lm32_cgen_rebuild_tables (CGEN_CPU_TABLE *);
    840 
    841 /* Subroutine of lm32_cgen_cpu_open to look up a mach via its bfd name.  */
    842 
    843 static const CGEN_MACH *
    844 lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
    845 {
    846   while (table->name)
    847     {
    848       if (strcmp (name, table->bfd_name) == 0)
    849 	return table;
    850       ++table;
    851     }
    852   abort ();
    853 }
    854 
    855 /* Subroutine of lm32_cgen_cpu_open to build the hardware table.  */
    856 
    857 static void
    858 build_hw_table (CGEN_CPU_TABLE *cd)
    859 {
    860   int i;
    861   int machs = cd->machs;
    862   const CGEN_HW_ENTRY *init = & lm32_cgen_hw_table[0];
    863   /* MAX_HW is only an upper bound on the number of selected entries.
    864      However each entry is indexed by it's enum so there can be holes in
    865      the table.  */
    866   const CGEN_HW_ENTRY **selected =
    867     (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
    868 
    869   cd->hw_table.init_entries = init;
    870   cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
    871   memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
    872   /* ??? For now we just use machs to determine which ones we want.  */
    873   for (i = 0; init[i].name != NULL; ++i)
    874     if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
    875 	& machs)
    876       selected[init[i].type] = &init[i];
    877   cd->hw_table.entries = selected;
    878   cd->hw_table.num_entries = MAX_HW;
    879 }
    880 
    881 /* Subroutine of lm32_cgen_cpu_open to build the hardware table.  */
    882 
    883 static void
    884 build_ifield_table (CGEN_CPU_TABLE *cd)
    885 {
    886   cd->ifld_table = & lm32_cgen_ifld_table[0];
    887 }
    888 
    889 /* Subroutine of lm32_cgen_cpu_open to build the hardware table.  */
    890 
    891 static void
    892 build_operand_table (CGEN_CPU_TABLE *cd)
    893 {
    894   int i;
    895   int machs = cd->machs;
    896   const CGEN_OPERAND *init = & lm32_cgen_operand_table[0];
    897   /* MAX_OPERANDS is only an upper bound on the number of selected entries.
    898      However each entry is indexed by it's enum so there can be holes in
    899      the table.  */
    900   const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected));
    901 
    902   cd->operand_table.init_entries = init;
    903   cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
    904   memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
    905   /* ??? For now we just use mach to determine which ones we want.  */
    906   for (i = 0; init[i].name != NULL; ++i)
    907     if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
    908 	& machs)
    909       selected[init[i].type] = &init[i];
    910   cd->operand_table.entries = selected;
    911   cd->operand_table.num_entries = MAX_OPERANDS;
    912 }
    913 
    914 /* Subroutine of lm32_cgen_cpu_open to build the hardware table.
    915    ??? This could leave out insns not supported by the specified mach/isa,
    916    but that would cause errors like "foo only supported by bar" to become
    917    "unknown insn", so for now we include all insns and require the app to
    918    do the checking later.
    919    ??? On the other hand, parsing of such insns may require their hardware or
    920    operand elements to be in the table [which they mightn't be].  */
    921 
    922 static void
    923 build_insn_table (CGEN_CPU_TABLE *cd)
    924 {
    925   int i;
    926   const CGEN_IBASE *ib = & lm32_cgen_insn_table[0];
    927   CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
    928 
    929   memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
    930   for (i = 0; i < MAX_INSNS; ++i)
    931     insns[i].base = &ib[i];
    932   cd->insn_table.init_entries = insns;
    933   cd->insn_table.entry_size = sizeof (CGEN_IBASE);
    934   cd->insn_table.num_init_entries = MAX_INSNS;
    935 }
    936 
    937 /* Subroutine of lm32_cgen_cpu_open to rebuild the tables.  */
    938 
    939 static void
    940 lm32_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
    941 {
    942   int i;
    943   CGEN_BITSET *isas = cd->isas;
    944   unsigned int machs = cd->machs;
    945 
    946   cd->int_insn_p = CGEN_INT_INSN_P;
    947 
    948   /* Data derived from the isa spec.  */
    949 #define UNSET (CGEN_SIZE_UNKNOWN + 1)
    950   cd->default_insn_bitsize = UNSET;
    951   cd->base_insn_bitsize = UNSET;
    952   cd->min_insn_bitsize = 65535; /* Some ridiculously big number.  */
    953   cd->max_insn_bitsize = 0;
    954   for (i = 0; i < MAX_ISAS; ++i)
    955     if (cgen_bitset_contains (isas, i))
    956       {
    957 	const CGEN_ISA *isa = & lm32_cgen_isa_table[i];
    958 
    959 	/* Default insn sizes of all selected isas must be
    960 	   equal or we set the result to 0, meaning "unknown".  */
    961 	if (cd->default_insn_bitsize == UNSET)
    962 	  cd->default_insn_bitsize = isa->default_insn_bitsize;
    963 	else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
    964 	  ; /* This is ok.  */
    965 	else
    966 	  cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
    967 
    968 	/* Base insn sizes of all selected isas must be equal
    969 	   or we set the result to 0, meaning "unknown".  */
    970 	if (cd->base_insn_bitsize == UNSET)
    971 	  cd->base_insn_bitsize = isa->base_insn_bitsize;
    972 	else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
    973 	  ; /* This is ok.  */
    974 	else
    975 	  cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
    976 
    977 	/* Set min,max insn sizes.  */
    978 	if (isa->min_insn_bitsize < cd->min_insn_bitsize)
    979 	  cd->min_insn_bitsize = isa->min_insn_bitsize;
    980 	if (isa->max_insn_bitsize > cd->max_insn_bitsize)
    981 	  cd->max_insn_bitsize = isa->max_insn_bitsize;
    982       }
    983 
    984   /* Data derived from the mach spec.  */
    985   for (i = 0; i < MAX_MACHS; ++i)
    986     if (((1 << i) & machs) != 0)
    987       {
    988 	const CGEN_MACH *mach = & lm32_cgen_mach_table[i];
    989 
    990 	if (mach->insn_chunk_bitsize != 0)
    991 	{
    992 	  if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
    993 	    {
    994 	      fprintf (stderr, "lm32_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
    995 		       cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
    996 	      abort ();
    997 	    }
    998 
    999  	  cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
   1000 	}
   1001       }
   1002 
   1003   /* Determine which hw elements are used by MACH.  */
   1004   build_hw_table (cd);
   1005 
   1006   /* Build the ifield table.  */
   1007   build_ifield_table (cd);
   1008 
   1009   /* Determine which operands are used by MACH/ISA.  */
   1010   build_operand_table (cd);
   1011 
   1012   /* Build the instruction table.  */
   1013   build_insn_table (cd);
   1014 }
   1015 
   1016 /* Initialize a cpu table and return a descriptor.
   1017    It's much like opening a file, and must be the first function called.
   1018    The arguments are a set of (type/value) pairs, terminated with
   1019    CGEN_CPU_OPEN_END.
   1020 
   1021    Currently supported values:
   1022    CGEN_CPU_OPEN_ISAS:    bitmap of values in enum isa_attr
   1023    CGEN_CPU_OPEN_MACHS:   bitmap of values in enum mach_attr
   1024    CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
   1025    CGEN_CPU_OPEN_ENDIAN:  specify endian choice
   1026    CGEN_CPU_OPEN_END:     terminates arguments
   1027 
   1028    ??? Simultaneous multiple isas might not make sense, but it's not (yet)
   1029    precluded.  */
   1030 
   1031 CGEN_CPU_DESC
   1032 lm32_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
   1033 {
   1034   CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
   1035   static int init_p;
   1036   CGEN_BITSET *isas = 0;  /* 0 = "unspecified" */
   1037   unsigned int machs = 0; /* 0 = "unspecified" */
   1038   enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
   1039   va_list ap;
   1040 
   1041   if (! init_p)
   1042     {
   1043       init_tables ();
   1044       init_p = 1;
   1045     }
   1046 
   1047   memset (cd, 0, sizeof (*cd));
   1048 
   1049   va_start (ap, arg_type);
   1050   while (arg_type != CGEN_CPU_OPEN_END)
   1051     {
   1052       switch (arg_type)
   1053 	{
   1054 	case CGEN_CPU_OPEN_ISAS :
   1055 	  isas = va_arg (ap, CGEN_BITSET *);
   1056 	  break;
   1057 	case CGEN_CPU_OPEN_MACHS :
   1058 	  machs = va_arg (ap, unsigned int);
   1059 	  break;
   1060 	case CGEN_CPU_OPEN_BFDMACH :
   1061 	  {
   1062 	    const char *name = va_arg (ap, const char *);
   1063 	    const CGEN_MACH *mach =
   1064 	      lookup_mach_via_bfd_name (lm32_cgen_mach_table, name);
   1065 
   1066 	    machs |= 1 << mach->num;
   1067 	    break;
   1068 	  }
   1069 	case CGEN_CPU_OPEN_ENDIAN :
   1070 	  endian = va_arg (ap, enum cgen_endian);
   1071 	  break;
   1072 	default :
   1073 	  fprintf (stderr, "lm32_cgen_cpu_open: unsupported argument `%d'\n",
   1074 		   arg_type);
   1075 	  abort (); /* ??? return NULL? */
   1076 	}
   1077       arg_type = va_arg (ap, enum cgen_cpu_open_arg);
   1078     }
   1079   va_end (ap);
   1080 
   1081   /* Mach unspecified means "all".  */
   1082   if (machs == 0)
   1083     machs = (1 << MAX_MACHS) - 1;
   1084   /* Base mach is always selected.  */
   1085   machs |= 1;
   1086   if (endian == CGEN_ENDIAN_UNKNOWN)
   1087     {
   1088       /* ??? If target has only one, could have a default.  */
   1089       fprintf (stderr, "lm32_cgen_cpu_open: no endianness specified\n");
   1090       abort ();
   1091     }
   1092 
   1093   cd->isas = cgen_bitset_copy (isas);
   1094   cd->machs = machs;
   1095   cd->endian = endian;
   1096   /* FIXME: for the sparc case we can determine insn-endianness statically.
   1097      The worry here is where both data and insn endian can be independently
   1098      chosen, in which case this function will need another argument.
   1099      Actually, will want to allow for more arguments in the future anyway.  */
   1100   cd->insn_endian = endian;
   1101 
   1102   /* Table (re)builder.  */
   1103   cd->rebuild_tables = lm32_cgen_rebuild_tables;
   1104   lm32_cgen_rebuild_tables (cd);
   1105 
   1106   /* Default to not allowing signed overflow.  */
   1107   cd->signed_overflow_ok_p = 0;
   1108 
   1109   return (CGEN_CPU_DESC) cd;
   1110 }
   1111 
   1112 /* Cover fn to lm32_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
   1113    MACH_NAME is the bfd name of the mach.  */
   1114 
   1115 CGEN_CPU_DESC
   1116 lm32_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
   1117 {
   1118   return lm32_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
   1119 			       CGEN_CPU_OPEN_ENDIAN, endian,
   1120 			       CGEN_CPU_OPEN_END);
   1121 }
   1122 
   1123 /* Close a cpu table.
   1124    ??? This can live in a machine independent file, but there's currently
   1125    no place to put this file (there's no libcgen).  libopcodes is the wrong
   1126    place as some simulator ports use this but they don't use libopcodes.  */
   1127 
   1128 void
   1129 lm32_cgen_cpu_close (CGEN_CPU_DESC cd)
   1130 {
   1131   unsigned int i;
   1132   const CGEN_INSN *insns;
   1133 
   1134   if (cd->macro_insn_table.init_entries)
   1135     {
   1136       insns = cd->macro_insn_table.init_entries;
   1137       for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
   1138 	if (CGEN_INSN_RX ((insns)))
   1139 	  regfree (CGEN_INSN_RX (insns));
   1140     }
   1141 
   1142   if (cd->insn_table.init_entries)
   1143     {
   1144       insns = cd->insn_table.init_entries;
   1145       for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
   1146 	if (CGEN_INSN_RX (insns))
   1147 	  regfree (CGEN_INSN_RX (insns));
   1148     }
   1149 
   1150   if (cd->macro_insn_table.init_entries)
   1151     free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
   1152 
   1153   if (cd->insn_table.init_entries)
   1154     free ((CGEN_INSN *) cd->insn_table.init_entries);
   1155 
   1156   if (cd->hw_table.entries)
   1157     free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
   1158 
   1159   if (cd->operand_table.entries)
   1160     free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
   1161 
   1162   free (cd);
   1163 }
   1164 
   1165