opcodes/iq2000-ibld.c

   1 /* Instruction building/extraction support for iq2000. -*- C -*-
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
   4 - the resultant file is machine generated, cgen-ibld.in isn't
   5
   6 Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   7
   8 This file is part of the GNU Binutils and GDB, the GNU debugger.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2, or (at your option)
  13 any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program; if not, write to the Free Software Foundation, Inc.,
  22 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
  25    Keep that in mind.  */
  26
  27 #include "sysdep.h"
  28 #include <stdio.h>
  29 #include "ansidecl.h"
  30 #include "dis-asm.h"
  31 #include "bfd.h"
  32 #include "symcat.h"
  33 #include "iq2000-desc.h"
  34 #include "iq2000-opc.h"
  35 #include "opintl.h"
  36 #include "safe-ctype.h"
  37
  38 #undef min
  39 #define min(a,b) ((a) < (b) ? (a) : (b))
  40 #undef max
  41 #define max(a,b) ((a) > (b) ? (a) : (b))
  42
  43 /* Used by the ifield rtx function.  */
  44 #define FLD(f) (fields->f)
  45
  46 static const char * insert_normal
  47      PARAMS ((CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int,
  48               unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR));
  49 static const char * insert_insn_normal
  50      PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *,
  51               CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
  52 static int extract_normal
  53      PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
  54               unsigned int, unsigned int, unsigned int, unsigned int,
  55               unsigned int, unsigned int, bfd_vma, long *));
  56 static int extract_insn_normal
  57      PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
  58               CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma));
  59 #if CGEN_INT_INSN_P
  60 static void put_insn_int_value
  61      PARAMS ((CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT));
  62 #endif
  63 #if ! CGEN_INT_INSN_P
  64 static CGEN_INLINE void insert_1
  65      PARAMS ((CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *));
  66 static CGEN_INLINE int fill_cache
  67      PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *,  int, int, bfd_vma));
  68 static CGEN_INLINE long extract_1
  69      PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int,
  70               unsigned char *, bfd_vma));
  71 #endif
  72 \f
  73 /* Operand insertion.  */
  74
  75 #if ! CGEN_INT_INSN_P
  76
  77 /* Subroutine of insert_normal.  */
  78
  79 static CGEN_INLINE void
  80 insert_1 (cd, value, start, length, word_length, bufp)
  81      CGEN_CPU_DESC cd;
  82      unsigned long value;
  83      int start,length,word_length;
  84      unsigned char *bufp;
  85 {
  86   unsigned long x,mask;
  87   int shift;
  88
  89   x = cgen_get_insn_value (cd, bufp, word_length);
  90
  91   /* Written this way to avoid undefined behaviour.  */
  92   mask = (((1L << (length - 1)) - 1) << 1) | 1;
  93   if (CGEN_INSN_LSB0_P)
  94     shift = (start + 1) - length;
  95   else
  96     shift = (word_length - (start + length));
  97   x = (x & ~(mask << shift)) | ((value & mask) << shift);
  98
  99   cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x);
 100 }
 101
 102 #endif /* ! CGEN_INT_INSN_P */
 103
 104 /* Default insertion routine.
 105
 106    ATTRS is a mask of the boolean attributes.
 107    WORD_OFFSET is the offset in bits from the start of the insn of the value.
 108    WORD_LENGTH is the length of the word in bits in which the value resides.
 109    START is the starting bit number in the word, architecture origin.
 110    LENGTH is the length of VALUE in bits.
 111    TOTAL_LENGTH is the total length of the insn in bits.
 112
 113    The result is an error message or NULL if success.  */
 114
 115 /* ??? This duplicates functionality with bfd's howto table and
 116    bfd_install_relocation.  */
 117 /* ??? This doesn't handle bfd_vma's.  Create another function when
 118    necessary.  */
 119
 120 static const char *
 121 insert_normal (cd, value, attrs, word_offset, start, length, word_length,
 122                total_length, buffer)
 123      CGEN_CPU_DESC cd;
 124      long value;
 125      unsigned int attrs;
 126      unsigned int word_offset, start, length, word_length, total_length;
 127      CGEN_INSN_BYTES_PTR buffer;
 128 {
 129   static char errbuf[100];
 130   /* Written this way to avoid undefined behaviour.  */
 131   unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
 132
 133   /* If LENGTH is zero, this operand doesn't contribute to the value.  */
 134   if (length == 0)
 135     return NULL;
 136
 137 #if 0
 138   if (CGEN_INT_INSN_P
 139       && word_offset != 0)
 140     abort ();
 141 #endif
 142
 143   if (word_length > 32)
 144     abort ();
 145
 146   /* For architectures with insns smaller than the base-insn-bitsize,
 147      word_length may be too big.  */
 148   if (cd->min_insn_bitsize < cd->base_insn_bitsize)
 149     {
 150       if (word_offset == 0
 151           && word_length > total_length)
 152         word_length = total_length;
 153     }
 154
 155   /* Ensure VALUE will fit.  */
 156   if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
 157     {
 158       long minval = - (1L << (length - 1));
 159       unsigned long maxval = mask;
 160
 161       if ((value > 0 && (unsigned long) value > maxval)
 162           || value < minval)
 163         {
 164           /* xgettext:c-format */
 165           sprintf (errbuf,
 166                    _("operand out of range (%ld not between %ld and %lu)"),
 167                    value, minval, maxval);
 168           return errbuf;
 169         }
 170     }
 171   else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
 172     {
 173       unsigned long maxval = mask;
 174
 175       if ((unsigned long) value > maxval)
 176         {
 177           /* xgettext:c-format */
 178           sprintf (errbuf,
 179                    _("operand out of range (%lu not between 0 and %lu)"),
 180                    value, maxval);
 181           return errbuf;
 182         }
 183     }
 184   else
 185     {
 186       if (! cgen_signed_overflow_ok_p (cd))
 187         {
 188           long minval = - (1L << (length - 1));
 189           long maxval =   (1L << (length - 1)) - 1;
 190
 191           if (value < minval || value > maxval)
 192             {
 193               sprintf
 194                 /* xgettext:c-format */
 195                 (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
 196                  value, minval, maxval);
 197               return errbuf;
 198             }
 199         }
 200     }
 201
 202 #if CGEN_INT_INSN_P
 203
 204   {
 205     int shift;
 206
 207     if (CGEN_INSN_LSB0_P)
 208       shift = (word_offset + start + 1) - length;
 209     else
 210       shift = total_length - (word_offset + start + length);
 211     *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
 212   }
 213
 214 #else /* ! CGEN_INT_INSN_P */
 215
 216   {
 217     unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
 218
 219     insert_1 (cd, value, start, length, word_length, bufp);
 220   }
 221
 222 #endif /* ! CGEN_INT_INSN_P */
 223
 224   return NULL;
 225 }
 226
 227 /* Default insn builder (insert handler).
 228    The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
 229    that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
 230    recorded in host byte order, otherwise BUFFER is an array of bytes
 231    and the value is recorded in target byte order).
 232    The result is an error message or NULL if success.  */
 233
 234 static const char *
 235 insert_insn_normal (cd, insn, fields, buffer, pc)
 236      CGEN_CPU_DESC cd;
 237      const CGEN_INSN * insn;
 238      CGEN_FIELDS * fields;
 239      CGEN_INSN_BYTES_PTR buffer;
 240      bfd_vma pc;
 241 {
 242   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
 243   unsigned long value;
 244   const CGEN_SYNTAX_CHAR_TYPE * syn;
 245
 246   CGEN_INIT_INSERT (cd);
 247   value = CGEN_INSN_BASE_VALUE (insn);
 248
 249   /* If we're recording insns as numbers (rather than a string of bytes),
 250      target byte order handling is deferred until later.  */
 251
 252 #if CGEN_INT_INSN_P
 253
 254   put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
 255                       CGEN_FIELDS_BITSIZE (fields), value);
 256
 257 #else
 258
 259   cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
 260                                         (unsigned) CGEN_FIELDS_BITSIZE (fields)),
 261                        value);
 262
 263 #endif /* ! CGEN_INT_INSN_P */
 264
 265   /* ??? It would be better to scan the format's fields.
 266      Still need to be able to insert a value based on the operand though;
 267      e.g. storing a branch displacement that got resolved later.
 268      Needs more thought first.  */
 269
 270   for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
 271     {
 272       const char *errmsg;
 273
 274       if (CGEN_SYNTAX_CHAR_P (* syn))
 275         continue;
 276
 277       errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
 278                                        fields, buffer, pc);
 279       if (errmsg)
 280         return errmsg;
 281     }
 282
 283   return NULL;
 284 }
 285
 286 #if CGEN_INT_INSN_P
 287 /* Cover function to store an insn value into an integral insn.  Must go here
 288  because it needs <prefix>-desc.h for CGEN_INT_INSN_P.  */
 289
 290 static void
 291 put_insn_int_value (cd, buf, length, insn_length, value)
 292      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
 293      CGEN_INSN_BYTES_PTR buf;
 294      int length;
 295      int insn_length;
 296      CGEN_INSN_INT value;
 297 {
 298   /* For architectures with insns smaller than the base-insn-bitsize,
 299      length may be too big.  */
 300   if (length > insn_length)
 301     *buf = value;
 302   else
 303     {
 304       int shift = insn_length - length;
 305       /* Written this way to avoid undefined behaviour.  */
 306       CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
 307       *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
 308     }
 309 }
 310 #endif
 311 \f
 312 /* Operand extraction.  */
 313
 314 #if ! CGEN_INT_INSN_P
 315
 316 /* Subroutine of extract_normal.
 317    Ensure sufficient bytes are cached in EX_INFO.
 318    OFFSET is the offset in bytes from the start of the insn of the value.
 319    BYTES is the length of the needed value.
 320    Returns 1 for success, 0 for failure.  */
 321
 322 static CGEN_INLINE int
 323 fill_cache (cd, ex_info, offset, bytes, pc)
 324      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
 325      CGEN_EXTRACT_INFO *ex_info;
 326      int offset, bytes;
 327      bfd_vma pc;
 328 {
 329   /* It's doubtful that the middle part has already been fetched so
 330      we don't optimize that case.  kiss.  */
 331   unsigned int mask;
 332   disassemble_info *info = (disassemble_info *) ex_info->dis_info;
 333
 334   /* First do a quick check.  */
 335   mask = (1 << bytes) - 1;
 336   if (((ex_info->valid >> offset) & mask) == mask)
 337     return 1;
 338
 339   /* Search for the first byte we need to read.  */
 340   for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
 341     if (! (mask & ex_info->valid))
 342       break;
 343
 344   if (bytes)
 345     {
 346       int status;
 347
 348       pc += offset;
 349       status = (*info->read_memory_func)
 350         (pc, ex_info->insn_bytes + offset, bytes, info);
 351
 352       if (status != 0)
 353         {
 354           (*info->memory_error_func) (status, pc, info);
 355           return 0;
 356         }
 357
 358       ex_info->valid |= ((1 << bytes) - 1) << offset;
 359     }
 360
 361   return 1;
 362 }
 363
 364 /* Subroutine of extract_normal.  */
 365
 366 static CGEN_INLINE long
 367 extract_1 (cd, ex_info, start, length, word_length, bufp, pc)
 368      CGEN_CPU_DESC cd;
 369      CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED;
 370      int start,length,word_length;
 371      unsigned char *bufp;
 372      bfd_vma pc ATTRIBUTE_UNUSED;
 373 {
 374   unsigned long x;
 375   int shift;
 376 #if 0
 377   int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
 378 #endif
 379   x = cgen_get_insn_value (cd, bufp, word_length);
 380
 381   if (CGEN_INSN_LSB0_P)
 382     shift = (start + 1) - length;
 383   else
 384     shift = (word_length - (start + length));
 385   return x >> shift;
 386 }
 387
 388 #endif /* ! CGEN_INT_INSN_P */
 389
 390 /* Default extraction routine.
 391
 392    INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
 393    or sometimes less for cases like the m32r where the base insn size is 32
 394    but some insns are 16 bits.
 395    ATTRS is a mask of the boolean attributes.  We only need `SIGNED',
 396    but for generality we take a bitmask of all of them.
 397    WORD_OFFSET is the offset in bits from the start of the insn of the value.
 398    WORD_LENGTH is the length of the word in bits in which the value resides.
 399    START is the starting bit number in the word, architecture origin.
 400    LENGTH is the length of VALUE in bits.
 401    TOTAL_LENGTH is the total length of the insn in bits.
 402
 403    Returns 1 for success, 0 for failure.  */
 404
 405 /* ??? The return code isn't properly used.  wip.  */
 406
 407 /* ??? This doesn't handle bfd_vma's.  Create another function when
 408    necessary.  */
 409
 410 static int
 411 extract_normal (cd, ex_info, insn_value, attrs, word_offset, start, length,
 412                 word_length, total_length, pc, valuep)
 413      CGEN_CPU_DESC cd;
 414 #if ! CGEN_INT_INSN_P
 415      CGEN_EXTRACT_INFO *ex_info;
 416 #else
 417      CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED;
 418 #endif
 419      CGEN_INSN_INT insn_value;
 420      unsigned int attrs;
 421      unsigned int word_offset, start, length, word_length, total_length;
 422 #if ! CGEN_INT_INSN_P
 423      bfd_vma pc;
 424 #else
 425      bfd_vma pc ATTRIBUTE_UNUSED;
 426 #endif
 427      long *valuep;
 428 {
 429   long value, mask;
 430
 431   /* If LENGTH is zero, this operand doesn't contribute to the value
 432      so give it a standard value of zero.  */
 433   if (length == 0)
 434     {
 435       *valuep = 0;
 436       return 1;
 437     }
 438
 439 #if 0
 440   if (CGEN_INT_INSN_P
 441       && word_offset != 0)
 442     abort ();
 443 #endif
 444
 445   if (word_length > 32)
 446     abort ();
 447
 448   /* For architectures with insns smaller than the insn-base-bitsize,
 449      word_length may be too big.  */
 450   if (cd->min_insn_bitsize < cd->base_insn_bitsize)
 451     {
 452       if (word_offset == 0
 453           && word_length > total_length)
 454         word_length = total_length;
 455     }
 456
 457   /* Does the value reside in INSN_VALUE, and at the right alignment?  */
 458
 459   if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
 460     {
 461       if (CGEN_INSN_LSB0_P)
 462         value = insn_value >> ((word_offset + start + 1) - length);
 463       else
 464         value = insn_value >> (total_length - ( word_offset + start + length));
 465     }
 466
 467 #if ! CGEN_INT_INSN_P
 468
 469   else
 470     {
 471       unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
 472
 473       if (word_length > 32)
 474         abort ();
 475
 476       if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
 477         return 0;
 478
 479       value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
 480     }
 481
 482 #endif /* ! CGEN_INT_INSN_P */
 483
 484   /* Written this way to avoid undefined behaviour.  */
 485   mask = (((1L << (length - 1)) - 1) << 1) | 1;
 486
 487   value &= mask;
 488   /* sign extend? */
 489   if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
 490       && (value & (1L << (length - 1))))
 491     value |= ~mask;
 492
 493   *valuep = value;
 494
 495   return 1;
 496 }
 497
 498 /* Default insn extractor.
 499
 500    INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
 501    The extracted fields are stored in FIELDS.
 502    EX_INFO is used to handle reading variable length insns.
 503    Return the length of the insn in bits, or 0 if no match,
 504    or -1 if an error occurs fetching data (memory_error_func will have
 505    been called).  */
 506
 507 static int
 508 extract_insn_normal (cd, insn, ex_info, insn_value, fields, pc)
 509      CGEN_CPU_DESC cd;
 510      const CGEN_INSN *insn;
 511      CGEN_EXTRACT_INFO *ex_info;
 512      CGEN_INSN_INT insn_value;
 513      CGEN_FIELDS *fields;
 514      bfd_vma pc;
 515 {
 516   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
 517   const CGEN_SYNTAX_CHAR_TYPE *syn;
 518
 519   CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
 520
 521   CGEN_INIT_EXTRACT (cd);
 522
 523   for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
 524     {
 525       int length;
 526
 527       if (CGEN_SYNTAX_CHAR_P (*syn))
 528         continue;
 529
 530       length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
 531                                         ex_info, insn_value, fields, pc);
 532       if (length <= 0)
 533         return length;
 534     }
 535
 536   /* We recognized and successfully extracted this insn.  */
 537   return CGEN_INSN_BITSIZE (insn);
 538 }
 539 \f
 540 /* machine generated code added here */
 541
 542 const char * iq2000_cgen_insert_operand
 543   PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
 544
 545 /* Main entry point for operand insertion.
 546
 547    This function is basically just a big switch statement.  Earlier versions
 548    used tables to look up the function to use, but
 549    - if the table contains both assembler and disassembler functions then
 550      the disassembler contains much of the assembler and vice-versa,
 551    - there's a lot of inlining possibilities as things grow,
 552    - using a switch statement avoids the function call overhead.
 553
 554    This function could be moved into `parse_insn_normal', but keeping it
 555    separate makes clear the interface between `parse_insn_normal' and each of
 556    the handlers.  It's also needed by GAS to insert operands that couldn't be
 557    resolved during parsing.  */
 558
 559 const char *
 560 iq2000_cgen_insert_operand (cd, opindex, fields, buffer, pc)
 561      CGEN_CPU_DESC cd;
 562      int opindex;
 563      CGEN_FIELDS * fields;
 564      CGEN_INSN_BYTES_PTR buffer;
 565      bfd_vma pc ATTRIBUTE_UNUSED;
 566 {
 567   const char * errmsg = NULL;
 568   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 569
 570   switch (opindex)
 571     {
 572     case IQ2000_OPERAND_BASE :
 573       errmsg = insert_normal (cd, fields->f_rs, 0, 0, 25, 5, 32, total_length, buffer);
 574       break;
 575     case IQ2000_OPERAND_BASEOFF :
 576       errmsg = insert_normal (cd, fields->f_imm, 0, 0, 15, 16, 32, total_length, buffer);
 577       break;
 578     case IQ2000_OPERAND_BITNUM :
 579       errmsg = insert_normal (cd, fields->f_rt, 0, 0, 20, 5, 32, total_length, buffer);
 580       break;
 581     case IQ2000_OPERAND_BYTECOUNT :
 582       errmsg = insert_normal (cd, fields->f_bytecount, 0, 0, 7, 8, 32, total_length, buffer);
 583       break;
 584     case IQ2000_OPERAND_CAM_Y :
 585       errmsg = insert_normal (cd, fields->f_cam_y, 0, 0, 2, 3, 32, total_length, buffer);
 586       break;
 587     case IQ2000_OPERAND_CAM_Z :
 588       errmsg = insert_normal (cd, fields->f_cam_z, 0, 0, 5, 3, 32, total_length, buffer);
 589       break;
 590     case IQ2000_OPERAND_CM_3FUNC :
 591       errmsg = insert_normal (cd, fields->f_cm_3func, 0, 0, 5, 3, 32, total_length, buffer);
 592       break;
 593     case IQ2000_OPERAND_CM_3Z :
 594       errmsg = insert_normal (cd, fields->f_cm_3z, 0, 0, 1, 2, 32, total_length, buffer);
 595       break;
 596     case IQ2000_OPERAND_CM_4FUNC :
 597       errmsg = insert_normal (cd, fields->f_cm_4func, 0, 0, 5, 4, 32, total_length, buffer);
 598       break;
 599     case IQ2000_OPERAND_CM_4Z :
 600       errmsg = insert_normal (cd, fields->f_cm_4z, 0, 0, 2, 3, 32, total_length, buffer);
 601       break;
 602     case IQ2000_OPERAND_COUNT :
 603       errmsg = insert_normal (cd, fields->f_count, 0, 0, 15, 7, 32, total_length, buffer);
 604       break;
 605     case IQ2000_OPERAND_EXECODE :
 606       errmsg = insert_normal (cd, fields->f_excode, 0, 0, 25, 20, 32, total_length, buffer);
 607       break;
 608     case IQ2000_OPERAND_F_INDEX :
 609       errmsg = insert_normal (cd, fields->f_index, 0, 0, 8, 9, 32, total_length, buffer);
 610       break;
 611     case IQ2000_OPERAND_HI16 :
 612       errmsg = insert_normal (cd, fields->f_imm, 0, 0, 15, 16, 32, total_length, buffer);
 613       break;
 614     case IQ2000_OPERAND_IMM :
 615       errmsg = insert_normal (cd, fields->f_imm, 0, 0, 15, 16, 32, total_length, buffer);
 616       break;
 617     case IQ2000_OPERAND_JMPTARG :
 618       {
 619         long value = fields->f_jtarg;
 620         value = ((unsigned int) (((value) & (262143))) >> (2));
 621         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 15, 16, 32, total_length, buffer);
 622       }
 623       break;
 624     case IQ2000_OPERAND_JMPTARGQ10 :
 625       {
 626         long value = fields->f_jtargq10;
 627         value = ((unsigned int) (((value) & (8388607))) >> (2));
 628         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 20, 21, 32, total_length, buffer);
 629       }
 630       break;
 631     case IQ2000_OPERAND_LO16 :
 632       errmsg = insert_normal (cd, fields->f_imm, 0, 0, 15, 16, 32, total_length, buffer);
 633       break;
 634     case IQ2000_OPERAND_MASK :
 635       errmsg = insert_normal (cd, fields->f_mask, 0, 0, 9, 4, 32, total_length, buffer);
 636       break;
 637     case IQ2000_OPERAND_MASKL :
 638       errmsg = insert_normal (cd, fields->f_maskl, 0, 0, 4, 5, 32, total_length, buffer);
 639       break;
 640     case IQ2000_OPERAND_MASKQ10 :
 641       errmsg = insert_normal (cd, fields->f_maskq10, 0, 0, 10, 5, 32, total_length, buffer);
 642       break;
 643     case IQ2000_OPERAND_MASKR :
 644       errmsg = insert_normal (cd, fields->f_rs, 0, 0, 25, 5, 32, total_length, buffer);
 645       break;
 646     case IQ2000_OPERAND_MLO16 :
 647       errmsg = insert_normal (cd, fields->f_imm, 0, 0, 15, 16, 32, total_length, buffer);
 648       break;
 649     case IQ2000_OPERAND_OFFSET :
 650       {
 651         long value = fields->f_offset;
 652         value = ((int) (((value) - (pc))) >> (2));
 653         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, buffer);
 654       }
 655       break;
 656     case IQ2000_OPERAND_RD :
 657       errmsg = insert_normal (cd, fields->f_rd, 0, 0, 15, 5, 32, total_length, buffer);
 658       break;
 659     case IQ2000_OPERAND_RD_RS :
 660       {
 661 {
 662   FLD (f_rd) = FLD (f_rd_rs);
 663   FLD (f_rs) = FLD (f_rd_rs);
 664 }
 665         errmsg = insert_normal (cd, fields->f_rd, 0, 0, 15, 5, 32, total_length, buffer);
 666         if (errmsg)
 667           break;
 668         errmsg = insert_normal (cd, fields->f_rs, 0, 0, 25, 5, 32, total_length, buffer);
 669         if (errmsg)
 670           break;
 671       }
 672       break;
 673     case IQ2000_OPERAND_RD_RT :
 674       {
 675 {
 676   FLD (f_rd) = FLD (f_rd_rt);
 677   FLD (f_rt) = FLD (f_rd_rt);
 678 }
 679         errmsg = insert_normal (cd, fields->f_rd, 0, 0, 15, 5, 32, total_length, buffer);
 680         if (errmsg)
 681           break;
 682         errmsg = insert_normal (cd, fields->f_rt, 0, 0, 20, 5, 32, total_length, buffer);
 683         if (errmsg)
 684           break;
 685       }
 686       break;
 687     case IQ2000_OPERAND_RS :
 688       errmsg = insert_normal (cd, fields->f_rs, 0, 0, 25, 5, 32, total_length, buffer);
 689       break;
 690     case IQ2000_OPERAND_RT :
 691       errmsg = insert_normal (cd, fields->f_rt, 0, 0, 20, 5, 32, total_length, buffer);
 692       break;
 693     case IQ2000_OPERAND_RT_RS :
 694       {
 695 {
 696   FLD (f_rt) = FLD (f_rt_rs);
 697   FLD (f_rs) = FLD (f_rt_rs);
 698 }
 699         errmsg = insert_normal (cd, fields->f_rt, 0, 0, 20, 5, 32, total_length, buffer);
 700         if (errmsg)
 701           break;
 702         errmsg = insert_normal (cd, fields->f_rs, 0, 0, 25, 5, 32, total_length, buffer);
 703         if (errmsg)
 704           break;
 705       }
 706       break;
 707     case IQ2000_OPERAND_SHAMT :
 708       errmsg = insert_normal (cd, fields->f_shamt, 0, 0, 10, 5, 32, total_length, buffer);
 709       break;
 710
 711     default :
 712       /* xgettext:c-format */
 713       fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
 714                opindex);
 715       abort ();
 716   }
 717
 718   return errmsg;
 719 }
 720
 721 int iq2000_cgen_extract_operand
 722   PARAMS ((CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
 723            CGEN_FIELDS *, bfd_vma));
 724
 725 /* Main entry point for operand extraction.
 726    The result is <= 0 for error, >0 for success.
 727    ??? Actual values aren't well defined right now.
 728
 729    This function is basically just a big switch statement.  Earlier versions
 730    used tables to look up the function to use, but
 731    - if the table contains both assembler and disassembler functions then
 732      the disassembler contains much of the assembler and vice-versa,
 733    - there's a lot of inlining possibilities as things grow,
 734    - using a switch statement avoids the function call overhead.
 735
 736    This function could be moved into `print_insn_normal', but keeping it
 737    separate makes clear the interface between `print_insn_normal' and each of
 738    the handlers.  */
 739
 740 int
 741 iq2000_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
 742      CGEN_CPU_DESC cd;
 743      int opindex;
 744      CGEN_EXTRACT_INFO *ex_info;
 745      CGEN_INSN_INT insn_value;
 746      CGEN_FIELDS * fields;
 747      bfd_vma pc;
 748 {
 749   /* Assume success (for those operands that are nops).  */
 750   int length = 1;
 751   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 752
 753   switch (opindex)
 754     {
 755     case IQ2000_OPERAND_BASE :
 756       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 5, 32, total_length, pc, & fields->f_rs);
 757       break;
 758     case IQ2000_OPERAND_BASEOFF :
 759       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_imm);
 760       break;
 761     case IQ2000_OPERAND_BITNUM :
 762       length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_rt);
 763       break;
 764     case IQ2000_OPERAND_BYTECOUNT :
 765       length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 32, total_length, pc, & fields->f_bytecount);
 766       break;
 767     case IQ2000_OPERAND_CAM_Y :
 768       length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 32, total_length, pc, & fields->f_cam_y);
 769       break;
 770     case IQ2000_OPERAND_CAM_Z :
 771       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_cam_z);
 772       break;
 773     case IQ2000_OPERAND_CM_3FUNC :
 774       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_cm_3func);
 775       break;
 776     case IQ2000_OPERAND_CM_3Z :
 777       length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_cm_3z);
 778       break;
 779     case IQ2000_OPERAND_CM_4FUNC :
 780       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 4, 32, total_length, pc, & fields->f_cm_4func);
 781       break;
 782     case IQ2000_OPERAND_CM_4Z :
 783       length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 32, total_length, pc, & fields->f_cm_4z);
 784       break;
 785     case IQ2000_OPERAND_COUNT :
 786       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 7, 32, total_length, pc, & fields->f_count);
 787       break;
 788     case IQ2000_OPERAND_EXECODE :
 789       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 20, 32, total_length, pc, & fields->f_excode);
 790       break;
 791     case IQ2000_OPERAND_F_INDEX :
 792       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 9, 32, total_length, pc, & fields->f_index);
 793       break;
 794     case IQ2000_OPERAND_HI16 :
 795       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_imm);
 796       break;
 797     case IQ2000_OPERAND_IMM :
 798       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_imm);
 799       break;
 800     case IQ2000_OPERAND_JMPTARG :
 801       {
 802         long value;
 803         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 15, 16, 32, total_length, pc, & value);
 804         value = ((((pc) & (0xf0000000))) | (((value) << (2))));
 805         fields->f_jtarg = value;
 806       }
 807       break;
 808     case IQ2000_OPERAND_JMPTARGQ10 :
 809       {
 810         long value;
 811         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 20, 21, 32, total_length, pc, & value);
 812         value = ((((pc) & (0xf0000000))) | (((value) << (2))));
 813         fields->f_jtargq10 = value;
 814       }
 815       break;
 816     case IQ2000_OPERAND_LO16 :
 817       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_imm);
 818       break;
 819     case IQ2000_OPERAND_MASK :
 820       length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 4, 32, total_length, pc, & fields->f_mask);
 821       break;
 822     case IQ2000_OPERAND_MASKL :
 823       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 5, 32, total_length, pc, & fields->f_maskl);
 824       break;
 825     case IQ2000_OPERAND_MASKQ10 :
 826       length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 5, 32, total_length, pc, & fields->f_maskq10);
 827       break;
 828     case IQ2000_OPERAND_MASKR :
 829       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 5, 32, total_length, pc, & fields->f_rs);
 830       break;
 831     case IQ2000_OPERAND_MLO16 :
 832       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_imm);
 833       break;
 834     case IQ2000_OPERAND_OFFSET :
 835       {
 836         long value;
 837         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, pc, & value);
 838         value = ((((value) << (2))) + (((pc) + (4))));
 839         fields->f_offset = value;
 840       }
 841       break;
 842     case IQ2000_OPERAND_RD :
 843       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 5, 32, total_length, pc, & fields->f_rd);
 844       break;
 845     case IQ2000_OPERAND_RD_RS :
 846       {
 847         length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 5, 32, total_length, pc, & fields->f_rd);
 848         if (length <= 0) break;
 849         length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 5, 32, total_length, pc, & fields->f_rs);
 850         if (length <= 0) break;
 851 {
 852   FLD (f_rd_rs) = FLD (f_rs);
 853 }
 854       }
 855       break;
 856     case IQ2000_OPERAND_RD_RT :
 857       {
 858         length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 5, 32, total_length, pc, & fields->f_rd);
 859         if (length <= 0) break;
 860         length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_rt);
 861         if (length <= 0) break;
 862 {
 863   FLD (f_rd_rt) = FLD (f_rt);
 864 }
 865       }
 866       break;
 867     case IQ2000_OPERAND_RS :
 868       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 5, 32, total_length, pc, & fields->f_rs);
 869       break;
 870     case IQ2000_OPERAND_RT :
 871       length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_rt);
 872       break;
 873     case IQ2000_OPERAND_RT_RS :
 874       {
 875         length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 5, 32, total_length, pc, & fields->f_rt);
 876         if (length <= 0) break;
 877         length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 5, 32, total_length, pc, & fields->f_rs);
 878         if (length <= 0) break;
 879 {
 880   FLD (f_rd_rs) = FLD (f_rs);
 881 }
 882       }
 883       break;
 884     case IQ2000_OPERAND_SHAMT :
 885       length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 5, 32, total_length, pc, & fields->f_shamt);
 886       break;
 887
 888     default :
 889       /* xgettext:c-format */
 890       fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
 891                opindex);
 892       abort ();
 893     }
 894
 895   return length;
 896 }
 897
 898 cgen_insert_fn * const iq2000_cgen_insert_handlers[] =
 899 {
 900   insert_insn_normal,
 901 };
 902
 903 cgen_extract_fn * const iq2000_cgen_extract_handlers[] =
 904 {
 905   extract_insn_normal,
 906 };
 907
 908 int iq2000_cgen_get_int_operand
 909   PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
 910 bfd_vma iq2000_cgen_get_vma_operand
 911   PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
 912
 913 /* Getting values from cgen_fields is handled by a collection of functions.
 914    They are distinguished by the type of the VALUE argument they return.
 915    TODO: floating point, inlining support, remove cases where result type
 916    not appropriate.  */
 917
 918 int
 919 iq2000_cgen_get_int_operand (cd, opindex, fields)
 920      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
 921      int opindex;
 922      const CGEN_FIELDS * fields;
 923 {
 924   int value;
 925
 926   switch (opindex)
 927     {
 928     case IQ2000_OPERAND_BASE :
 929       value = fields->f_rs;
 930       break;
 931     case IQ2000_OPERAND_BASEOFF :
 932       value = fields->f_imm;
 933       break;
 934     case IQ2000_OPERAND_BITNUM :
 935       value = fields->f_rt;
 936       break;
 937     case IQ2000_OPERAND_BYTECOUNT :
 938       value = fields->f_bytecount;
 939       break;
 940     case IQ2000_OPERAND_CAM_Y :
 941       value = fields->f_cam_y;
 942       break;
 943     case IQ2000_OPERAND_CAM_Z :
 944       value = fields->f_cam_z;
 945       break;
 946     case IQ2000_OPERAND_CM_3FUNC :
 947       value = fields->f_cm_3func;
 948       break;
 949     case IQ2000_OPERAND_CM_3Z :
 950       value = fields->f_cm_3z;
 951       break;
 952     case IQ2000_OPERAND_CM_4FUNC :
 953       value = fields->f_cm_4func;
 954       break;
 955     case IQ2000_OPERAND_CM_4Z :
 956       value = fields->f_cm_4z;
 957       break;
 958     case IQ2000_OPERAND_COUNT :
 959       value = fields->f_count;
 960       break;
 961     case IQ2000_OPERAND_EXECODE :
 962       value = fields->f_excode;
 963       break;
 964     case IQ2000_OPERAND_F_INDEX :
 965       value = fields->f_index;
 966       break;
 967     case IQ2000_OPERAND_HI16 :
 968       value = fields->f_imm;
 969       break;
 970     case IQ2000_OPERAND_IMM :
 971       value = fields->f_imm;
 972       break;
 973     case IQ2000_OPERAND_JMPTARG :
 974       value = fields->f_jtarg;
 975       break;
 976     case IQ2000_OPERAND_JMPTARGQ10 :
 977       value = fields->f_jtargq10;
 978       break;
 979     case IQ2000_OPERAND_LO16 :
 980       value = fields->f_imm;
 981       break;
 982     case IQ2000_OPERAND_MASK :
 983       value = fields->f_mask;
 984       break;
 985     case IQ2000_OPERAND_MASKL :
 986       value = fields->f_maskl;
 987       break;
 988     case IQ2000_OPERAND_MASKQ10 :
 989       value = fields->f_maskq10;
 990       break;
 991     case IQ2000_OPERAND_MASKR :
 992       value = fields->f_rs;
 993       break;
 994     case IQ2000_OPERAND_MLO16 :
 995       value = fields->f_imm;
 996       break;
 997     case IQ2000_OPERAND_OFFSET :
 998       value = fields->f_offset;
 999       break;
1000     case IQ2000_OPERAND_RD :
1001       value = fields->f_rd;
1002       break;
1003     case IQ2000_OPERAND_RD_RS :
1004       value = fields->f_rd_rs;
1005       break;
1006     case IQ2000_OPERAND_RD_RT :
1007       value = fields->f_rd_rt;
1008       break;
1009     case IQ2000_OPERAND_RS :
1010       value = fields->f_rs;
1011       break;
1012     case IQ2000_OPERAND_RT :
1013       value = fields->f_rt;
1014       break;
1015     case IQ2000_OPERAND_RT_RS :
1016       value = fields->f_rt_rs;
1017       break;
1018     case IQ2000_OPERAND_SHAMT :
1019       value = fields->f_shamt;
1020       break;
1021
1022     default :
1023       /* xgettext:c-format */
1024       fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
1025                        opindex);
1026       abort ();
1027   }
1028
1029   return value;
1030 }
1031
1032 bfd_vma
1033 iq2000_cgen_get_vma_operand (cd, opindex, fields)
1034      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1035      int opindex;
1036      const CGEN_FIELDS * fields;
1037 {
1038   bfd_vma value;
1039
1040   switch (opindex)
1041     {
1042     case IQ2000_OPERAND_BASE :
1043       value = fields->f_rs;
1044       break;
1045     case IQ2000_OPERAND_BASEOFF :
1046       value = fields->f_imm;
1047       break;
1048     case IQ2000_OPERAND_BITNUM :
1049       value = fields->f_rt;
1050       break;
1051     case IQ2000_OPERAND_BYTECOUNT :
1052       value = fields->f_bytecount;
1053       break;
1054     case IQ2000_OPERAND_CAM_Y :
1055       value = fields->f_cam_y;
1056       break;
1057     case IQ2000_OPERAND_CAM_Z :
1058       value = fields->f_cam_z;
1059       break;
1060     case IQ2000_OPERAND_CM_3FUNC :
1061       value = fields->f_cm_3func;
1062       break;
1063     case IQ2000_OPERAND_CM_3Z :
1064       value = fields->f_cm_3z;
1065       break;
1066     case IQ2000_OPERAND_CM_4FUNC :
1067       value = fields->f_cm_4func;
1068       break;
1069     case IQ2000_OPERAND_CM_4Z :
1070       value = fields->f_cm_4z;
1071       break;
1072     case IQ2000_OPERAND_COUNT :
1073       value = fields->f_count;
1074       break;
1075     case IQ2000_OPERAND_EXECODE :
1076       value = fields->f_excode;
1077       break;
1078     case IQ2000_OPERAND_F_INDEX :
1079       value = fields->f_index;
1080       break;
1081     case IQ2000_OPERAND_HI16 :
1082       value = fields->f_imm;
1083       break;
1084     case IQ2000_OPERAND_IMM :
1085       value = fields->f_imm;
1086       break;
1087     case IQ2000_OPERAND_JMPTARG :
1088       value = fields->f_jtarg;
1089       break;
1090     case IQ2000_OPERAND_JMPTARGQ10 :
1091       value = fields->f_jtargq10;
1092       break;
1093     case IQ2000_OPERAND_LO16 :
1094       value = fields->f_imm;
1095       break;
1096     case IQ2000_OPERAND_MASK :
1097       value = fields->f_mask;
1098       break;
1099     case IQ2000_OPERAND_MASKL :
1100       value = fields->f_maskl;
1101       break;
1102     case IQ2000_OPERAND_MASKQ10 :
1103       value = fields->f_maskq10;
1104       break;
1105     case IQ2000_OPERAND_MASKR :
1106       value = fields->f_rs;
1107       break;
1108     case IQ2000_OPERAND_MLO16 :
1109       value = fields->f_imm;
1110       break;
1111     case IQ2000_OPERAND_OFFSET :
1112       value = fields->f_offset;
1113       break;
1114     case IQ2000_OPERAND_RD :
1115       value = fields->f_rd;
1116       break;
1117     case IQ2000_OPERAND_RD_RS :
1118       value = fields->f_rd_rs;
1119       break;
1120     case IQ2000_OPERAND_RD_RT :
1121       value = fields->f_rd_rt;
1122       break;
1123     case IQ2000_OPERAND_RS :
1124       value = fields->f_rs;
1125       break;
1126     case IQ2000_OPERAND_RT :
1127       value = fields->f_rt;
1128       break;
1129     case IQ2000_OPERAND_RT_RS :
1130       value = fields->f_rt_rs;
1131       break;
1132     case IQ2000_OPERAND_SHAMT :
1133       value = fields->f_shamt;
1134       break;
1135
1136     default :
1137       /* xgettext:c-format */
1138       fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
1139                        opindex);
1140       abort ();
1141   }
1142
1143   return value;
1144 }
1145
1146 void iq2000_cgen_set_int_operand
1147   PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int));
1148 void iq2000_cgen_set_vma_operand
1149   PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma));
1150
1151 /* Stuffing values in cgen_fields is handled by a collection of functions.
1152    They are distinguished by the type of the VALUE argument they accept.
1153    TODO: floating point, inlining support, remove cases where argument type
1154    not appropriate.  */
1155
1156 void
1157 iq2000_cgen_set_int_operand (cd, opindex, fields, value)
1158      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1159      int opindex;
1160      CGEN_FIELDS * fields;
1161      int value;
1162 {
1163   switch (opindex)
1164     {
1165     case IQ2000_OPERAND_BASE :
1166       fields->f_rs = value;
1167       break;
1168     case IQ2000_OPERAND_BASEOFF :
1169       fields->f_imm = value;
1170       break;
1171     case IQ2000_OPERAND_BITNUM :
1172       fields->f_rt = value;
1173       break;
1174     case IQ2000_OPERAND_BYTECOUNT :
1175       fields->f_bytecount = value;
1176       break;
1177     case IQ2000_OPERAND_CAM_Y :
1178       fields->f_cam_y = value;
1179       break;
1180     case IQ2000_OPERAND_CAM_Z :
1181       fields->f_cam_z = value;
1182       break;
1183     case IQ2000_OPERAND_CM_3FUNC :
1184       fields->f_cm_3func = value;
1185       break;
1186     case IQ2000_OPERAND_CM_3Z :
1187       fields->f_cm_3z = value;
1188       break;
1189     case IQ2000_OPERAND_CM_4FUNC :
1190       fields->f_cm_4func = value;
1191       break;
1192     case IQ2000_OPERAND_CM_4Z :
1193       fields->f_cm_4z = value;
1194       break;
1195     case IQ2000_OPERAND_COUNT :
1196       fields->f_count = value;
1197       break;
1198     case IQ2000_OPERAND_EXECODE :
1199       fields->f_excode = value;
1200       break;
1201     case IQ2000_OPERAND_F_INDEX :
1202       fields->f_index = value;
1203       break;
1204     case IQ2000_OPERAND_HI16 :
1205       fields->f_imm = value;
1206       break;
1207     case IQ2000_OPERAND_IMM :
1208       fields->f_imm = value;
1209       break;
1210     case IQ2000_OPERAND_JMPTARG :
1211       fields->f_jtarg = value;
1212       break;
1213     case IQ2000_OPERAND_JMPTARGQ10 :
1214       fields->f_jtargq10 = value;
1215       break;
1216     case IQ2000_OPERAND_LO16 :
1217       fields->f_imm = value;
1218       break;
1219     case IQ2000_OPERAND_MASK :
1220       fields->f_mask = value;
1221       break;
1222     case IQ2000_OPERAND_MASKL :
1223       fields->f_maskl = value;
1224       break;
1225     case IQ2000_OPERAND_MASKQ10 :
1226       fields->f_maskq10 = value;
1227       break;
1228     case IQ2000_OPERAND_MASKR :
1229       fields->f_rs = value;
1230       break;
1231     case IQ2000_OPERAND_MLO16 :
1232       fields->f_imm = value;
1233       break;
1234     case IQ2000_OPERAND_OFFSET :
1235       fields->f_offset = value;
1236       break;
1237     case IQ2000_OPERAND_RD :
1238       fields->f_rd = value;
1239       break;
1240     case IQ2000_OPERAND_RD_RS :
1241       fields->f_rd_rs = value;
1242       break;
1243     case IQ2000_OPERAND_RD_RT :
1244       fields->f_rd_rt = value;
1245       break;
1246     case IQ2000_OPERAND_RS :
1247       fields->f_rs = value;
1248       break;
1249     case IQ2000_OPERAND_RT :
1250       fields->f_rt = value;
1251       break;
1252     case IQ2000_OPERAND_RT_RS :
1253       fields->f_rt_rs = value;
1254       break;
1255     case IQ2000_OPERAND_SHAMT :
1256       fields->f_shamt = value;
1257       break;
1258
1259     default :
1260       /* xgettext:c-format */
1261       fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
1262                        opindex);
1263       abort ();
1264   }
1265 }
1266
1267 void
1268 iq2000_cgen_set_vma_operand (cd, opindex, fields, value)
1269      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1270      int opindex;
1271      CGEN_FIELDS * fields;
1272      bfd_vma value;
1273 {
1274   switch (opindex)
1275     {
1276     case IQ2000_OPERAND_BASE :
1277       fields->f_rs = value;
1278       break;
1279     case IQ2000_OPERAND_BASEOFF :
1280       fields->f_imm = value;
1281       break;
1282     case IQ2000_OPERAND_BITNUM :
1283       fields->f_rt = value;
1284       break;
1285     case IQ2000_OPERAND_BYTECOUNT :
1286       fields->f_bytecount = value;
1287       break;
1288     case IQ2000_OPERAND_CAM_Y :
1289       fields->f_cam_y = value;
1290       break;
1291     case IQ2000_OPERAND_CAM_Z :
1292       fields->f_cam_z = value;
1293       break;
1294     case IQ2000_OPERAND_CM_3FUNC :
1295       fields->f_cm_3func = value;
1296       break;
1297     case IQ2000_OPERAND_CM_3Z :
1298       fields->f_cm_3z = value;
1299       break;
1300     case IQ2000_OPERAND_CM_4FUNC :
1301       fields->f_cm_4func = value;
1302       break;
1303     case IQ2000_OPERAND_CM_4Z :
1304       fields->f_cm_4z = value;
1305       break;
1306     case IQ2000_OPERAND_COUNT :
1307       fields->f_count = value;
1308       break;
1309     case IQ2000_OPERAND_EXECODE :
1310       fields->f_excode = value;
1311       break;
1312     case IQ2000_OPERAND_F_INDEX :
1313       fields->f_index = value;
1314       break;
1315     case IQ2000_OPERAND_HI16 :
1316       fields->f_imm = value;
1317       break;
1318     case IQ2000_OPERAND_IMM :
1319       fields->f_imm = value;
1320       break;
1321     case IQ2000_OPERAND_JMPTARG :
1322       fields->f_jtarg = value;
1323       break;
1324     case IQ2000_OPERAND_JMPTARGQ10 :
1325       fields->f_jtargq10 = value;
1326       break;
1327     case IQ2000_OPERAND_LO16 :
1328       fields->f_imm = value;
1329       break;
1330     case IQ2000_OPERAND_MASK :
1331       fields->f_mask = value;
1332       break;
1333     case IQ2000_OPERAND_MASKL :
1334       fields->f_maskl = value;
1335       break;
1336     case IQ2000_OPERAND_MASKQ10 :
1337       fields->f_maskq10 = value;
1338       break;
1339     case IQ2000_OPERAND_MASKR :
1340       fields->f_rs = value;
1341       break;
1342     case IQ2000_OPERAND_MLO16 :
1343       fields->f_imm = value;
1344       break;
1345     case IQ2000_OPERAND_OFFSET :
1346       fields->f_offset = value;
1347       break;
1348     case IQ2000_OPERAND_RD :
1349       fields->f_rd = value;
1350       break;
1351     case IQ2000_OPERAND_RD_RS :
1352       fields->f_rd_rs = value;
1353       break;
1354     case IQ2000_OPERAND_RD_RT :
1355       fields->f_rd_rt = value;
1356       break;
1357     case IQ2000_OPERAND_RS :
1358       fields->f_rs = value;
1359       break;
1360     case IQ2000_OPERAND_RT :
1361       fields->f_rt = value;
1362       break;
1363     case IQ2000_OPERAND_RT_RS :
1364       fields->f_rt_rs = value;
1365       break;
1366     case IQ2000_OPERAND_SHAMT :
1367       fields->f_shamt = value;
1368       break;
1369
1370     default :
1371       /* xgettext:c-format */
1372       fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
1373                        opindex);
1374       abort ();
1375   }
1376 }
1377
1378 /* Function to call before using the instruction builder tables.  */
1379
1380 void
1381 iq2000_cgen_init_ibld_table (cd)
1382      CGEN_CPU_DESC cd;
1383 {
1384   cd->insert_handlers = & iq2000_cgen_insert_handlers[0];
1385   cd->extract_handlers = & iq2000_cgen_extract_handlers[0];
1386
1387   cd->insert_operand = iq2000_cgen_insert_operand;
1388   cd->extract_operand = iq2000_cgen_extract_operand;
1389
1390   cd->get_int_operand = iq2000_cgen_get_int_operand;
1391   cd->set_int_operand = iq2000_cgen_set_int_operand;
1392   cd->get_vma_operand = iq2000_cgen_get_vma_operand;
1393   cd->set_vma_operand = iq2000_cgen_set_vma_operand;
1394 }