opcodes/frv-ibld.c

   1 /* Instruction building/extraction support for frv. -*- 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 "frv-desc.h"
  34 #include "frv-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   (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   (CGEN_CPU_DESC, const CGEN_INSN *,
  51    CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
  52 static int extract_normal
  53   (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   (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   (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   (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *);
  66 static CGEN_INLINE int fill_cache
  67   (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *,  int, int, bfd_vma);
  68 static CGEN_INLINE long extract_1
  69   (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma);
  70 #endif
  71 \f
  72 /* Operand insertion.  */
  73
  74 #if ! CGEN_INT_INSN_P
  75
  76 /* Subroutine of insert_normal.  */
  77
  78 static CGEN_INLINE void
  79 insert_1 (CGEN_CPU_DESC cd,
  80           unsigned long value,
  81           int start,
  82           int length,
  83           int 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 (CGEN_CPU_DESC cd,
 122                long value,
 123                unsigned int attrs,
 124                unsigned int word_offset,
 125                unsigned int start,
 126                unsigned int length,
 127                unsigned int word_length,
 128                unsigned int total_length,
 129                CGEN_INSN_BYTES_PTR buffer)
 130 {
 131   static char errbuf[100];
 132   /* Written this way to avoid undefined behaviour.  */
 133   unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
 134
 135   /* If LENGTH is zero, this operand doesn't contribute to the value.  */
 136   if (length == 0)
 137     return NULL;
 138
 139 #if 0
 140   if (CGEN_INT_INSN_P
 141       && word_offset != 0)
 142     abort ();
 143 #endif
 144
 145   if (word_length > 32)
 146     abort ();
 147
 148   /* For architectures with insns smaller than the base-insn-bitsize,
 149      word_length may be too big.  */
 150   if (cd->min_insn_bitsize < cd->base_insn_bitsize)
 151     {
 152       if (word_offset == 0
 153           && word_length > total_length)
 154         word_length = total_length;
 155     }
 156
 157   /* Ensure VALUE will fit.  */
 158   if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
 159     {
 160       long minval = - (1L << (length - 1));
 161       unsigned long maxval = mask;
 162
 163       if ((value > 0 && (unsigned long) value > maxval)
 164           || value < minval)
 165         {
 166           /* xgettext:c-format */
 167           sprintf (errbuf,
 168                    _("operand out of range (%ld not between %ld and %lu)"),
 169                    value, minval, maxval);
 170           return errbuf;
 171         }
 172     }
 173   else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
 174     {
 175       unsigned long maxval = mask;
 176
 177       if ((unsigned long) value > maxval)
 178         {
 179           /* xgettext:c-format */
 180           sprintf (errbuf,
 181                    _("operand out of range (%lu not between 0 and %lu)"),
 182                    value, maxval);
 183           return errbuf;
 184         }
 185     }
 186   else
 187     {
 188       if (! cgen_signed_overflow_ok_p (cd))
 189         {
 190           long minval = - (1L << (length - 1));
 191           long maxval =   (1L << (length - 1)) - 1;
 192
 193           if (value < minval || value > maxval)
 194             {
 195               sprintf
 196                 /* xgettext:c-format */
 197                 (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
 198                  value, minval, maxval);
 199               return errbuf;
 200             }
 201         }
 202     }
 203
 204 #if CGEN_INT_INSN_P
 205
 206   {
 207     int shift;
 208
 209     if (CGEN_INSN_LSB0_P)
 210       shift = (word_offset + start + 1) - length;
 211     else
 212       shift = total_length - (word_offset + start + length);
 213     *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
 214   }
 215
 216 #else /* ! CGEN_INT_INSN_P */
 217
 218   {
 219     unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
 220
 221     insert_1 (cd, value, start, length, word_length, bufp);
 222   }
 223
 224 #endif /* ! CGEN_INT_INSN_P */
 225
 226   return NULL;
 227 }
 228
 229 /* Default insn builder (insert handler).
 230    The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
 231    that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
 232    recorded in host byte order, otherwise BUFFER is an array of bytes
 233    and the value is recorded in target byte order).
 234    The result is an error message or NULL if success.  */
 235
 236 static const char *
 237 insert_insn_normal (CGEN_CPU_DESC cd,
 238                     const CGEN_INSN * insn,
 239                     CGEN_FIELDS * fields,
 240                     CGEN_INSN_BYTES_PTR buffer,
 241                     bfd_vma pc)
 242 {
 243   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
 244   unsigned long value;
 245   const CGEN_SYNTAX_CHAR_TYPE * syn;
 246
 247   CGEN_INIT_INSERT (cd);
 248   value = CGEN_INSN_BASE_VALUE (insn);
 249
 250   /* If we're recording insns as numbers (rather than a string of bytes),
 251      target byte order handling is deferred until later.  */
 252
 253 #if CGEN_INT_INSN_P
 254
 255   put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
 256                       CGEN_FIELDS_BITSIZE (fields), value);
 257
 258 #else
 259
 260   cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
 261                                         (unsigned) CGEN_FIELDS_BITSIZE (fields)),
 262                        value);
 263
 264 #endif /* ! CGEN_INT_INSN_P */
 265
 266   /* ??? It would be better to scan the format's fields.
 267      Still need to be able to insert a value based on the operand though;
 268      e.g. storing a branch displacement that got resolved later.
 269      Needs more thought first.  */
 270
 271   for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
 272     {
 273       const char *errmsg;
 274
 275       if (CGEN_SYNTAX_CHAR_P (* syn))
 276         continue;
 277
 278       errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
 279                                        fields, buffer, pc);
 280       if (errmsg)
 281         return errmsg;
 282     }
 283
 284   return NULL;
 285 }
 286
 287 #if CGEN_INT_INSN_P
 288 /* Cover function to store an insn value into an integral insn.  Must go here
 289  because it needs <prefix>-desc.h for CGEN_INT_INSN_P.  */
 290
 291 static void
 292 put_insn_int_value (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 (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 324             CGEN_EXTRACT_INFO *ex_info,
 325             int offset,
 326             int 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 (CGEN_CPU_DESC cd,
 368            CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
 369            int start,
 370            int length,
 371            int word_length,
 372            unsigned char *bufp,
 373            bfd_vma pc ATTRIBUTE_UNUSED)
 374 {
 375   unsigned long x;
 376   int shift;
 377 #if 0
 378   int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
 379 #endif
 380   x = cgen_get_insn_value (cd, bufp, word_length);
 381
 382   if (CGEN_INSN_LSB0_P)
 383     shift = (start + 1) - length;
 384   else
 385     shift = (word_length - (start + length));
 386   return x >> shift;
 387 }
 388
 389 #endif /* ! CGEN_INT_INSN_P */
 390
 391 /* Default extraction routine.
 392
 393    INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
 394    or sometimes less for cases like the m32r where the base insn size is 32
 395    but some insns are 16 bits.
 396    ATTRS is a mask of the boolean attributes.  We only need `SIGNED',
 397    but for generality we take a bitmask of all of them.
 398    WORD_OFFSET is the offset in bits from the start of the insn of the value.
 399    WORD_LENGTH is the length of the word in bits in which the value resides.
 400    START is the starting bit number in the word, architecture origin.
 401    LENGTH is the length of VALUE in bits.
 402    TOTAL_LENGTH is the total length of the insn in bits.
 403
 404    Returns 1 for success, 0 for failure.  */
 405
 406 /* ??? The return code isn't properly used.  wip.  */
 407
 408 /* ??? This doesn't handle bfd_vma's.  Create another function when
 409    necessary.  */
 410
 411 static int
 412 extract_normal (CGEN_CPU_DESC cd,
 413 #if ! CGEN_INT_INSN_P
 414                 CGEN_EXTRACT_INFO *ex_info,
 415 #else
 416                 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
 417 #endif
 418                 CGEN_INSN_INT insn_value,
 419                 unsigned int attrs,
 420                 unsigned int word_offset,
 421                 unsigned int start,
 422                 unsigned int length,
 423                 unsigned int word_length,
 424                 unsigned int total_length,
 425 #if ! CGEN_INT_INSN_P
 426                 bfd_vma pc,
 427 #else
 428                 bfd_vma pc ATTRIBUTE_UNUSED,
 429 #endif
 430                 long *valuep)
 431 {
 432   long value, mask;
 433
 434   /* If LENGTH is zero, this operand doesn't contribute to the value
 435      so give it a standard value of zero.  */
 436   if (length == 0)
 437     {
 438       *valuep = 0;
 439       return 1;
 440     }
 441
 442 #if 0
 443   if (CGEN_INT_INSN_P
 444       && word_offset != 0)
 445     abort ();
 446 #endif
 447
 448   if (word_length > 32)
 449     abort ();
 450
 451   /* For architectures with insns smaller than the insn-base-bitsize,
 452      word_length may be too big.  */
 453   if (cd->min_insn_bitsize < cd->base_insn_bitsize)
 454     {
 455       if (word_offset == 0
 456           && word_length > total_length)
 457         word_length = total_length;
 458     }
 459
 460   /* Does the value reside in INSN_VALUE, and at the right alignment?  */
 461
 462   if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
 463     {
 464       if (CGEN_INSN_LSB0_P)
 465         value = insn_value >> ((word_offset + start + 1) - length);
 466       else
 467         value = insn_value >> (total_length - ( word_offset + start + length));
 468     }
 469
 470 #if ! CGEN_INT_INSN_P
 471
 472   else
 473     {
 474       unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
 475
 476       if (word_length > 32)
 477         abort ();
 478
 479       if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
 480         return 0;
 481
 482       value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
 483     }
 484
 485 #endif /* ! CGEN_INT_INSN_P */
 486
 487   /* Written this way to avoid undefined behaviour.  */
 488   mask = (((1L << (length - 1)) - 1) << 1) | 1;
 489
 490   value &= mask;
 491   /* sign extend? */
 492   if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
 493       && (value & (1L << (length - 1))))
 494     value |= ~mask;
 495
 496   *valuep = value;
 497
 498   return 1;
 499 }
 500
 501 /* Default insn extractor.
 502
 503    INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
 504    The extracted fields are stored in FIELDS.
 505    EX_INFO is used to handle reading variable length insns.
 506    Return the length of the insn in bits, or 0 if no match,
 507    or -1 if an error occurs fetching data (memory_error_func will have
 508    been called).  */
 509
 510 static int
 511 extract_insn_normal (CGEN_CPU_DESC cd,
 512                      const CGEN_INSN *insn,
 513                      CGEN_EXTRACT_INFO *ex_info,
 514                      CGEN_INSN_INT insn_value,
 515                      CGEN_FIELDS *fields,
 516                      bfd_vma pc)
 517 {
 518   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
 519   const CGEN_SYNTAX_CHAR_TYPE *syn;
 520
 521   CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
 522
 523   CGEN_INIT_EXTRACT (cd);
 524
 525   for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
 526     {
 527       int length;
 528
 529       if (CGEN_SYNTAX_CHAR_P (*syn))
 530         continue;
 531
 532       length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
 533                                         ex_info, insn_value, fields, pc);
 534       if (length <= 0)
 535         return length;
 536     }
 537
 538   /* We recognized and successfully extracted this insn.  */
 539   return CGEN_INSN_BITSIZE (insn);
 540 }
 541 \f
 542 /* machine generated code added here */
 543
 544 const char * frv_cgen_insert_operand
 545   PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
 546
 547 /* Main entry point for operand insertion.
 548
 549    This function is basically just a big switch statement.  Earlier versions
 550    used tables to look up the function to use, but
 551    - if the table contains both assembler and disassembler functions then
 552      the disassembler contains much of the assembler and vice-versa,
 553    - there's a lot of inlining possibilities as things grow,
 554    - using a switch statement avoids the function call overhead.
 555
 556    This function could be moved into `parse_insn_normal', but keeping it
 557    separate makes clear the interface between `parse_insn_normal' and each of
 558    the handlers.  It's also needed by GAS to insert operands that couldn't be
 559    resolved during parsing.  */
 560
 561 const char *
 562 frv_cgen_insert_operand (cd, opindex, fields, buffer, pc)
 563      CGEN_CPU_DESC cd;
 564      int opindex;
 565      CGEN_FIELDS * fields;
 566      CGEN_INSN_BYTES_PTR buffer;
 567      bfd_vma pc ATTRIBUTE_UNUSED;
 568 {
 569   const char * errmsg = NULL;
 570   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 571
 572   switch (opindex)
 573     {
 574     case FRV_OPERAND_A :
 575       errmsg = insert_normal (cd, fields->f_A, 0, 0, 17, 1, 32, total_length, buffer);
 576       break;
 577     case FRV_OPERAND_ACC40SI :
 578       errmsg = insert_normal (cd, fields->f_ACC40Si, 0, 0, 17, 6, 32, total_length, buffer);
 579       break;
 580     case FRV_OPERAND_ACC40SK :
 581       errmsg = insert_normal (cd, fields->f_ACC40Sk, 0, 0, 30, 6, 32, total_length, buffer);
 582       break;
 583     case FRV_OPERAND_ACC40UI :
 584       errmsg = insert_normal (cd, fields->f_ACC40Ui, 0, 0, 17, 6, 32, total_length, buffer);
 585       break;
 586     case FRV_OPERAND_ACC40UK :
 587       errmsg = insert_normal (cd, fields->f_ACC40Uk, 0, 0, 30, 6, 32, total_length, buffer);
 588       break;
 589     case FRV_OPERAND_ACCGI :
 590       errmsg = insert_normal (cd, fields->f_ACCGi, 0, 0, 17, 6, 32, total_length, buffer);
 591       break;
 592     case FRV_OPERAND_ACCGK :
 593       errmsg = insert_normal (cd, fields->f_ACCGk, 0, 0, 30, 6, 32, total_length, buffer);
 594       break;
 595     case FRV_OPERAND_CCI :
 596       errmsg = insert_normal (cd, fields->f_CCi, 0, 0, 11, 3, 32, total_length, buffer);
 597       break;
 598     case FRV_OPERAND_CPRDOUBLEK :
 599       errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
 600       break;
 601     case FRV_OPERAND_CPRI :
 602       errmsg = insert_normal (cd, fields->f_CPRi, 0, 0, 17, 6, 32, total_length, buffer);
 603       break;
 604     case FRV_OPERAND_CPRJ :
 605       errmsg = insert_normal (cd, fields->f_CPRj, 0, 0, 5, 6, 32, total_length, buffer);
 606       break;
 607     case FRV_OPERAND_CPRK :
 608       errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
 609       break;
 610     case FRV_OPERAND_CRI :
 611       errmsg = insert_normal (cd, fields->f_CRi, 0, 0, 14, 3, 32, total_length, buffer);
 612       break;
 613     case FRV_OPERAND_CRJ :
 614       errmsg = insert_normal (cd, fields->f_CRj, 0, 0, 2, 3, 32, total_length, buffer);
 615       break;
 616     case FRV_OPERAND_CRJ_FLOAT :
 617       errmsg = insert_normal (cd, fields->f_CRj_float, 0, 0, 26, 2, 32, total_length, buffer);
 618       break;
 619     case FRV_OPERAND_CRJ_INT :
 620       {
 621         long value = fields->f_CRj_int;
 622         value = ((value) - (4));
 623         errmsg = insert_normal (cd, value, 0, 0, 26, 2, 32, total_length, buffer);
 624       }
 625       break;
 626     case FRV_OPERAND_CRK :
 627       errmsg = insert_normal (cd, fields->f_CRk, 0, 0, 27, 3, 32, total_length, buffer);
 628       break;
 629     case FRV_OPERAND_FCCI_1 :
 630       errmsg = insert_normal (cd, fields->f_FCCi_1, 0, 0, 11, 2, 32, total_length, buffer);
 631       break;
 632     case FRV_OPERAND_FCCI_2 :
 633       errmsg = insert_normal (cd, fields->f_FCCi_2, 0, 0, 26, 2, 32, total_length, buffer);
 634       break;
 635     case FRV_OPERAND_FCCI_3 :
 636       errmsg = insert_normal (cd, fields->f_FCCi_3, 0, 0, 1, 2, 32, total_length, buffer);
 637       break;
 638     case FRV_OPERAND_FCCK :
 639       errmsg = insert_normal (cd, fields->f_FCCk, 0, 0, 26, 2, 32, total_length, buffer);
 640       break;
 641     case FRV_OPERAND_FRDOUBLEI :
 642       errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
 643       break;
 644     case FRV_OPERAND_FRDOUBLEJ :
 645       errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
 646       break;
 647     case FRV_OPERAND_FRDOUBLEK :
 648       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 649       break;
 650     case FRV_OPERAND_FRI :
 651       errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
 652       break;
 653     case FRV_OPERAND_FRINTI :
 654       errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
 655       break;
 656     case FRV_OPERAND_FRINTIEVEN :
 657       errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
 658       break;
 659     case FRV_OPERAND_FRINTJ :
 660       errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
 661       break;
 662     case FRV_OPERAND_FRINTJEVEN :
 663       errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
 664       break;
 665     case FRV_OPERAND_FRINTK :
 666       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 667       break;
 668     case FRV_OPERAND_FRINTKEVEN :
 669       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 670       break;
 671     case FRV_OPERAND_FRJ :
 672       errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
 673       break;
 674     case FRV_OPERAND_FRK :
 675       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 676       break;
 677     case FRV_OPERAND_FRKHI :
 678       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 679       break;
 680     case FRV_OPERAND_FRKLO :
 681       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 682       break;
 683     case FRV_OPERAND_GRDOUBLEK :
 684       errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
 685       break;
 686     case FRV_OPERAND_GRI :
 687       errmsg = insert_normal (cd, fields->f_GRi, 0, 0, 17, 6, 32, total_length, buffer);
 688       break;
 689     case FRV_OPERAND_GRJ :
 690       errmsg = insert_normal (cd, fields->f_GRj, 0, 0, 5, 6, 32, total_length, buffer);
 691       break;
 692     case FRV_OPERAND_GRK :
 693       errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
 694       break;
 695     case FRV_OPERAND_GRKHI :
 696       errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
 697       break;
 698     case FRV_OPERAND_GRKLO :
 699       errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
 700       break;
 701     case FRV_OPERAND_ICCI_1 :
 702       errmsg = insert_normal (cd, fields->f_ICCi_1, 0, 0, 11, 2, 32, total_length, buffer);
 703       break;
 704     case FRV_OPERAND_ICCI_2 :
 705       errmsg = insert_normal (cd, fields->f_ICCi_2, 0, 0, 26, 2, 32, total_length, buffer);
 706       break;
 707     case FRV_OPERAND_ICCI_3 :
 708       errmsg = insert_normal (cd, fields->f_ICCi_3, 0, 0, 1, 2, 32, total_length, buffer);
 709       break;
 710     case FRV_OPERAND_LI :
 711       errmsg = insert_normal (cd, fields->f_LI, 0, 0, 25, 1, 32, total_length, buffer);
 712       break;
 713     case FRV_OPERAND_AE :
 714       errmsg = insert_normal (cd, fields->f_ae, 0, 0, 25, 1, 32, total_length, buffer);
 715       break;
 716     case FRV_OPERAND_CCOND :
 717       errmsg = insert_normal (cd, fields->f_ccond, 0, 0, 12, 1, 32, total_length, buffer);
 718       break;
 719     case FRV_OPERAND_COND :
 720       errmsg = insert_normal (cd, fields->f_cond, 0, 0, 8, 1, 32, total_length, buffer);
 721       break;
 722     case FRV_OPERAND_D12 :
 723       errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
 724       break;
 725     case FRV_OPERAND_DEBUG :
 726       errmsg = insert_normal (cd, fields->f_debug, 0, 0, 25, 1, 32, total_length, buffer);
 727       break;
 728     case FRV_OPERAND_EIR :
 729       errmsg = insert_normal (cd, fields->f_eir, 0, 0, 17, 6, 32, total_length, buffer);
 730       break;
 731     case FRV_OPERAND_HINT :
 732       errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
 733       break;
 734     case FRV_OPERAND_HINT_NOT_TAKEN :
 735       errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
 736       break;
 737     case FRV_OPERAND_HINT_TAKEN :
 738       errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
 739       break;
 740     case FRV_OPERAND_LABEL16 :
 741       {
 742         long value = fields->f_label16;
 743         value = ((int) (((value) - (pc))) >> (2));
 744         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, buffer);
 745       }
 746       break;
 747     case FRV_OPERAND_LABEL24 :
 748       {
 749 {
 750   FLD (f_labelH6) = ((int) (((FLD (f_label24)) - (pc))) >> (20));
 751   FLD (f_labelL18) = ((((unsigned int) (((FLD (f_label24)) - (pc))) >> (2))) & (262143));
 752 }
 753         errmsg = insert_normal (cd, fields->f_labelH6, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, buffer);
 754         if (errmsg)
 755           break;
 756         errmsg = insert_normal (cd, fields->f_labelL18, 0, 0, 17, 18, 32, total_length, buffer);
 757         if (errmsg)
 758           break;
 759       }
 760       break;
 761     case FRV_OPERAND_LOCK :
 762       errmsg = insert_normal (cd, fields->f_lock, 0, 0, 25, 1, 32, total_length, buffer);
 763       break;
 764     case FRV_OPERAND_PACK :
 765       errmsg = insert_normal (cd, fields->f_pack, 0, 0, 31, 1, 32, total_length, buffer);
 766       break;
 767     case FRV_OPERAND_S10 :
 768       errmsg = insert_normal (cd, fields->f_s10, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, buffer);
 769       break;
 770     case FRV_OPERAND_S12 :
 771       errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
 772       break;
 773     case FRV_OPERAND_S16 :
 774       errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
 775       break;
 776     case FRV_OPERAND_S5 :
 777       errmsg = insert_normal (cd, fields->f_s5, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, buffer);
 778       break;
 779     case FRV_OPERAND_S6 :
 780       errmsg = insert_normal (cd, fields->f_s6, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, buffer);
 781       break;
 782     case FRV_OPERAND_S6_1 :
 783       errmsg = insert_normal (cd, fields->f_s6_1, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, buffer);
 784       break;
 785     case FRV_OPERAND_SLO16 :
 786       errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
 787       break;
 788     case FRV_OPERAND_SPR :
 789       {
 790 {
 791   FLD (f_spr_h) = ((unsigned int) (FLD (f_spr)) >> (6));
 792   FLD (f_spr_l) = ((FLD (f_spr)) & (63));
 793 }
 794         errmsg = insert_normal (cd, fields->f_spr_h, 0, 0, 30, 6, 32, total_length, buffer);
 795         if (errmsg)
 796           break;
 797         errmsg = insert_normal (cd, fields->f_spr_l, 0, 0, 17, 6, 32, total_length, buffer);
 798         if (errmsg)
 799           break;
 800       }
 801       break;
 802     case FRV_OPERAND_U12 :
 803       {
 804 {
 805   FLD (f_u12_h) = ((int) (FLD (f_u12)) >> (6));
 806   FLD (f_u12_l) = ((FLD (f_u12)) & (63));
 807 }
 808         errmsg = insert_normal (cd, fields->f_u12_h, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, buffer);
 809         if (errmsg)
 810           break;
 811         errmsg = insert_normal (cd, fields->f_u12_l, 0, 0, 5, 6, 32, total_length, buffer);
 812         if (errmsg)
 813           break;
 814       }
 815       break;
 816     case FRV_OPERAND_U16 :
 817       errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
 818       break;
 819     case FRV_OPERAND_U6 :
 820       errmsg = insert_normal (cd, fields->f_u6, 0, 0, 5, 6, 32, total_length, buffer);
 821       break;
 822     case FRV_OPERAND_UHI16 :
 823       errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
 824       break;
 825     case FRV_OPERAND_ULO16 :
 826       errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
 827       break;
 828
 829     default :
 830       /* xgettext:c-format */
 831       fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
 832                opindex);
 833       abort ();
 834   }
 835
 836   return errmsg;
 837 }
 838
 839 int frv_cgen_extract_operand
 840   PARAMS ((CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
 841            CGEN_FIELDS *, bfd_vma));
 842
 843 /* Main entry point for operand extraction.
 844    The result is <= 0 for error, >0 for success.
 845    ??? Actual values aren't well defined right now.
 846
 847    This function is basically just a big switch statement.  Earlier versions
 848    used tables to look up the function to use, but
 849    - if the table contains both assembler and disassembler functions then
 850      the disassembler contains much of the assembler and vice-versa,
 851    - there's a lot of inlining possibilities as things grow,
 852    - using a switch statement avoids the function call overhead.
 853
 854    This function could be moved into `print_insn_normal', but keeping it
 855    separate makes clear the interface between `print_insn_normal' and each of
 856    the handlers.  */
 857
 858 int
 859 frv_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
 860      CGEN_CPU_DESC cd;
 861      int opindex;
 862      CGEN_EXTRACT_INFO *ex_info;
 863      CGEN_INSN_INT insn_value;
 864      CGEN_FIELDS * fields;
 865      bfd_vma pc;
 866 {
 867   /* Assume success (for those operands that are nops).  */
 868   int length = 1;
 869   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 870
 871   switch (opindex)
 872     {
 873     case FRV_OPERAND_A :
 874       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 1, 32, total_length, pc, & fields->f_A);
 875       break;
 876     case FRV_OPERAND_ACC40SI :
 877       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Si);
 878       break;
 879     case FRV_OPERAND_ACC40SK :
 880       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Sk);
 881       break;
 882     case FRV_OPERAND_ACC40UI :
 883       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Ui);
 884       break;
 885     case FRV_OPERAND_ACC40UK :
 886       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Uk);
 887       break;
 888     case FRV_OPERAND_ACCGI :
 889       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACCGi);
 890       break;
 891     case FRV_OPERAND_ACCGK :
 892       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACCGk);
 893       break;
 894     case FRV_OPERAND_CCI :
 895       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 3, 32, total_length, pc, & fields->f_CCi);
 896       break;
 897     case FRV_OPERAND_CPRDOUBLEK :
 898       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
 899       break;
 900     case FRV_OPERAND_CPRI :
 901       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_CPRi);
 902       break;
 903     case FRV_OPERAND_CPRJ :
 904       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_CPRj);
 905       break;
 906     case FRV_OPERAND_CPRK :
 907       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
 908       break;
 909     case FRV_OPERAND_CRI :
 910       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_CRi);
 911       break;
 912     case FRV_OPERAND_CRJ :
 913       length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 32, total_length, pc, & fields->f_CRj);
 914       break;
 915     case FRV_OPERAND_CRJ_FLOAT :
 916       length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_CRj_float);
 917       break;
 918     case FRV_OPERAND_CRJ_INT :
 919       {
 920         long value;
 921         length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & value);
 922         value = ((value) + (4));
 923         fields->f_CRj_int = value;
 924       }
 925       break;
 926     case FRV_OPERAND_CRK :
 927       length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 3, 32, total_length, pc, & fields->f_CRk);
 928       break;
 929     case FRV_OPERAND_FCCI_1 :
 930       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_FCCi_1);
 931       break;
 932     case FRV_OPERAND_FCCI_2 :
 933       length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCi_2);
 934       break;
 935     case FRV_OPERAND_FCCI_3 :
 936       length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_FCCi_3);
 937       break;
 938     case FRV_OPERAND_FCCK :
 939       length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCk);
 940       break;
 941     case FRV_OPERAND_FRDOUBLEI :
 942       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
 943       break;
 944     case FRV_OPERAND_FRDOUBLEJ :
 945       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
 946       break;
 947     case FRV_OPERAND_FRDOUBLEK :
 948       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 949       break;
 950     case FRV_OPERAND_FRI :
 951       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
 952       break;
 953     case FRV_OPERAND_FRINTI :
 954       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
 955       break;
 956     case FRV_OPERAND_FRINTIEVEN :
 957       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
 958       break;
 959     case FRV_OPERAND_FRINTJ :
 960       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
 961       break;
 962     case FRV_OPERAND_FRINTJEVEN :
 963       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
 964       break;
 965     case FRV_OPERAND_FRINTK :
 966       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 967       break;
 968     case FRV_OPERAND_FRINTKEVEN :
 969       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 970       break;
 971     case FRV_OPERAND_FRJ :
 972       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
 973       break;
 974     case FRV_OPERAND_FRK :
 975       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 976       break;
 977     case FRV_OPERAND_FRKHI :
 978       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 979       break;
 980     case FRV_OPERAND_FRKLO :
 981       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 982       break;
 983     case FRV_OPERAND_GRDOUBLEK :
 984       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
 985       break;
 986     case FRV_OPERAND_GRI :
 987       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_GRi);
 988       break;
 989     case FRV_OPERAND_GRJ :
 990       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_GRj);
 991       break;
 992     case FRV_OPERAND_GRK :
 993       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
 994       break;
 995     case FRV_OPERAND_GRKHI :
 996       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
 997       break;
 998     case FRV_OPERAND_GRKLO :
 999       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
1000       break;
1001     case FRV_OPERAND_ICCI_1 :
1002       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_ICCi_1);
1003       break;
1004     case FRV_OPERAND_ICCI_2 :
1005       length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_ICCi_2);
1006       break;
1007     case FRV_OPERAND_ICCI_3 :
1008       length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_ICCi_3);
1009       break;
1010     case FRV_OPERAND_LI :
1011       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_LI);
1012       break;
1013     case FRV_OPERAND_AE :
1014       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_ae);
1015       break;
1016     case FRV_OPERAND_CCOND :
1017       length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 1, 32, total_length, pc, & fields->f_ccond);
1018       break;
1019     case FRV_OPERAND_COND :
1020       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 1, 32, total_length, pc, & fields->f_cond);
1021       break;
1022     case FRV_OPERAND_D12 :
1023       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
1024       break;
1025     case FRV_OPERAND_DEBUG :
1026       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_debug);
1027       break;
1028     case FRV_OPERAND_EIR :
1029       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_eir);
1030       break;
1031     case FRV_OPERAND_HINT :
1032       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1033       break;
1034     case FRV_OPERAND_HINT_NOT_TAKEN :
1035       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1036       break;
1037     case FRV_OPERAND_HINT_TAKEN :
1038       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1039       break;
1040     case FRV_OPERAND_LABEL16 :
1041       {
1042         long value;
1043         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);
1044         value = ((((value) << (2))) + (pc));
1045         fields->f_label16 = value;
1046       }
1047       break;
1048     case FRV_OPERAND_LABEL24 :
1049       {
1050         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, pc, & fields->f_labelH6);
1051         if (length <= 0) break;
1052         length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 18, 32, total_length, pc, & fields->f_labelL18);
1053         if (length <= 0) break;
1054 {
1055   FLD (f_label24) = ((((((((FLD (f_labelH6)) << (18))) | (FLD (f_labelL18)))) << (2))) + (pc));
1056 }
1057       }
1058       break;
1059     case FRV_OPERAND_LOCK :
1060       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_lock);
1061       break;
1062     case FRV_OPERAND_PACK :
1063       length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 1, 32, total_length, pc, & fields->f_pack);
1064       break;
1065     case FRV_OPERAND_S10 :
1066       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, pc, & fields->f_s10);
1067       break;
1068     case FRV_OPERAND_S12 :
1069       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
1070       break;
1071     case FRV_OPERAND_S16 :
1072       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
1073       break;
1074     case FRV_OPERAND_S5 :
1075       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, pc, & fields->f_s5);
1076       break;
1077     case FRV_OPERAND_S6 :
1078       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, pc, & fields->f_s6);
1079       break;
1080     case FRV_OPERAND_S6_1 :
1081       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, pc, & fields->f_s6_1);
1082       break;
1083     case FRV_OPERAND_SLO16 :
1084       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
1085       break;
1086     case FRV_OPERAND_SPR :
1087       {
1088         length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_spr_h);
1089         if (length <= 0) break;
1090         length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_spr_l);
1091         if (length <= 0) break;
1092 {
1093   FLD (f_spr) = ((((FLD (f_spr_h)) << (6))) | (FLD (f_spr_l)));
1094 }
1095       }
1096       break;
1097     case FRV_OPERAND_U12 :
1098       {
1099         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, pc, & fields->f_u12_h);
1100         if (length <= 0) break;
1101         length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u12_l);
1102         if (length <= 0) break;
1103 {
1104   FLD (f_u12) = ((((FLD (f_u12_h)) << (6))) | (FLD (f_u12_l)));
1105 }
1106       }
1107       break;
1108     case FRV_OPERAND_U16 :
1109       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1110       break;
1111     case FRV_OPERAND_U6 :
1112       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u6);
1113       break;
1114     case FRV_OPERAND_UHI16 :
1115       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1116       break;
1117     case FRV_OPERAND_ULO16 :
1118       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1119       break;
1120
1121     default :
1122       /* xgettext:c-format */
1123       fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
1124                opindex);
1125       abort ();
1126     }
1127
1128   return length;
1129 }
1130
1131 cgen_insert_fn * const frv_cgen_insert_handlers[] =
1132 {
1133   insert_insn_normal,
1134 };
1135
1136 cgen_extract_fn * const frv_cgen_extract_handlers[] =
1137 {
1138   extract_insn_normal,
1139 };
1140
1141 int frv_cgen_get_int_operand
1142   PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
1143 bfd_vma frv_cgen_get_vma_operand
1144   PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
1145
1146 /* Getting values from cgen_fields is handled by a collection of functions.
1147    They are distinguished by the type of the VALUE argument they return.
1148    TODO: floating point, inlining support, remove cases where result type
1149    not appropriate.  */
1150
1151 int
1152 frv_cgen_get_int_operand (cd, opindex, fields)
1153      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1154      int opindex;
1155      const CGEN_FIELDS * fields;
1156 {
1157   int value;
1158
1159   switch (opindex)
1160     {
1161     case FRV_OPERAND_A :
1162       value = fields->f_A;
1163       break;
1164     case FRV_OPERAND_ACC40SI :
1165       value = fields->f_ACC40Si;
1166       break;
1167     case FRV_OPERAND_ACC40SK :
1168       value = fields->f_ACC40Sk;
1169       break;
1170     case FRV_OPERAND_ACC40UI :
1171       value = fields->f_ACC40Ui;
1172       break;
1173     case FRV_OPERAND_ACC40UK :
1174       value = fields->f_ACC40Uk;
1175       break;
1176     case FRV_OPERAND_ACCGI :
1177       value = fields->f_ACCGi;
1178       break;
1179     case FRV_OPERAND_ACCGK :
1180       value = fields->f_ACCGk;
1181       break;
1182     case FRV_OPERAND_CCI :
1183       value = fields->f_CCi;
1184       break;
1185     case FRV_OPERAND_CPRDOUBLEK :
1186       value = fields->f_CPRk;
1187       break;
1188     case FRV_OPERAND_CPRI :
1189       value = fields->f_CPRi;
1190       break;
1191     case FRV_OPERAND_CPRJ :
1192       value = fields->f_CPRj;
1193       break;
1194     case FRV_OPERAND_CPRK :
1195       value = fields->f_CPRk;
1196       break;
1197     case FRV_OPERAND_CRI :
1198       value = fields->f_CRi;
1199       break;
1200     case FRV_OPERAND_CRJ :
1201       value = fields->f_CRj;
1202       break;
1203     case FRV_OPERAND_CRJ_FLOAT :
1204       value = fields->f_CRj_float;
1205       break;
1206     case FRV_OPERAND_CRJ_INT :
1207       value = fields->f_CRj_int;
1208       break;
1209     case FRV_OPERAND_CRK :
1210       value = fields->f_CRk;
1211       break;
1212     case FRV_OPERAND_FCCI_1 :
1213       value = fields->f_FCCi_1;
1214       break;
1215     case FRV_OPERAND_FCCI_2 :
1216       value = fields->f_FCCi_2;
1217       break;
1218     case FRV_OPERAND_FCCI_3 :
1219       value = fields->f_FCCi_3;
1220       break;
1221     case FRV_OPERAND_FCCK :
1222       value = fields->f_FCCk;
1223       break;
1224     case FRV_OPERAND_FRDOUBLEI :
1225       value = fields->f_FRi;
1226       break;
1227     case FRV_OPERAND_FRDOUBLEJ :
1228       value = fields->f_FRj;
1229       break;
1230     case FRV_OPERAND_FRDOUBLEK :
1231       value = fields->f_FRk;
1232       break;
1233     case FRV_OPERAND_FRI :
1234       value = fields->f_FRi;
1235       break;
1236     case FRV_OPERAND_FRINTI :
1237       value = fields->f_FRi;
1238       break;
1239     case FRV_OPERAND_FRINTIEVEN :
1240       value = fields->f_FRi;
1241       break;
1242     case FRV_OPERAND_FRINTJ :
1243       value = fields->f_FRj;
1244       break;
1245     case FRV_OPERAND_FRINTJEVEN :
1246       value = fields->f_FRj;
1247       break;
1248     case FRV_OPERAND_FRINTK :
1249       value = fields->f_FRk;
1250       break;
1251     case FRV_OPERAND_FRINTKEVEN :
1252       value = fields->f_FRk;
1253       break;
1254     case FRV_OPERAND_FRJ :
1255       value = fields->f_FRj;
1256       break;
1257     case FRV_OPERAND_FRK :
1258       value = fields->f_FRk;
1259       break;
1260     case FRV_OPERAND_FRKHI :
1261       value = fields->f_FRk;
1262       break;
1263     case FRV_OPERAND_FRKLO :
1264       value = fields->f_FRk;
1265       break;
1266     case FRV_OPERAND_GRDOUBLEK :
1267       value = fields->f_GRk;
1268       break;
1269     case FRV_OPERAND_GRI :
1270       value = fields->f_GRi;
1271       break;
1272     case FRV_OPERAND_GRJ :
1273       value = fields->f_GRj;
1274       break;
1275     case FRV_OPERAND_GRK :
1276       value = fields->f_GRk;
1277       break;
1278     case FRV_OPERAND_GRKHI :
1279       value = fields->f_GRk;
1280       break;
1281     case FRV_OPERAND_GRKLO :
1282       value = fields->f_GRk;
1283       break;
1284     case FRV_OPERAND_ICCI_1 :
1285       value = fields->f_ICCi_1;
1286       break;
1287     case FRV_OPERAND_ICCI_2 :
1288       value = fields->f_ICCi_2;
1289       break;
1290     case FRV_OPERAND_ICCI_3 :
1291       value = fields->f_ICCi_3;
1292       break;
1293     case FRV_OPERAND_LI :
1294       value = fields->f_LI;
1295       break;
1296     case FRV_OPERAND_AE :
1297       value = fields->f_ae;
1298       break;
1299     case FRV_OPERAND_CCOND :
1300       value = fields->f_ccond;
1301       break;
1302     case FRV_OPERAND_COND :
1303       value = fields->f_cond;
1304       break;
1305     case FRV_OPERAND_D12 :
1306       value = fields->f_d12;
1307       break;
1308     case FRV_OPERAND_DEBUG :
1309       value = fields->f_debug;
1310       break;
1311     case FRV_OPERAND_EIR :
1312       value = fields->f_eir;
1313       break;
1314     case FRV_OPERAND_HINT :
1315       value = fields->f_hint;
1316       break;
1317     case FRV_OPERAND_HINT_NOT_TAKEN :
1318       value = fields->f_hint;
1319       break;
1320     case FRV_OPERAND_HINT_TAKEN :
1321       value = fields->f_hint;
1322       break;
1323     case FRV_OPERAND_LABEL16 :
1324       value = fields->f_label16;
1325       break;
1326     case FRV_OPERAND_LABEL24 :
1327       value = fields->f_label24;
1328       break;
1329     case FRV_OPERAND_LOCK :
1330       value = fields->f_lock;
1331       break;
1332     case FRV_OPERAND_PACK :
1333       value = fields->f_pack;
1334       break;
1335     case FRV_OPERAND_S10 :
1336       value = fields->f_s10;
1337       break;
1338     case FRV_OPERAND_S12 :
1339       value = fields->f_d12;
1340       break;
1341     case FRV_OPERAND_S16 :
1342       value = fields->f_s16;
1343       break;
1344     case FRV_OPERAND_S5 :
1345       value = fields->f_s5;
1346       break;
1347     case FRV_OPERAND_S6 :
1348       value = fields->f_s6;
1349       break;
1350     case FRV_OPERAND_S6_1 :
1351       value = fields->f_s6_1;
1352       break;
1353     case FRV_OPERAND_SLO16 :
1354       value = fields->f_s16;
1355       break;
1356     case FRV_OPERAND_SPR :
1357       value = fields->f_spr;
1358       break;
1359     case FRV_OPERAND_U12 :
1360       value = fields->f_u12;
1361       break;
1362     case FRV_OPERAND_U16 :
1363       value = fields->f_u16;
1364       break;
1365     case FRV_OPERAND_U6 :
1366       value = fields->f_u6;
1367       break;
1368     case FRV_OPERAND_UHI16 :
1369       value = fields->f_u16;
1370       break;
1371     case FRV_OPERAND_ULO16 :
1372       value = fields->f_u16;
1373       break;
1374
1375     default :
1376       /* xgettext:c-format */
1377       fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
1378                        opindex);
1379       abort ();
1380   }
1381
1382   return value;
1383 }
1384
1385 bfd_vma
1386 frv_cgen_get_vma_operand (cd, opindex, fields)
1387      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1388      int opindex;
1389      const CGEN_FIELDS * fields;
1390 {
1391   bfd_vma value;
1392
1393   switch (opindex)
1394     {
1395     case FRV_OPERAND_A :
1396       value = fields->f_A;
1397       break;
1398     case FRV_OPERAND_ACC40SI :
1399       value = fields->f_ACC40Si;
1400       break;
1401     case FRV_OPERAND_ACC40SK :
1402       value = fields->f_ACC40Sk;
1403       break;
1404     case FRV_OPERAND_ACC40UI :
1405       value = fields->f_ACC40Ui;
1406       break;
1407     case FRV_OPERAND_ACC40UK :
1408       value = fields->f_ACC40Uk;
1409       break;
1410     case FRV_OPERAND_ACCGI :
1411       value = fields->f_ACCGi;
1412       break;
1413     case FRV_OPERAND_ACCGK :
1414       value = fields->f_ACCGk;
1415       break;
1416     case FRV_OPERAND_CCI :
1417       value = fields->f_CCi;
1418       break;
1419     case FRV_OPERAND_CPRDOUBLEK :
1420       value = fields->f_CPRk;
1421       break;
1422     case FRV_OPERAND_CPRI :
1423       value = fields->f_CPRi;
1424       break;
1425     case FRV_OPERAND_CPRJ :
1426       value = fields->f_CPRj;
1427       break;
1428     case FRV_OPERAND_CPRK :
1429       value = fields->f_CPRk;
1430       break;
1431     case FRV_OPERAND_CRI :
1432       value = fields->f_CRi;
1433       break;
1434     case FRV_OPERAND_CRJ :
1435       value = fields->f_CRj;
1436       break;
1437     case FRV_OPERAND_CRJ_FLOAT :
1438       value = fields->f_CRj_float;
1439       break;
1440     case FRV_OPERAND_CRJ_INT :
1441       value = fields->f_CRj_int;
1442       break;
1443     case FRV_OPERAND_CRK :
1444       value = fields->f_CRk;
1445       break;
1446     case FRV_OPERAND_FCCI_1 :
1447       value = fields->f_FCCi_1;
1448       break;
1449     case FRV_OPERAND_FCCI_2 :
1450       value = fields->f_FCCi_2;
1451       break;
1452     case FRV_OPERAND_FCCI_3 :
1453       value = fields->f_FCCi_3;
1454       break;
1455     case FRV_OPERAND_FCCK :
1456       value = fields->f_FCCk;
1457       break;
1458     case FRV_OPERAND_FRDOUBLEI :
1459       value = fields->f_FRi;
1460       break;
1461     case FRV_OPERAND_FRDOUBLEJ :
1462       value = fields->f_FRj;
1463       break;
1464     case FRV_OPERAND_FRDOUBLEK :
1465       value = fields->f_FRk;
1466       break;
1467     case FRV_OPERAND_FRI :
1468       value = fields->f_FRi;
1469       break;
1470     case FRV_OPERAND_FRINTI :
1471       value = fields->f_FRi;
1472       break;
1473     case FRV_OPERAND_FRINTIEVEN :
1474       value = fields->f_FRi;
1475       break;
1476     case FRV_OPERAND_FRINTJ :
1477       value = fields->f_FRj;
1478       break;
1479     case FRV_OPERAND_FRINTJEVEN :
1480       value = fields->f_FRj;
1481       break;
1482     case FRV_OPERAND_FRINTK :
1483       value = fields->f_FRk;
1484       break;
1485     case FRV_OPERAND_FRINTKEVEN :
1486       value = fields->f_FRk;
1487       break;
1488     case FRV_OPERAND_FRJ :
1489       value = fields->f_FRj;
1490       break;
1491     case FRV_OPERAND_FRK :
1492       value = fields->f_FRk;
1493       break;
1494     case FRV_OPERAND_FRKHI :
1495       value = fields->f_FRk;
1496       break;
1497     case FRV_OPERAND_FRKLO :
1498       value = fields->f_FRk;
1499       break;
1500     case FRV_OPERAND_GRDOUBLEK :
1501       value = fields->f_GRk;
1502       break;
1503     case FRV_OPERAND_GRI :
1504       value = fields->f_GRi;
1505       break;
1506     case FRV_OPERAND_GRJ :
1507       value = fields->f_GRj;
1508       break;
1509     case FRV_OPERAND_GRK :
1510       value = fields->f_GRk;
1511       break;
1512     case FRV_OPERAND_GRKHI :
1513       value = fields->f_GRk;
1514       break;
1515     case FRV_OPERAND_GRKLO :
1516       value = fields->f_GRk;
1517       break;
1518     case FRV_OPERAND_ICCI_1 :
1519       value = fields->f_ICCi_1;
1520       break;
1521     case FRV_OPERAND_ICCI_2 :
1522       value = fields->f_ICCi_2;
1523       break;
1524     case FRV_OPERAND_ICCI_3 :
1525       value = fields->f_ICCi_3;
1526       break;
1527     case FRV_OPERAND_LI :
1528       value = fields->f_LI;
1529       break;
1530     case FRV_OPERAND_AE :
1531       value = fields->f_ae;
1532       break;
1533     case FRV_OPERAND_CCOND :
1534       value = fields->f_ccond;
1535       break;
1536     case FRV_OPERAND_COND :
1537       value = fields->f_cond;
1538       break;
1539     case FRV_OPERAND_D12 :
1540       value = fields->f_d12;
1541       break;
1542     case FRV_OPERAND_DEBUG :
1543       value = fields->f_debug;
1544       break;
1545     case FRV_OPERAND_EIR :
1546       value = fields->f_eir;
1547       break;
1548     case FRV_OPERAND_HINT :
1549       value = fields->f_hint;
1550       break;
1551     case FRV_OPERAND_HINT_NOT_TAKEN :
1552       value = fields->f_hint;
1553       break;
1554     case FRV_OPERAND_HINT_TAKEN :
1555       value = fields->f_hint;
1556       break;
1557     case FRV_OPERAND_LABEL16 :
1558       value = fields->f_label16;
1559       break;
1560     case FRV_OPERAND_LABEL24 :
1561       value = fields->f_label24;
1562       break;
1563     case FRV_OPERAND_LOCK :
1564       value = fields->f_lock;
1565       break;
1566     case FRV_OPERAND_PACK :
1567       value = fields->f_pack;
1568       break;
1569     case FRV_OPERAND_S10 :
1570       value = fields->f_s10;
1571       break;
1572     case FRV_OPERAND_S12 :
1573       value = fields->f_d12;
1574       break;
1575     case FRV_OPERAND_S16 :
1576       value = fields->f_s16;
1577       break;
1578     case FRV_OPERAND_S5 :
1579       value = fields->f_s5;
1580       break;
1581     case FRV_OPERAND_S6 :
1582       value = fields->f_s6;
1583       break;
1584     case FRV_OPERAND_S6_1 :
1585       value = fields->f_s6_1;
1586       break;
1587     case FRV_OPERAND_SLO16 :
1588       value = fields->f_s16;
1589       break;
1590     case FRV_OPERAND_SPR :
1591       value = fields->f_spr;
1592       break;
1593     case FRV_OPERAND_U12 :
1594       value = fields->f_u12;
1595       break;
1596     case FRV_OPERAND_U16 :
1597       value = fields->f_u16;
1598       break;
1599     case FRV_OPERAND_U6 :
1600       value = fields->f_u6;
1601       break;
1602     case FRV_OPERAND_UHI16 :
1603       value = fields->f_u16;
1604       break;
1605     case FRV_OPERAND_ULO16 :
1606       value = fields->f_u16;
1607       break;
1608
1609     default :
1610       /* xgettext:c-format */
1611       fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
1612                        opindex);
1613       abort ();
1614   }
1615
1616   return value;
1617 }
1618
1619 void frv_cgen_set_int_operand
1620   PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int));
1621 void frv_cgen_set_vma_operand
1622   PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma));
1623
1624 /* Stuffing values in cgen_fields is handled by a collection of functions.
1625    They are distinguished by the type of the VALUE argument they accept.
1626    TODO: floating point, inlining support, remove cases where argument type
1627    not appropriate.  */
1628
1629 void
1630 frv_cgen_set_int_operand (cd, opindex, fields, value)
1631      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1632      int opindex;
1633      CGEN_FIELDS * fields;
1634      int value;
1635 {
1636   switch (opindex)
1637     {
1638     case FRV_OPERAND_A :
1639       fields->f_A = value;
1640       break;
1641     case FRV_OPERAND_ACC40SI :
1642       fields->f_ACC40Si = value;
1643       break;
1644     case FRV_OPERAND_ACC40SK :
1645       fields->f_ACC40Sk = value;
1646       break;
1647     case FRV_OPERAND_ACC40UI :
1648       fields->f_ACC40Ui = value;
1649       break;
1650     case FRV_OPERAND_ACC40UK :
1651       fields->f_ACC40Uk = value;
1652       break;
1653     case FRV_OPERAND_ACCGI :
1654       fields->f_ACCGi = value;
1655       break;
1656     case FRV_OPERAND_ACCGK :
1657       fields->f_ACCGk = value;
1658       break;
1659     case FRV_OPERAND_CCI :
1660       fields->f_CCi = value;
1661       break;
1662     case FRV_OPERAND_CPRDOUBLEK :
1663       fields->f_CPRk = value;
1664       break;
1665     case FRV_OPERAND_CPRI :
1666       fields->f_CPRi = value;
1667       break;
1668     case FRV_OPERAND_CPRJ :
1669       fields->f_CPRj = value;
1670       break;
1671     case FRV_OPERAND_CPRK :
1672       fields->f_CPRk = value;
1673       break;
1674     case FRV_OPERAND_CRI :
1675       fields->f_CRi = value;
1676       break;
1677     case FRV_OPERAND_CRJ :
1678       fields->f_CRj = value;
1679       break;
1680     case FRV_OPERAND_CRJ_FLOAT :
1681       fields->f_CRj_float = value;
1682       break;
1683     case FRV_OPERAND_CRJ_INT :
1684       fields->f_CRj_int = value;
1685       break;
1686     case FRV_OPERAND_CRK :
1687       fields->f_CRk = value;
1688       break;
1689     case FRV_OPERAND_FCCI_1 :
1690       fields->f_FCCi_1 = value;
1691       break;
1692     case FRV_OPERAND_FCCI_2 :
1693       fields->f_FCCi_2 = value;
1694       break;
1695     case FRV_OPERAND_FCCI_3 :
1696       fields->f_FCCi_3 = value;
1697       break;
1698     case FRV_OPERAND_FCCK :
1699       fields->f_FCCk = value;
1700       break;
1701     case FRV_OPERAND_FRDOUBLEI :
1702       fields->f_FRi = value;
1703       break;
1704     case FRV_OPERAND_FRDOUBLEJ :
1705       fields->f_FRj = value;
1706       break;
1707     case FRV_OPERAND_FRDOUBLEK :
1708       fields->f_FRk = value;
1709       break;
1710     case FRV_OPERAND_FRI :
1711       fields->f_FRi = value;
1712       break;
1713     case FRV_OPERAND_FRINTI :
1714       fields->f_FRi = value;
1715       break;
1716     case FRV_OPERAND_FRINTIEVEN :
1717       fields->f_FRi = value;
1718       break;
1719     case FRV_OPERAND_FRINTJ :
1720       fields->f_FRj = value;
1721       break;
1722     case FRV_OPERAND_FRINTJEVEN :
1723       fields->f_FRj = value;
1724       break;
1725     case FRV_OPERAND_FRINTK :
1726       fields->f_FRk = value;
1727       break;
1728     case FRV_OPERAND_FRINTKEVEN :
1729       fields->f_FRk = value;
1730       break;
1731     case FRV_OPERAND_FRJ :
1732       fields->f_FRj = value;
1733       break;
1734     case FRV_OPERAND_FRK :
1735       fields->f_FRk = value;
1736       break;
1737     case FRV_OPERAND_FRKHI :
1738       fields->f_FRk = value;
1739       break;
1740     case FRV_OPERAND_FRKLO :
1741       fields->f_FRk = value;
1742       break;
1743     case FRV_OPERAND_GRDOUBLEK :
1744       fields->f_GRk = value;
1745       break;
1746     case FRV_OPERAND_GRI :
1747       fields->f_GRi = value;
1748       break;
1749     case FRV_OPERAND_GRJ :
1750       fields->f_GRj = value;
1751       break;
1752     case FRV_OPERAND_GRK :
1753       fields->f_GRk = value;
1754       break;
1755     case FRV_OPERAND_GRKHI :
1756       fields->f_GRk = value;
1757       break;
1758     case FRV_OPERAND_GRKLO :
1759       fields->f_GRk = value;
1760       break;
1761     case FRV_OPERAND_ICCI_1 :
1762       fields->f_ICCi_1 = value;
1763       break;
1764     case FRV_OPERAND_ICCI_2 :
1765       fields->f_ICCi_2 = value;
1766       break;
1767     case FRV_OPERAND_ICCI_3 :
1768       fields->f_ICCi_3 = value;
1769       break;
1770     case FRV_OPERAND_LI :
1771       fields->f_LI = value;
1772       break;
1773     case FRV_OPERAND_AE :
1774       fields->f_ae = value;
1775       break;
1776     case FRV_OPERAND_CCOND :
1777       fields->f_ccond = value;
1778       break;
1779     case FRV_OPERAND_COND :
1780       fields->f_cond = value;
1781       break;
1782     case FRV_OPERAND_D12 :
1783       fields->f_d12 = value;
1784       break;
1785     case FRV_OPERAND_DEBUG :
1786       fields->f_debug = value;
1787       break;
1788     case FRV_OPERAND_EIR :
1789       fields->f_eir = value;
1790       break;
1791     case FRV_OPERAND_HINT :
1792       fields->f_hint = value;
1793       break;
1794     case FRV_OPERAND_HINT_NOT_TAKEN :
1795       fields->f_hint = value;
1796       break;
1797     case FRV_OPERAND_HINT_TAKEN :
1798       fields->f_hint = value;
1799       break;
1800     case FRV_OPERAND_LABEL16 :
1801       fields->f_label16 = value;
1802       break;
1803     case FRV_OPERAND_LABEL24 :
1804       fields->f_label24 = value;
1805       break;
1806     case FRV_OPERAND_LOCK :
1807       fields->f_lock = value;
1808       break;
1809     case FRV_OPERAND_PACK :
1810       fields->f_pack = value;
1811       break;
1812     case FRV_OPERAND_S10 :
1813       fields->f_s10 = value;
1814       break;
1815     case FRV_OPERAND_S12 :
1816       fields->f_d12 = value;
1817       break;
1818     case FRV_OPERAND_S16 :
1819       fields->f_s16 = value;
1820       break;
1821     case FRV_OPERAND_S5 :
1822       fields->f_s5 = value;
1823       break;
1824     case FRV_OPERAND_S6 :
1825       fields->f_s6 = value;
1826       break;
1827     case FRV_OPERAND_S6_1 :
1828       fields->f_s6_1 = value;
1829       break;
1830     case FRV_OPERAND_SLO16 :
1831       fields->f_s16 = value;
1832       break;
1833     case FRV_OPERAND_SPR :
1834       fields->f_spr = value;
1835       break;
1836     case FRV_OPERAND_U12 :
1837       fields->f_u12 = value;
1838       break;
1839     case FRV_OPERAND_U16 :
1840       fields->f_u16 = value;
1841       break;
1842     case FRV_OPERAND_U6 :
1843       fields->f_u6 = value;
1844       break;
1845     case FRV_OPERAND_UHI16 :
1846       fields->f_u16 = value;
1847       break;
1848     case FRV_OPERAND_ULO16 :
1849       fields->f_u16 = value;
1850       break;
1851
1852     default :
1853       /* xgettext:c-format */
1854       fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
1855                        opindex);
1856       abort ();
1857   }
1858 }
1859
1860 void
1861 frv_cgen_set_vma_operand (cd, opindex, fields, value)
1862      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1863      int opindex;
1864      CGEN_FIELDS * fields;
1865      bfd_vma value;
1866 {
1867   switch (opindex)
1868     {
1869     case FRV_OPERAND_A :
1870       fields->f_A = value;
1871       break;
1872     case FRV_OPERAND_ACC40SI :
1873       fields->f_ACC40Si = value;
1874       break;
1875     case FRV_OPERAND_ACC40SK :
1876       fields->f_ACC40Sk = value;
1877       break;
1878     case FRV_OPERAND_ACC40UI :
1879       fields->f_ACC40Ui = value;
1880       break;
1881     case FRV_OPERAND_ACC40UK :
1882       fields->f_ACC40Uk = value;
1883       break;
1884     case FRV_OPERAND_ACCGI :
1885       fields->f_ACCGi = value;
1886       break;
1887     case FRV_OPERAND_ACCGK :
1888       fields->f_ACCGk = value;
1889       break;
1890     case FRV_OPERAND_CCI :
1891       fields->f_CCi = value;
1892       break;
1893     case FRV_OPERAND_CPRDOUBLEK :
1894       fields->f_CPRk = value;
1895       break;
1896     case FRV_OPERAND_CPRI :
1897       fields->f_CPRi = value;
1898       break;
1899     case FRV_OPERAND_CPRJ :
1900       fields->f_CPRj = value;
1901       break;
1902     case FRV_OPERAND_CPRK :
1903       fields->f_CPRk = value;
1904       break;
1905     case FRV_OPERAND_CRI :
1906       fields->f_CRi = value;
1907       break;
1908     case FRV_OPERAND_CRJ :
1909       fields->f_CRj = value;
1910       break;
1911     case FRV_OPERAND_CRJ_FLOAT :
1912       fields->f_CRj_float = value;
1913       break;
1914     case FRV_OPERAND_CRJ_INT :
1915       fields->f_CRj_int = value;
1916       break;
1917     case FRV_OPERAND_CRK :
1918       fields->f_CRk = value;
1919       break;
1920     case FRV_OPERAND_FCCI_1 :
1921       fields->f_FCCi_1 = value;
1922       break;
1923     case FRV_OPERAND_FCCI_2 :
1924       fields->f_FCCi_2 = value;
1925       break;
1926     case FRV_OPERAND_FCCI_3 :
1927       fields->f_FCCi_3 = value;
1928       break;
1929     case FRV_OPERAND_FCCK :
1930       fields->f_FCCk = value;
1931       break;
1932     case FRV_OPERAND_FRDOUBLEI :
1933       fields->f_FRi = value;
1934       break;
1935     case FRV_OPERAND_FRDOUBLEJ :
1936       fields->f_FRj = value;
1937       break;
1938     case FRV_OPERAND_FRDOUBLEK :
1939       fields->f_FRk = value;
1940       break;
1941     case FRV_OPERAND_FRI :
1942       fields->f_FRi = value;
1943       break;
1944     case FRV_OPERAND_FRINTI :
1945       fields->f_FRi = value;
1946       break;
1947     case FRV_OPERAND_FRINTIEVEN :
1948       fields->f_FRi = value;
1949       break;
1950     case FRV_OPERAND_FRINTJ :
1951       fields->f_FRj = value;
1952       break;
1953     case FRV_OPERAND_FRINTJEVEN :
1954       fields->f_FRj = value;
1955       break;
1956     case FRV_OPERAND_FRINTK :
1957       fields->f_FRk = value;
1958       break;
1959     case FRV_OPERAND_FRINTKEVEN :
1960       fields->f_FRk = value;
1961       break;
1962     case FRV_OPERAND_FRJ :
1963       fields->f_FRj = value;
1964       break;
1965     case FRV_OPERAND_FRK :
1966       fields->f_FRk = value;
1967       break;
1968     case FRV_OPERAND_FRKHI :
1969       fields->f_FRk = value;
1970       break;
1971     case FRV_OPERAND_FRKLO :
1972       fields->f_FRk = value;
1973       break;
1974     case FRV_OPERAND_GRDOUBLEK :
1975       fields->f_GRk = value;
1976       break;
1977     case FRV_OPERAND_GRI :
1978       fields->f_GRi = value;
1979       break;
1980     case FRV_OPERAND_GRJ :
1981       fields->f_GRj = value;
1982       break;
1983     case FRV_OPERAND_GRK :
1984       fields->f_GRk = value;
1985       break;
1986     case FRV_OPERAND_GRKHI :
1987       fields->f_GRk = value;
1988       break;
1989     case FRV_OPERAND_GRKLO :
1990       fields->f_GRk = value;
1991       break;
1992     case FRV_OPERAND_ICCI_1 :
1993       fields->f_ICCi_1 = value;
1994       break;
1995     case FRV_OPERAND_ICCI_2 :
1996       fields->f_ICCi_2 = value;
1997       break;
1998     case FRV_OPERAND_ICCI_3 :
1999       fields->f_ICCi_3 = value;
2000       break;
2001     case FRV_OPERAND_LI :
2002       fields->f_LI = value;
2003       break;
2004     case FRV_OPERAND_AE :
2005       fields->f_ae = value;
2006       break;
2007     case FRV_OPERAND_CCOND :
2008       fields->f_ccond = value;
2009       break;
2010     case FRV_OPERAND_COND :
2011       fields->f_cond = value;
2012       break;
2013     case FRV_OPERAND_D12 :
2014       fields->f_d12 = value;
2015       break;
2016     case FRV_OPERAND_DEBUG :
2017       fields->f_debug = value;
2018       break;
2019     case FRV_OPERAND_EIR :
2020       fields->f_eir = value;
2021       break;
2022     case FRV_OPERAND_HINT :
2023       fields->f_hint = value;
2024       break;
2025     case FRV_OPERAND_HINT_NOT_TAKEN :
2026       fields->f_hint = value;
2027       break;
2028     case FRV_OPERAND_HINT_TAKEN :
2029       fields->f_hint = value;
2030       break;
2031     case FRV_OPERAND_LABEL16 :
2032       fields->f_label16 = value;
2033       break;
2034     case FRV_OPERAND_LABEL24 :
2035       fields->f_label24 = value;
2036       break;
2037     case FRV_OPERAND_LOCK :
2038       fields->f_lock = value;
2039       break;
2040     case FRV_OPERAND_PACK :
2041       fields->f_pack = value;
2042       break;
2043     case FRV_OPERAND_S10 :
2044       fields->f_s10 = value;
2045       break;
2046     case FRV_OPERAND_S12 :
2047       fields->f_d12 = value;
2048       break;
2049     case FRV_OPERAND_S16 :
2050       fields->f_s16 = value;
2051       break;
2052     case FRV_OPERAND_S5 :
2053       fields->f_s5 = value;
2054       break;
2055     case FRV_OPERAND_S6 :
2056       fields->f_s6 = value;
2057       break;
2058     case FRV_OPERAND_S6_1 :
2059       fields->f_s6_1 = value;
2060       break;
2061     case FRV_OPERAND_SLO16 :
2062       fields->f_s16 = value;
2063       break;
2064     case FRV_OPERAND_SPR :
2065       fields->f_spr = value;
2066       break;
2067     case FRV_OPERAND_U12 :
2068       fields->f_u12 = value;
2069       break;
2070     case FRV_OPERAND_U16 :
2071       fields->f_u16 = value;
2072       break;
2073     case FRV_OPERAND_U6 :
2074       fields->f_u6 = value;
2075       break;
2076     case FRV_OPERAND_UHI16 :
2077       fields->f_u16 = value;
2078       break;
2079     case FRV_OPERAND_ULO16 :
2080       fields->f_u16 = value;
2081       break;
2082
2083     default :
2084       /* xgettext:c-format */
2085       fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
2086                        opindex);
2087       abort ();
2088   }
2089 }
2090
2091 /* Function to call before using the instruction builder tables.  */
2092
2093 void
2094 frv_cgen_init_ibld_table (cd)
2095      CGEN_CPU_DESC cd;
2096 {
2097   cd->insert_handlers = & frv_cgen_insert_handlers[0];
2098   cd->extract_handlers = & frv_cgen_extract_handlers[0];
2099
2100   cd->insert_operand = frv_cgen_insert_operand;
2101   cd->extract_operand = frv_cgen_extract_operand;
2102
2103   cd->get_int_operand = frv_cgen_get_int_operand;
2104   cd->set_int_operand = frv_cgen_set_int_operand;
2105   cd->get_vma_operand = frv_cgen_get_vma_operand;
2106   cd->set_vma_operand = frv_cgen_set_vma_operand;
2107 }