gnu/dist/gdb6/opcodes/ip2k-opc.c

   1 /* Instruction opcode table for ip2k.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright 1996-2005 Free Software Foundation, Inc.
   6
   7 This file is part of the GNU Binutils and/or GDB, the GNU debugger.
   8
   9 This program 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 2, or (at your option)
  12 any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public 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 "ansidecl.h"
  27 #include "bfd.h"
  28 #include "symcat.h"
  29 #include "ip2k-desc.h"
  30 #include "ip2k-opc.h"
  31 #include "libiberty.h"
  32
  33 /* -- opc.c */
  34
  35 #include "safe-ctype.h"
  36
  37 /* A better hash function for instruction mnemonics.  */
  38 unsigned int
  39 ip2k_asm_hash (const char* insn)
  40 {
  41   unsigned int hash;
  42   const char* m = insn;
  43
  44   for (hash = 0; *m && ! ISSPACE (*m); m++)
  45     hash = (hash * 23) ^ (0x1F & TOLOWER (*m));
  46
  47   /* printf ("%s %d\n", insn, (hash % CGEN_ASM_HASH_SIZE)); */
  48
  49   return hash % CGEN_ASM_HASH_SIZE;
  50 }
  51
  52
  53 /* Special check to ensure that instruction exists for given machine.  */
  54
  55 int
  56 ip2k_cgen_insn_supported (CGEN_CPU_DESC cd, const CGEN_INSN *insn)
  57 {
  58   int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
  59
  60   /* No mach attribute?  Assume it's supported for all machs.  */
  61   if (machs == 0)
  62     return 1;
  63
  64   return (machs & cd->machs) != 0;
  65 }
  66
  67 \f
  68 /* -- asm.c */
  69 /* The hash functions are recorded here to help keep assembler code out of
  70    the disassembler and vice versa.  */
  71
  72 static int asm_hash_insn_p        (const CGEN_INSN *);
  73 static unsigned int asm_hash_insn (const char *);
  74 static int dis_hash_insn_p        (const CGEN_INSN *);
  75 static unsigned int dis_hash_insn (const char *, CGEN_INSN_INT);
  76
  77 /* Instruction formats.  */
  78
  79 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
  80 #define F(f) & ip2k_cgen_ifld_table[IP2K_##f]
  81 #else
  82 #define F(f) & ip2k_cgen_ifld_table[IP2K_/**/f]
  83 #endif
  84 static const CGEN_IFMT ifmt_empty ATTRIBUTE_UNUSED = {
  85   0, 0, 0x0, { { 0 } }
  86 };
  87
  88 static const CGEN_IFMT ifmt_jmp ATTRIBUTE_UNUSED = {
  89   16, 16, 0xe000, { { F (F_OP3) }, { F (F_ADDR16CJP) }, { 0 } }
  90 };
  91
  92 static const CGEN_IFMT ifmt_sb ATTRIBUTE_UNUSED = {
  93   16, 16, 0xf000, { { F (F_OP4) }, { F (F_BITNO) }, { F (F_REG) }, { 0 } }
  94 };
  95
  96 static const CGEN_IFMT ifmt_xorw_l ATTRIBUTE_UNUSED = {
  97   16, 16, 0xff00, { { F (F_OP4) }, { F (F_OP4MID) }, { F (F_IMM8) }, { 0 } }
  98 };
  99
 100 static const CGEN_IFMT ifmt_loadl_a ATTRIBUTE_UNUSED = {
 101   16, 16, 0xff00, { { F (F_OP4) }, { F (F_OP4MID) }, { F (F_IMM8) }, { 0 } }
 102 };
 103
 104 static const CGEN_IFMT ifmt_loadh_a ATTRIBUTE_UNUSED = {
 105   16, 16, 0xff00, { { F (F_OP4) }, { F (F_OP4MID) }, { F (F_IMM8) }, { 0 } }
 106 };
 107
 108 static const CGEN_IFMT ifmt_addcfr_w ATTRIBUTE_UNUSED = {
 109   16, 16, 0xfe00, { { F (F_OP6) }, { F (F_DIR) }, { F (F_REG) }, { 0 } }
 110 };
 111
 112 static const CGEN_IFMT ifmt_speed ATTRIBUTE_UNUSED = {
 113   16, 16, 0xff00, { { F (F_OP8) }, { F (F_IMM8) }, { 0 } }
 114 };
 115
 116 static const CGEN_IFMT ifmt_ireadi ATTRIBUTE_UNUSED = {
 117   16, 16, 0xffff, { { F (F_OP6) }, { F (F_OP6_10LOW) }, { 0 } }
 118 };
 119
 120 static const CGEN_IFMT ifmt_page ATTRIBUTE_UNUSED = {
 121   16, 16, 0xfff8, { { F (F_OP6) }, { F (F_OP6_7LOW) }, { F (F_PAGE3) }, { 0 } }
 122 };
 123
 124 static const CGEN_IFMT ifmt_reti ATTRIBUTE_UNUSED = {
 125   16, 16, 0xfff8, { { F (F_OP6) }, { F (F_OP6_7LOW) }, { F (F_RETI3) }, { 0 } }
 126 };
 127
 128 #undef F
 129
 130 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 131 #define A(a) (1 << CGEN_INSN_##a)
 132 #else
 133 #define A(a) (1 << CGEN_INSN_/**/a)
 134 #endif
 135 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 136 #define OPERAND(op) IP2K_OPERAND_##op
 137 #else
 138 #define OPERAND(op) IP2K_OPERAND_/**/op
 139 #endif
 140 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
 141 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
 142
 143 /* The instruction table.  */
 144
 145 static const CGEN_OPCODE ip2k_cgen_insn_opcode_table[MAX_INSNS] =
 146 {
 147   /* Special null first entry.
 148      A `num' value of zero is thus invalid.
 149      Also, the special `invalid' insn resides here.  */
 150   { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
 151 /* jmp $addr16cjp */
 152   {
 153     { 0, 0, 0, 0 },
 154     { { MNEM, ' ', OP (ADDR16CJP), 0 } },
 155     & ifmt_jmp, { 0xe000 }
 156   },
 157 /* call $addr16cjp */
 158   {
 159     { 0, 0, 0, 0 },
 160     { { MNEM, ' ', OP (ADDR16CJP), 0 } },
 161     & ifmt_jmp, { 0xc000 }
 162   },
 163 /* sb $fr,$bitno */
 164   {
 165     { 0, 0, 0, 0 },
 166     { { MNEM, ' ', OP (FR), ',', OP (BITNO), 0 } },
 167     & ifmt_sb, { 0xb000 }
 168   },
 169 /* snb $fr,$bitno */
 170   {
 171     { 0, 0, 0, 0 },
 172     { { MNEM, ' ', OP (FR), ',', OP (BITNO), 0 } },
 173     & ifmt_sb, { 0xa000 }
 174   },
 175 /* setb $fr,$bitno */
 176   {
 177     { 0, 0, 0, 0 },
 178     { { MNEM, ' ', OP (FR), ',', OP (BITNO), 0 } },
 179     & ifmt_sb, { 0x9000 }
 180   },
 181 /* clrb $fr,$bitno */
 182   {
 183     { 0, 0, 0, 0 },
 184     { { MNEM, ' ', OP (FR), ',', OP (BITNO), 0 } },
 185     & ifmt_sb, { 0x8000 }
 186   },
 187 /* xor W,#$lit8 */
 188   {
 189     { 0, 0, 0, 0 },
 190     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 191     & ifmt_xorw_l, { 0x7f00 }
 192   },
 193 /* and W,#$lit8 */
 194   {
 195     { 0, 0, 0, 0 },
 196     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 197     & ifmt_xorw_l, { 0x7e00 }
 198   },
 199 /* or W,#$lit8 */
 200   {
 201     { 0, 0, 0, 0 },
 202     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 203     & ifmt_xorw_l, { 0x7d00 }
 204   },
 205 /* add W,#$lit8 */
 206   {
 207     { 0, 0, 0, 0 },
 208     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 209     & ifmt_xorw_l, { 0x7b00 }
 210   },
 211 /* sub W,#$lit8 */
 212   {
 213     { 0, 0, 0, 0 },
 214     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 215     & ifmt_xorw_l, { 0x7a00 }
 216   },
 217 /* cmp W,#$lit8 */
 218   {
 219     { 0, 0, 0, 0 },
 220     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 221     & ifmt_xorw_l, { 0x7900 }
 222   },
 223 /* retw #$lit8 */
 224   {
 225     { 0, 0, 0, 0 },
 226     { { MNEM, ' ', '#', OP (LIT8), 0 } },
 227     & ifmt_xorw_l, { 0x7800 }
 228   },
 229 /* cse W,#$lit8 */
 230   {
 231     { 0, 0, 0, 0 },
 232     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 233     & ifmt_xorw_l, { 0x7700 }
 234   },
 235 /* csne W,#$lit8 */
 236   {
 237     { 0, 0, 0, 0 },
 238     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 239     & ifmt_xorw_l, { 0x7600 }
 240   },
 241 /* push #$lit8 */
 242   {
 243     { 0, 0, 0, 0 },
 244     { { MNEM, ' ', '#', OP (LIT8), 0 } },
 245     & ifmt_xorw_l, { 0x7400 }
 246   },
 247 /* muls W,#$lit8 */
 248   {
 249     { 0, 0, 0, 0 },
 250     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 251     & ifmt_xorw_l, { 0x7300 }
 252   },
 253 /* mulu W,#$lit8 */
 254   {
 255     { 0, 0, 0, 0 },
 256     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 257     & ifmt_xorw_l, { 0x7200 }
 258   },
 259 /* loadl #$lit8 */
 260   {
 261     { 0, 0, 0, 0 },
 262     { { MNEM, ' ', '#', OP (LIT8), 0 } },
 263     & ifmt_xorw_l, { 0x7100 }
 264   },
 265 /* loadh #$lit8 */
 266   {
 267     { 0, 0, 0, 0 },
 268     { { MNEM, ' ', '#', OP (LIT8), 0 } },
 269     & ifmt_xorw_l, { 0x7000 }
 270   },
 271 /* loadl $addr16l */
 272   {
 273     { 0, 0, 0, 0 },
 274     { { MNEM, ' ', OP (ADDR16L), 0 } },
 275     & ifmt_loadl_a, { 0x7100 }
 276   },
 277 /* loadh $addr16h */
 278   {
 279     { 0, 0, 0, 0 },
 280     { { MNEM, ' ', OP (ADDR16H), 0 } },
 281     & ifmt_loadh_a, { 0x7000 }
 282   },
 283 /* addc $fr,W */
 284   {
 285     { 0, 0, 0, 0 },
 286     { { MNEM, ' ', OP (FR), ',', 'W', 0 } },
 287     & ifmt_addcfr_w, { 0x5e00 }
 288   },
 289 /* addc W,$fr */
 290   {
 291     { 0, 0, 0, 0 },
 292     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 293     & ifmt_addcfr_w, { 0x5c00 }
 294   },
 295 /* incsnz $fr */
 296   {
 297     { 0, 0, 0, 0 },
 298     { { MNEM, ' ', OP (FR), 0 } },
 299     & ifmt_addcfr_w, { 0x5a00 }
 300   },
 301 /* incsnz W,$fr */
 302   {
 303     { 0, 0, 0, 0 },
 304     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 305     & ifmt_addcfr_w, { 0x5800 }
 306   },
 307 /* muls W,$fr */
 308   {
 309     { 0, 0, 0, 0 },
 310     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 311     & ifmt_addcfr_w, { 0x5400 }
 312   },
 313 /* mulu W,$fr */
 314   {
 315     { 0, 0, 0, 0 },
 316     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 317     & ifmt_addcfr_w, { 0x5000 }
 318   },
 319 /* decsnz $fr */
 320   {
 321     { 0, 0, 0, 0 },
 322     { { MNEM, ' ', OP (FR), 0 } },
 323     & ifmt_addcfr_w, { 0x4e00 }
 324   },
 325 /* decsnz W,$fr */
 326   {
 327     { 0, 0, 0, 0 },
 328     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 329     & ifmt_addcfr_w, { 0x4c00 }
 330   },
 331 /* subc W,$fr */
 332   {
 333     { 0, 0, 0, 0 },
 334     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 335     & ifmt_addcfr_w, { 0x4800 }
 336   },
 337 /* subc $fr,W */
 338   {
 339     { 0, 0, 0, 0 },
 340     { { MNEM, ' ', OP (FR), ',', 'W', 0 } },
 341     & ifmt_addcfr_w, { 0x4a00 }
 342   },
 343 /* pop $fr */
 344   {
 345     { 0, 0, 0, 0 },
 346     { { MNEM, ' ', OP (FR), 0 } },
 347     & ifmt_addcfr_w, { 0x4600 }
 348   },
 349 /* push $fr */
 350   {
 351     { 0, 0, 0, 0 },
 352     { { MNEM, ' ', OP (FR), 0 } },
 353     & ifmt_addcfr_w, { 0x4400 }
 354   },
 355 /* cse W,$fr */
 356   {
 357     { 0, 0, 0, 0 },
 358     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 359     & ifmt_addcfr_w, { 0x4200 }
 360   },
 361 /* csne W,$fr */
 362   {
 363     { 0, 0, 0, 0 },
 364     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 365     & ifmt_addcfr_w, { 0x4000 }
 366   },
 367 /* incsz $fr */
 368   {
 369     { 0, 0, 0, 0 },
 370     { { MNEM, ' ', OP (FR), 0 } },
 371     & ifmt_addcfr_w, { 0x3e00 }
 372   },
 373 /* incsz W,$fr */
 374   {
 375     { 0, 0, 0, 0 },
 376     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 377     & ifmt_addcfr_w, { 0x3c00 }
 378   },
 379 /* swap $fr */
 380   {
 381     { 0, 0, 0, 0 },
 382     { { MNEM, ' ', OP (FR), 0 } },
 383     & ifmt_addcfr_w, { 0x3a00 }
 384   },
 385 /* swap W,$fr */
 386   {
 387     { 0, 0, 0, 0 },
 388     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 389     & ifmt_addcfr_w, { 0x3800 }
 390   },
 391 /* rl $fr */
 392   {
 393     { 0, 0, 0, 0 },
 394     { { MNEM, ' ', OP (FR), 0 } },
 395     & ifmt_addcfr_w, { 0x3600 }
 396   },
 397 /* rl W,$fr */
 398   {
 399     { 0, 0, 0, 0 },
 400     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 401     & ifmt_addcfr_w, { 0x3400 }
 402   },
 403 /* rr $fr */
 404   {
 405     { 0, 0, 0, 0 },
 406     { { MNEM, ' ', OP (FR), 0 } },
 407     & ifmt_addcfr_w, { 0x3200 }
 408   },
 409 /* rr W,$fr */
 410   {
 411     { 0, 0, 0, 0 },
 412     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 413     & ifmt_addcfr_w, { 0x3000 }
 414   },
 415 /* decsz $fr */
 416   {
 417     { 0, 0, 0, 0 },
 418     { { MNEM, ' ', OP (FR), 0 } },
 419     & ifmt_addcfr_w, { 0x2e00 }
 420   },
 421 /* decsz W,$fr */
 422   {
 423     { 0, 0, 0, 0 },
 424     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 425     & ifmt_addcfr_w, { 0x2c00 }
 426   },
 427 /* inc $fr */
 428   {
 429     { 0, 0, 0, 0 },
 430     { { MNEM, ' ', OP (FR), 0 } },
 431     & ifmt_addcfr_w, { 0x2a00 }
 432   },
 433 /* inc W,$fr */
 434   {
 435     { 0, 0, 0, 0 },
 436     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 437     & ifmt_addcfr_w, { 0x2800 }
 438   },
 439 /* not $fr */
 440   {
 441     { 0, 0, 0, 0 },
 442     { { MNEM, ' ', OP (FR), 0 } },
 443     & ifmt_addcfr_w, { 0x2600 }
 444   },
 445 /* not W,$fr */
 446   {
 447     { 0, 0, 0, 0 },
 448     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 449     & ifmt_addcfr_w, { 0x2400 }
 450   },
 451 /* test $fr */
 452   {
 453     { 0, 0, 0, 0 },
 454     { { MNEM, ' ', OP (FR), 0 } },
 455     & ifmt_addcfr_w, { 0x2200 }
 456   },
 457 /* mov W,#$lit8 */
 458   {
 459     { 0, 0, 0, 0 },
 460     { { MNEM, ' ', 'W', ',', '#', OP (LIT8), 0 } },
 461     & ifmt_xorw_l, { 0x7c00 }
 462   },
 463 /* mov $fr,W */
 464   {
 465     { 0, 0, 0, 0 },
 466     { { MNEM, ' ', OP (FR), ',', 'W', 0 } },
 467     & ifmt_addcfr_w, { 0x200 }
 468   },
 469 /* mov W,$fr */
 470   {
 471     { 0, 0, 0, 0 },
 472     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 473     & ifmt_addcfr_w, { 0x2000 }
 474   },
 475 /* add $fr,W */
 476   {
 477     { 0, 0, 0, 0 },
 478     { { MNEM, ' ', OP (FR), ',', 'W', 0 } },
 479     & ifmt_addcfr_w, { 0x1e00 }
 480   },
 481 /* add W,$fr */
 482   {
 483     { 0, 0, 0, 0 },
 484     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 485     & ifmt_addcfr_w, { 0x1c00 }
 486   },
 487 /* xor $fr,W */
 488   {
 489     { 0, 0, 0, 0 },
 490     { { MNEM, ' ', OP (FR), ',', 'W', 0 } },
 491     & ifmt_addcfr_w, { 0x1a00 }
 492   },
 493 /* xor W,$fr */
 494   {
 495     { 0, 0, 0, 0 },
 496     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 497     & ifmt_addcfr_w, { 0x1800 }
 498   },
 499 /* and $fr,W */
 500   {
 501     { 0, 0, 0, 0 },
 502     { { MNEM, ' ', OP (FR), ',', 'W', 0 } },
 503     & ifmt_addcfr_w, { 0x1600 }
 504   },
 505 /* and W,$fr */
 506   {
 507     { 0, 0, 0, 0 },
 508     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 509     & ifmt_addcfr_w, { 0x1400 }
 510   },
 511 /* or $fr,W */
 512   {
 513     { 0, 0, 0, 0 },
 514     { { MNEM, ' ', OP (FR), ',', 'W', 0 } },
 515     & ifmt_addcfr_w, { 0x1200 }
 516   },
 517 /* or W,$fr */
 518   {
 519     { 0, 0, 0, 0 },
 520     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 521     & ifmt_addcfr_w, { 0x1000 }
 522   },
 523 /* dec $fr */
 524   {
 525     { 0, 0, 0, 0 },
 526     { { MNEM, ' ', OP (FR), 0 } },
 527     & ifmt_addcfr_w, { 0xe00 }
 528   },
 529 /* dec W,$fr */
 530   {
 531     { 0, 0, 0, 0 },
 532     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 533     & ifmt_addcfr_w, { 0xc00 }
 534   },
 535 /* sub $fr,W */
 536   {
 537     { 0, 0, 0, 0 },
 538     { { MNEM, ' ', OP (FR), ',', 'W', 0 } },
 539     & ifmt_addcfr_w, { 0xa00 }
 540   },
 541 /* sub W,$fr */
 542   {
 543     { 0, 0, 0, 0 },
 544     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 545     & ifmt_addcfr_w, { 0x800 }
 546   },
 547 /* clr $fr */
 548   {
 549     { 0, 0, 0, 0 },
 550     { { MNEM, ' ', OP (FR), 0 } },
 551     & ifmt_addcfr_w, { 0x600 }
 552   },
 553 /* cmp W,$fr */
 554   {
 555     { 0, 0, 0, 0 },
 556     { { MNEM, ' ', 'W', ',', OP (FR), 0 } },
 557     & ifmt_addcfr_w, { 0x400 }
 558   },
 559 /* speed #$lit8 */
 560   {
 561     { 0, 0, 0, 0 },
 562     { { MNEM, ' ', '#', OP (LIT8), 0 } },
 563     & ifmt_speed, { 0x100 }
 564   },
 565 /* ireadi */
 566   {
 567     { 0, 0, 0, 0 },
 568     { { MNEM, 0 } },
 569     & ifmt_ireadi, { 0x1d }
 570   },
 571 /* iwritei */
 572   {
 573     { 0, 0, 0, 0 },
 574     { { MNEM, 0 } },
 575     & ifmt_ireadi, { 0x1c }
 576   },
 577 /* fread */
 578   {
 579     { 0, 0, 0, 0 },
 580     { { MNEM, 0 } },
 581     & ifmt_ireadi, { 0x1b }
 582   },
 583 /* fwrite */
 584   {
 585     { 0, 0, 0, 0 },
 586     { { MNEM, 0 } },
 587     & ifmt_ireadi, { 0x1a }
 588   },
 589 /* iread */
 590   {
 591     { 0, 0, 0, 0 },
 592     { { MNEM, 0 } },
 593     & ifmt_ireadi, { 0x19 }
 594   },
 595 /* iwrite */
 596   {
 597     { 0, 0, 0, 0 },
 598     { { MNEM, 0 } },
 599     & ifmt_ireadi, { 0x18 }
 600   },
 601 /* page $addr16p */
 602   {
 603     { 0, 0, 0, 0 },
 604     { { MNEM, ' ', OP (ADDR16P), 0 } },
 605     & ifmt_page, { 0x10 }
 606   },
 607 /* system */
 608   {
 609     { 0, 0, 0, 0 },
 610     { { MNEM, 0 } },
 611     & ifmt_ireadi, { 0xff }
 612   },
 613 /* reti #$reti3 */
 614   {
 615     { 0, 0, 0, 0 },
 616     { { MNEM, ' ', '#', OP (RETI3), 0 } },
 617     & ifmt_reti, { 0x8 }
 618   },
 619 /* ret */
 620   {
 621     { 0, 0, 0, 0 },
 622     { { MNEM, 0 } },
 623     & ifmt_ireadi, { 0x7 }
 624   },
 625 /* int */
 626   {
 627     { 0, 0, 0, 0 },
 628     { { MNEM, 0 } },
 629     & ifmt_ireadi, { 0x6 }
 630   },
 631 /* breakx */
 632   {
 633     { 0, 0, 0, 0 },
 634     { { MNEM, 0 } },
 635     & ifmt_ireadi, { 0x5 }
 636   },
 637 /* cwdt */
 638   {
 639     { 0, 0, 0, 0 },
 640     { { MNEM, 0 } },
 641     & ifmt_ireadi, { 0x4 }
 642   },
 643 /* ferase */
 644   {
 645     { 0, 0, 0, 0 },
 646     { { MNEM, 0 } },
 647     & ifmt_ireadi, { 0x3 }
 648   },
 649 /* retnp */
 650   {
 651     { 0, 0, 0, 0 },
 652     { { MNEM, 0 } },
 653     & ifmt_ireadi, { 0x2 }
 654   },
 655 /* break */
 656   {
 657     { 0, 0, 0, 0 },
 658     { { MNEM, 0 } },
 659     & ifmt_ireadi, { 0x1 }
 660   },
 661 /* nop */
 662   {
 663     { 0, 0, 0, 0 },
 664     { { MNEM, 0 } },
 665     & ifmt_ireadi, { 0x0 }
 666   },
 667 };
 668
 669 #undef A
 670 #undef OPERAND
 671 #undef MNEM
 672 #undef OP
 673
 674 /* Formats for ALIAS macro-insns.  */
 675
 676 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 677 #define F(f) & ip2k_cgen_ifld_table[IP2K_##f]
 678 #else
 679 #define F(f) & ip2k_cgen_ifld_table[IP2K_/**/f]
 680 #endif
 681 static const CGEN_IFMT ifmt_sc ATTRIBUTE_UNUSED = {
 682   16, 16, 0xffff, { { F (F_OP4) }, { F (F_BITNO) }, { F (F_REG) }, { 0 } }
 683 };
 684
 685 static const CGEN_IFMT ifmt_snc ATTRIBUTE_UNUSED = {
 686   16, 16, 0xffff, { { F (F_OP4) }, { F (F_BITNO) }, { F (F_REG) }, { 0 } }
 687 };
 688
 689 static const CGEN_IFMT ifmt_sz ATTRIBUTE_UNUSED = {
 690   16, 16, 0xffff, { { F (F_OP4) }, { F (F_BITNO) }, { F (F_REG) }, { 0 } }
 691 };
 692
 693 static const CGEN_IFMT ifmt_snz ATTRIBUTE_UNUSED = {
 694   16, 16, 0xffff, { { F (F_OP4) }, { F (F_BITNO) }, { F (F_REG) }, { 0 } }
 695 };
 696
 697 static const CGEN_IFMT ifmt_skip ATTRIBUTE_UNUSED = {
 698   16, 16, 0xffff, { { F (F_OP4) }, { F (F_BITNO) }, { F (F_REG) }, { 0 } }
 699 };
 700
 701 static const CGEN_IFMT ifmt_skipb ATTRIBUTE_UNUSED = {
 702   16, 16, 0xffff, { { F (F_OP4) }, { F (F_BITNO) }, { F (F_REG) }, { 0 } }
 703 };
 704
 705 #undef F
 706
 707 /* Each non-simple macro entry points to an array of expansion possibilities.  */
 708
 709 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 710 #define A(a) (1 << CGEN_INSN_##a)
 711 #else
 712 #define A(a) (1 << CGEN_INSN_/**/a)
 713 #endif
 714 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 715 #define OPERAND(op) IP2K_OPERAND_##op
 716 #else
 717 #define OPERAND(op) IP2K_OPERAND_/**/op
 718 #endif
 719 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
 720 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
 721
 722 /* The macro instruction table.  */
 723
 724 static const CGEN_IBASE ip2k_cgen_macro_insn_table[] =
 725 {
 726 /* sc */
 727   {
 728     -1, "sc", "sc", 16,
 729     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 730   },
 731 /* snc */
 732   {
 733     -1, "snc", "snc", 16,
 734     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 735   },
 736 /* sz */
 737   {
 738     -1, "sz", "sz", 16,
 739     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 740   },
 741 /* snz */
 742   {
 743     -1, "snz", "snz", 16,
 744     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 745   },
 746 /* skip */
 747   {
 748     -1, "skip", "skip", 16,
 749     { 0|A(SKIPA)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 750   },
 751 /* skip */
 752   {
 753     -1, "skipb", "skip", 16,
 754     { 0|A(SKIPA)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 755   },
 756 };
 757
 758 /* The macro instruction opcode table.  */
 759
 760 static const CGEN_OPCODE ip2k_cgen_macro_insn_opcode_table[] =
 761 {
 762 /* sc */
 763   {
 764     { 0, 0, 0, 0 },
 765     { { MNEM, 0 } },
 766     & ifmt_sc, { 0xb00b }
 767   },
 768 /* snc */
 769   {
 770     { 0, 0, 0, 0 },
 771     { { MNEM, 0 } },
 772     & ifmt_snc, { 0xa00b }
 773   },
 774 /* sz */
 775   {
 776     { 0, 0, 0, 0 },
 777     { { MNEM, 0 } },
 778     & ifmt_sz, { 0xb40b }
 779   },
 780 /* snz */
 781   {
 782     { 0, 0, 0, 0 },
 783     { { MNEM, 0 } },
 784     & ifmt_snz, { 0xa40b }
 785   },
 786 /* skip */
 787   {
 788     { 0, 0, 0, 0 },
 789     { { MNEM, 0 } },
 790     & ifmt_skip, { 0xa009 }
 791   },
 792 /* skip */
 793   {
 794     { 0, 0, 0, 0 },
 795     { { MNEM, 0 } },
 796     & ifmt_skipb, { 0xb009 }
 797   },
 798 };
 799
 800 #undef A
 801 #undef OPERAND
 802 #undef MNEM
 803 #undef OP
 804
 805 #ifndef CGEN_ASM_HASH_P
 806 #define CGEN_ASM_HASH_P(insn) 1
 807 #endif
 808
 809 #ifndef CGEN_DIS_HASH_P
 810 #define CGEN_DIS_HASH_P(insn) 1
 811 #endif
 812
 813 /* Return non-zero if INSN is to be added to the hash table.
 814    Targets are free to override CGEN_{ASM,DIS}_HASH_P in the .opc file.  */
 815
 816 static int
 817 asm_hash_insn_p (insn)
 818      const CGEN_INSN *insn ATTRIBUTE_UNUSED;
 819 {
 820   return CGEN_ASM_HASH_P (insn);
 821 }
 822
 823 static int
 824 dis_hash_insn_p (insn)
 825      const CGEN_INSN *insn;
 826 {
 827   /* If building the hash table and the NO-DIS attribute is present,
 828      ignore.  */
 829   if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_NO_DIS))
 830     return 0;
 831   return CGEN_DIS_HASH_P (insn);
 832 }
 833
 834 #ifndef CGEN_ASM_HASH
 835 #define CGEN_ASM_HASH_SIZE 127
 836 #ifdef CGEN_MNEMONIC_OPERANDS
 837 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE)
 838 #else
 839 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE) /*FIXME*/
 840 #endif
 841 #endif
 842
 843 /* It doesn't make much sense to provide a default here,
 844    but while this is under development we do.
 845    BUFFER is a pointer to the bytes of the insn, target order.
 846    VALUE is the first base_insn_bitsize bits as an int in host order.  */
 847
 848 #ifndef CGEN_DIS_HASH
 849 #define CGEN_DIS_HASH_SIZE 256
 850 #define CGEN_DIS_HASH(buf, value) (*(unsigned char *) (buf))
 851 #endif
 852
 853 /* The result is the hash value of the insn.
 854    Targets are free to override CGEN_{ASM,DIS}_HASH in the .opc file.  */
 855
 856 static unsigned int
 857 asm_hash_insn (mnem)
 858      const char * mnem;
 859 {
 860   return CGEN_ASM_HASH (mnem);
 861 }
 862
 863 /* BUF is a pointer to the bytes of the insn, target order.
 864    VALUE is the first base_insn_bitsize bits as an int in host order.  */
 865
 866 static unsigned int
 867 dis_hash_insn (buf, value)
 868      const char * buf ATTRIBUTE_UNUSED;
 869      CGEN_INSN_INT value ATTRIBUTE_UNUSED;
 870 {
 871   return CGEN_DIS_HASH (buf, value);
 872 }
 873
 874 /* Set the recorded length of the insn in the CGEN_FIELDS struct.  */
 875
 876 static void
 877 set_fields_bitsize (CGEN_FIELDS *fields, int size)
 878 {
 879   CGEN_FIELDS_BITSIZE (fields) = size;
 880 }
 881
 882 /* Function to call before using the operand instance table.
 883    This plugs the opcode entries and macro instructions into the cpu table.  */
 884
 885 void
 886 ip2k_cgen_init_opcode_table (CGEN_CPU_DESC cd)
 887 {
 888   int i;
 889   int num_macros = (sizeof (ip2k_cgen_macro_insn_table) /
 890                     sizeof (ip2k_cgen_macro_insn_table[0]));
 891   const CGEN_IBASE *ib = & ip2k_cgen_macro_insn_table[0];
 892   const CGEN_OPCODE *oc = & ip2k_cgen_macro_insn_opcode_table[0];
 893   CGEN_INSN *insns = xmalloc (num_macros * sizeof (CGEN_INSN));
 894
 895   memset (insns, 0, num_macros * sizeof (CGEN_INSN));
 896   for (i = 0; i < num_macros; ++i)
 897     {
 898       insns[i].base = &ib[i];
 899       insns[i].opcode = &oc[i];
 900       ip2k_cgen_build_insn_regex (& insns[i]);
 901     }
 902   cd->macro_insn_table.init_entries = insns;
 903   cd->macro_insn_table.entry_size = sizeof (CGEN_IBASE);
 904   cd->macro_insn_table.num_init_entries = num_macros;
 905
 906   oc = & ip2k_cgen_insn_opcode_table[0];
 907   insns = (CGEN_INSN *) cd->insn_table.init_entries;
 908   for (i = 0; i < MAX_INSNS; ++i)
 909     {
 910       insns[i].opcode = &oc[i];
 911       ip2k_cgen_build_insn_regex (& insns[i]);
 912     }
 913
 914   cd->sizeof_fields = sizeof (CGEN_FIELDS);
 915   cd->set_fields_bitsize = set_fields_bitsize;
 916
 917   cd->asm_hash_p = asm_hash_insn_p;
 918   cd->asm_hash = asm_hash_insn;
 919   cd->asm_hash_size = CGEN_ASM_HASH_SIZE;
 920
 921   cd->dis_hash_p = dis_hash_insn_p;
 922   cd->dis_hash = dis_hash_insn;
 923   cd->dis_hash_size = CGEN_DIS_HASH_SIZE;
 924 }