opcodes/lm32-desc.c

   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