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_A0 :
 575       errmsg = insert_normal (cd, fields->f_A, 0, 0, 17, 1, 32, total_length, buffer);
 576       break;
 577     case FRV_OPERAND_A1 :
 578       errmsg = insert_normal (cd, fields->f_A, 0, 0, 17, 1, 32, total_length, buffer);
 579       break;
 580     case FRV_OPERAND_ACC40SI :
 581       errmsg = insert_normal (cd, fields->f_ACC40Si, 0, 0, 17, 6, 32, total_length, buffer);
 582       break;
 583     case FRV_OPERAND_ACC40SK :
 584       errmsg = insert_normal (cd, fields->f_ACC40Sk, 0, 0, 30, 6, 32, total_length, buffer);
 585       break;
 586     case FRV_OPERAND_ACC40UI :
 587       errmsg = insert_normal (cd, fields->f_ACC40Ui, 0, 0, 17, 6, 32, total_length, buffer);
 588       break;
 589     case FRV_OPERAND_ACC40UK :
 590       errmsg = insert_normal (cd, fields->f_ACC40Uk, 0, 0, 30, 6, 32, total_length, buffer);
 591       break;
 592     case FRV_OPERAND_ACCGI :
 593       errmsg = insert_normal (cd, fields->f_ACCGi, 0, 0, 17, 6, 32, total_length, buffer);
 594       break;
 595     case FRV_OPERAND_ACCGK :
 596       errmsg = insert_normal (cd, fields->f_ACCGk, 0, 0, 30, 6, 32, total_length, buffer);
 597       break;
 598     case FRV_OPERAND_CCI :
 599       errmsg = insert_normal (cd, fields->f_CCi, 0, 0, 11, 3, 32, total_length, buffer);
 600       break;
 601     case FRV_OPERAND_CPRDOUBLEK :
 602       errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
 603       break;
 604     case FRV_OPERAND_CPRI :
 605       errmsg = insert_normal (cd, fields->f_CPRi, 0, 0, 17, 6, 32, total_length, buffer);
 606       break;
 607     case FRV_OPERAND_CPRJ :
 608       errmsg = insert_normal (cd, fields->f_CPRj, 0, 0, 5, 6, 32, total_length, buffer);
 609       break;
 610     case FRV_OPERAND_CPRK :
 611       errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
 612       break;
 613     case FRV_OPERAND_CRI :
 614       errmsg = insert_normal (cd, fields->f_CRi, 0, 0, 14, 3, 32, total_length, buffer);
 615       break;
 616     case FRV_OPERAND_CRJ :
 617       errmsg = insert_normal (cd, fields->f_CRj, 0, 0, 2, 3, 32, total_length, buffer);
 618       break;
 619     case FRV_OPERAND_CRJ_FLOAT :
 620       errmsg = insert_normal (cd, fields->f_CRj_float, 0, 0, 26, 2, 32, total_length, buffer);
 621       break;
 622     case FRV_OPERAND_CRJ_INT :
 623       {
 624         long value = fields->f_CRj_int;
 625         value = ((value) - (4));
 626         errmsg = insert_normal (cd, value, 0, 0, 26, 2, 32, total_length, buffer);
 627       }
 628       break;
 629     case FRV_OPERAND_CRK :
 630       errmsg = insert_normal (cd, fields->f_CRk, 0, 0, 27, 3, 32, total_length, buffer);
 631       break;
 632     case FRV_OPERAND_FCCI_1 :
 633       errmsg = insert_normal (cd, fields->f_FCCi_1, 0, 0, 11, 2, 32, total_length, buffer);
 634       break;
 635     case FRV_OPERAND_FCCI_2 :
 636       errmsg = insert_normal (cd, fields->f_FCCi_2, 0, 0, 26, 2, 32, total_length, buffer);
 637       break;
 638     case FRV_OPERAND_FCCI_3 :
 639       errmsg = insert_normal (cd, fields->f_FCCi_3, 0, 0, 1, 2, 32, total_length, buffer);
 640       break;
 641     case FRV_OPERAND_FCCK :
 642       errmsg = insert_normal (cd, fields->f_FCCk, 0, 0, 26, 2, 32, total_length, buffer);
 643       break;
 644     case FRV_OPERAND_FRDOUBLEI :
 645       errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
 646       break;
 647     case FRV_OPERAND_FRDOUBLEJ :
 648       errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
 649       break;
 650     case FRV_OPERAND_FRDOUBLEK :
 651       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 652       break;
 653     case FRV_OPERAND_FRI :
 654       errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
 655       break;
 656     case FRV_OPERAND_FRINTI :
 657       errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
 658       break;
 659     case FRV_OPERAND_FRINTIEVEN :
 660       errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
 661       break;
 662     case FRV_OPERAND_FRINTJ :
 663       errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
 664       break;
 665     case FRV_OPERAND_FRINTJEVEN :
 666       errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
 667       break;
 668     case FRV_OPERAND_FRINTK :
 669       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 670       break;
 671     case FRV_OPERAND_FRINTKEVEN :
 672       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 673       break;
 674     case FRV_OPERAND_FRJ :
 675       errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
 676       break;
 677     case FRV_OPERAND_FRK :
 678       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 679       break;
 680     case FRV_OPERAND_FRKHI :
 681       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 682       break;
 683     case FRV_OPERAND_FRKLO :
 684       errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
 685       break;
 686     case FRV_OPERAND_GRDOUBLEK :
 687       errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
 688       break;
 689     case FRV_OPERAND_GRI :
 690       errmsg = insert_normal (cd, fields->f_GRi, 0, 0, 17, 6, 32, total_length, buffer);
 691       break;
 692     case FRV_OPERAND_GRJ :
 693       errmsg = insert_normal (cd, fields->f_GRj, 0, 0, 5, 6, 32, total_length, buffer);
 694       break;
 695     case FRV_OPERAND_GRK :
 696       errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
 697       break;
 698     case FRV_OPERAND_GRKHI :
 699       errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
 700       break;
 701     case FRV_OPERAND_GRKLO :
 702       errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
 703       break;
 704     case FRV_OPERAND_ICCI_1 :
 705       errmsg = insert_normal (cd, fields->f_ICCi_1, 0, 0, 11, 2, 32, total_length, buffer);
 706       break;
 707     case FRV_OPERAND_ICCI_2 :
 708       errmsg = insert_normal (cd, fields->f_ICCi_2, 0, 0, 26, 2, 32, total_length, buffer);
 709       break;
 710     case FRV_OPERAND_ICCI_3 :
 711       errmsg = insert_normal (cd, fields->f_ICCi_3, 0, 0, 1, 2, 32, total_length, buffer);
 712       break;
 713     case FRV_OPERAND_LI :
 714       errmsg = insert_normal (cd, fields->f_LI, 0, 0, 25, 1, 32, total_length, buffer);
 715       break;
 716     case FRV_OPERAND_AE :
 717       errmsg = insert_normal (cd, fields->f_ae, 0, 0, 25, 1, 32, total_length, buffer);
 718       break;
 719     case FRV_OPERAND_CCOND :
 720       errmsg = insert_normal (cd, fields->f_ccond, 0, 0, 12, 1, 32, total_length, buffer);
 721       break;
 722     case FRV_OPERAND_COND :
 723       errmsg = insert_normal (cd, fields->f_cond, 0, 0, 8, 1, 32, total_length, buffer);
 724       break;
 725     case FRV_OPERAND_D12 :
 726       errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
 727       break;
 728     case FRV_OPERAND_DEBUG :
 729       errmsg = insert_normal (cd, fields->f_debug, 0, 0, 25, 1, 32, total_length, buffer);
 730       break;
 731     case FRV_OPERAND_EIR :
 732       errmsg = insert_normal (cd, fields->f_eir, 0, 0, 17, 6, 32, total_length, buffer);
 733       break;
 734     case FRV_OPERAND_HINT :
 735       errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
 736       break;
 737     case FRV_OPERAND_HINT_NOT_TAKEN :
 738       errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
 739       break;
 740     case FRV_OPERAND_HINT_TAKEN :
 741       errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
 742       break;
 743     case FRV_OPERAND_LABEL16 :
 744       {
 745         long value = fields->f_label16;
 746         value = ((int) (((value) - (pc))) >> (2));
 747         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, buffer);
 748       }
 749       break;
 750     case FRV_OPERAND_LABEL24 :
 751       {
 752 {
 753   FLD (f_labelH6) = ((int) (((FLD (f_label24)) - (pc))) >> (20));
 754   FLD (f_labelL18) = ((((unsigned int) (((FLD (f_label24)) - (pc))) >> (2))) & (262143));
 755 }
 756         errmsg = insert_normal (cd, fields->f_labelH6, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, buffer);
 757         if (errmsg)
 758           break;
 759         errmsg = insert_normal (cd, fields->f_labelL18, 0, 0, 17, 18, 32, total_length, buffer);
 760         if (errmsg)
 761           break;
 762       }
 763       break;
 764     case FRV_OPERAND_LOCK :
 765       errmsg = insert_normal (cd, fields->f_lock, 0, 0, 25, 1, 32, total_length, buffer);
 766       break;
 767     case FRV_OPERAND_PACK :
 768       errmsg = insert_normal (cd, fields->f_pack, 0, 0, 31, 1, 32, total_length, buffer);
 769       break;
 770     case FRV_OPERAND_S10 :
 771       errmsg = insert_normal (cd, fields->f_s10, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, buffer);
 772       break;
 773     case FRV_OPERAND_S12 :
 774       errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
 775       break;
 776     case FRV_OPERAND_S16 :
 777       errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
 778       break;
 779     case FRV_OPERAND_S5 :
 780       errmsg = insert_normal (cd, fields->f_s5, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, buffer);
 781       break;
 782     case FRV_OPERAND_S6 :
 783       errmsg = insert_normal (cd, fields->f_s6, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, buffer);
 784       break;
 785     case FRV_OPERAND_S6_1 :
 786       errmsg = insert_normal (cd, fields->f_s6_1, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, buffer);
 787       break;
 788     case FRV_OPERAND_SLO16 :
 789       errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
 790       break;
 791     case FRV_OPERAND_SPR :
 792       {
 793 {
 794   FLD (f_spr_h) = ((unsigned int) (FLD (f_spr)) >> (6));
 795   FLD (f_spr_l) = ((FLD (f_spr)) & (63));
 796 }
 797         errmsg = insert_normal (cd, fields->f_spr_h, 0, 0, 30, 6, 32, total_length, buffer);
 798         if (errmsg)
 799           break;
 800         errmsg = insert_normal (cd, fields->f_spr_l, 0, 0, 17, 6, 32, total_length, buffer);
 801         if (errmsg)
 802           break;
 803       }
 804       break;
 805     case FRV_OPERAND_U12 :
 806       {
 807 {
 808   FLD (f_u12_h) = ((int) (FLD (f_u12)) >> (6));
 809   FLD (f_u12_l) = ((FLD (f_u12)) & (63));
 810 }
 811         errmsg = insert_normal (cd, fields->f_u12_h, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, buffer);
 812         if (errmsg)
 813           break;
 814         errmsg = insert_normal (cd, fields->f_u12_l, 0, 0, 5, 6, 32, total_length, buffer);
 815         if (errmsg)
 816           break;
 817       }
 818       break;
 819     case FRV_OPERAND_U16 :
 820       errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
 821       break;
 822     case FRV_OPERAND_U6 :
 823       errmsg = insert_normal (cd, fields->f_u6, 0, 0, 5, 6, 32, total_length, buffer);
 824       break;
 825     case FRV_OPERAND_UHI16 :
 826       errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
 827       break;
 828     case FRV_OPERAND_ULO16 :
 829       errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
 830       break;
 831
 832     default :
 833       /* xgettext:c-format */
 834       fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
 835                opindex);
 836       abort ();
 837   }
 838
 839   return errmsg;
 840 }
 841
 842 int frv_cgen_extract_operand
 843   PARAMS ((CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
 844            CGEN_FIELDS *, bfd_vma));
 845
 846 /* Main entry point for operand extraction.
 847    The result is <= 0 for error, >0 for success.
 848    ??? Actual values aren't well defined right now.
 849
 850    This function is basically just a big switch statement.  Earlier versions
 851    used tables to look up the function to use, but
 852    - if the table contains both assembler and disassembler functions then
 853      the disassembler contains much of the assembler and vice-versa,
 854    - there's a lot of inlining possibilities as things grow,
 855    - using a switch statement avoids the function call overhead.
 856
 857    This function could be moved into `print_insn_normal', but keeping it
 858    separate makes clear the interface between `print_insn_normal' and each of
 859    the handlers.  */
 860
 861 int
 862 frv_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
 863      CGEN_CPU_DESC cd;
 864      int opindex;
 865      CGEN_EXTRACT_INFO *ex_info;
 866      CGEN_INSN_INT insn_value;
 867      CGEN_FIELDS * fields;
 868      bfd_vma pc;
 869 {
 870   /* Assume success (for those operands that are nops).  */
 871   int length = 1;
 872   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 873
 874   switch (opindex)
 875     {
 876     case FRV_OPERAND_A0 :
 877       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 1, 32, total_length, pc, & fields->f_A);
 878       break;
 879     case FRV_OPERAND_A1 :
 880       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 1, 32, total_length, pc, & fields->f_A);
 881       break;
 882     case FRV_OPERAND_ACC40SI :
 883       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Si);
 884       break;
 885     case FRV_OPERAND_ACC40SK :
 886       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Sk);
 887       break;
 888     case FRV_OPERAND_ACC40UI :
 889       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Ui);
 890       break;
 891     case FRV_OPERAND_ACC40UK :
 892       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Uk);
 893       break;
 894     case FRV_OPERAND_ACCGI :
 895       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACCGi);
 896       break;
 897     case FRV_OPERAND_ACCGK :
 898       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACCGk);
 899       break;
 900     case FRV_OPERAND_CCI :
 901       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 3, 32, total_length, pc, & fields->f_CCi);
 902       break;
 903     case FRV_OPERAND_CPRDOUBLEK :
 904       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
 905       break;
 906     case FRV_OPERAND_CPRI :
 907       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_CPRi);
 908       break;
 909     case FRV_OPERAND_CPRJ :
 910       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_CPRj);
 911       break;
 912     case FRV_OPERAND_CPRK :
 913       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
 914       break;
 915     case FRV_OPERAND_CRI :
 916       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_CRi);
 917       break;
 918     case FRV_OPERAND_CRJ :
 919       length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 32, total_length, pc, & fields->f_CRj);
 920       break;
 921     case FRV_OPERAND_CRJ_FLOAT :
 922       length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_CRj_float);
 923       break;
 924     case FRV_OPERAND_CRJ_INT :
 925       {
 926         long value;
 927         length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & value);
 928         value = ((value) + (4));
 929         fields->f_CRj_int = value;
 930       }
 931       break;
 932     case FRV_OPERAND_CRK :
 933       length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 3, 32, total_length, pc, & fields->f_CRk);
 934       break;
 935     case FRV_OPERAND_FCCI_1 :
 936       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_FCCi_1);
 937       break;
 938     case FRV_OPERAND_FCCI_2 :
 939       length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCi_2);
 940       break;
 941     case FRV_OPERAND_FCCI_3 :
 942       length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_FCCi_3);
 943       break;
 944     case FRV_OPERAND_FCCK :
 945       length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCk);
 946       break;
 947     case FRV_OPERAND_FRDOUBLEI :
 948       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
 949       break;
 950     case FRV_OPERAND_FRDOUBLEJ :
 951       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
 952       break;
 953     case FRV_OPERAND_FRDOUBLEK :
 954       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 955       break;
 956     case FRV_OPERAND_FRI :
 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_FRINTI :
 960       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
 961       break;
 962     case FRV_OPERAND_FRINTIEVEN :
 963       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
 964       break;
 965     case FRV_OPERAND_FRINTJ :
 966       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
 967       break;
 968     case FRV_OPERAND_FRINTJEVEN :
 969       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
 970       break;
 971     case FRV_OPERAND_FRINTK :
 972       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 973       break;
 974     case FRV_OPERAND_FRINTKEVEN :
 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_FRJ :
 978       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
 979       break;
 980     case FRV_OPERAND_FRK :
 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_FRKHI :
 984       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 985       break;
 986     case FRV_OPERAND_FRKLO :
 987       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
 988       break;
 989     case FRV_OPERAND_GRDOUBLEK :
 990       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
 991       break;
 992     case FRV_OPERAND_GRI :
 993       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_GRi);
 994       break;
 995     case FRV_OPERAND_GRJ :
 996       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_GRj);
 997       break;
 998     case FRV_OPERAND_GRK :
 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_GRKHI :
1002       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
1003       break;
1004     case FRV_OPERAND_GRKLO :
1005       length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
1006       break;
1007     case FRV_OPERAND_ICCI_1 :
1008       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_ICCi_1);
1009       break;
1010     case FRV_OPERAND_ICCI_2 :
1011       length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_ICCi_2);
1012       break;
1013     case FRV_OPERAND_ICCI_3 :
1014       length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_ICCi_3);
1015       break;
1016     case FRV_OPERAND_LI :
1017       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_LI);
1018       break;
1019     case FRV_OPERAND_AE :
1020       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_ae);
1021       break;
1022     case FRV_OPERAND_CCOND :
1023       length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 1, 32, total_length, pc, & fields->f_ccond);
1024       break;
1025     case FRV_OPERAND_COND :
1026       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 1, 32, total_length, pc, & fields->f_cond);
1027       break;
1028     case FRV_OPERAND_D12 :
1029       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
1030       break;
1031     case FRV_OPERAND_DEBUG :
1032       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_debug);
1033       break;
1034     case FRV_OPERAND_EIR :
1035       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_eir);
1036       break;
1037     case FRV_OPERAND_HINT :
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_HINT_NOT_TAKEN :
1041       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1042       break;
1043     case FRV_OPERAND_HINT_TAKEN :
1044       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1045       break;
1046     case FRV_OPERAND_LABEL16 :
1047       {
1048         long value;
1049         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);
1050         value = ((((value) << (2))) + (pc));
1051         fields->f_label16 = value;
1052       }
1053       break;
1054     case FRV_OPERAND_LABEL24 :
1055       {
1056         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, pc, & fields->f_labelH6);
1057         if (length <= 0) break;
1058         length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 18, 32, total_length, pc, & fields->f_labelL18);
1059         if (length <= 0) break;
1060 {
1061   FLD (f_label24) = ((((((((FLD (f_labelH6)) << (18))) | (FLD (f_labelL18)))) << (2))) + (pc));
1062 }
1063       }
1064       break;
1065     case FRV_OPERAND_LOCK :
1066       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_lock);
1067       break;
1068     case FRV_OPERAND_PACK :
1069       length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 1, 32, total_length, pc, & fields->f_pack);
1070       break;
1071     case FRV_OPERAND_S10 :
1072       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, pc, & fields->f_s10);
1073       break;
1074     case FRV_OPERAND_S12 :
1075       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
1076       break;
1077     case FRV_OPERAND_S16 :
1078       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
1079       break;
1080     case FRV_OPERAND_S5 :
1081       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, pc, & fields->f_s5);
1082       break;
1083     case FRV_OPERAND_S6 :
1084       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, pc, & fields->f_s6);
1085       break;
1086     case FRV_OPERAND_S6_1 :
1087       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, pc, & fields->f_s6_1);
1088       break;
1089     case FRV_OPERAND_SLO16 :
1090       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
1091       break;
1092     case FRV_OPERAND_SPR :
1093       {
1094         length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_spr_h);
1095         if (length <= 0) break;
1096         length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_spr_l);
1097         if (length <= 0) break;
1098 {
1099   FLD (f_spr) = ((((FLD (f_spr_h)) << (6))) | (FLD (f_spr_l)));
1100 }
1101       }
1102       break;
1103     case FRV_OPERAND_U12 :
1104       {
1105         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, pc, & fields->f_u12_h);
1106         if (length <= 0) break;
1107         length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u12_l);
1108         if (length <= 0) break;
1109 {
1110   FLD (f_u12) = ((((FLD (f_u12_h)) << (6))) | (FLD (f_u12_l)));
1111 }
1112       }
1113       break;
1114     case FRV_OPERAND_U16 :
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_U6 :
1118       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u6);
1119       break;
1120     case FRV_OPERAND_UHI16 :
1121       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1122       break;
1123     case FRV_OPERAND_ULO16 :
1124       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1125       break;
1126
1127     default :
1128       /* xgettext:c-format */
1129       fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
1130                opindex);
1131       abort ();
1132     }
1133
1134   return length;
1135 }
1136
1137 cgen_insert_fn * const frv_cgen_insert_handlers[] =
1138 {
1139   insert_insn_normal,
1140 };
1141
1142 cgen_extract_fn * const frv_cgen_extract_handlers[] =
1143 {
1144   extract_insn_normal,
1145 };
1146
1147 int frv_cgen_get_int_operand
1148   PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
1149 bfd_vma frv_cgen_get_vma_operand
1150   PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
1151
1152 /* Getting values from cgen_fields is handled by a collection of functions.
1153    They are distinguished by the type of the VALUE argument they return.
1154    TODO: floating point, inlining support, remove cases where result type
1155    not appropriate.  */
1156
1157 int
1158 frv_cgen_get_int_operand (cd, opindex, fields)
1159      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1160      int opindex;
1161      const CGEN_FIELDS * fields;
1162 {
1163   int value;
1164
1165   switch (opindex)
1166     {
1167     case FRV_OPERAND_A0 :
1168       value = fields->f_A;
1169       break;
1170     case FRV_OPERAND_A1 :
1171       value = fields->f_A;
1172       break;
1173     case FRV_OPERAND_ACC40SI :
1174       value = fields->f_ACC40Si;
1175       break;
1176     case FRV_OPERAND_ACC40SK :
1177       value = fields->f_ACC40Sk;
1178       break;
1179     case FRV_OPERAND_ACC40UI :
1180       value = fields->f_ACC40Ui;
1181       break;
1182     case FRV_OPERAND_ACC40UK :
1183       value = fields->f_ACC40Uk;
1184       break;
1185     case FRV_OPERAND_ACCGI :
1186       value = fields->f_ACCGi;
1187       break;
1188     case FRV_OPERAND_ACCGK :
1189       value = fields->f_ACCGk;
1190       break;
1191     case FRV_OPERAND_CCI :
1192       value = fields->f_CCi;
1193       break;
1194     case FRV_OPERAND_CPRDOUBLEK :
1195       value = fields->f_CPRk;
1196       break;
1197     case FRV_OPERAND_CPRI :
1198       value = fields->f_CPRi;
1199       break;
1200     case FRV_OPERAND_CPRJ :
1201       value = fields->f_CPRj;
1202       break;
1203     case FRV_OPERAND_CPRK :
1204       value = fields->f_CPRk;
1205       break;
1206     case FRV_OPERAND_CRI :
1207       value = fields->f_CRi;
1208       break;
1209     case FRV_OPERAND_CRJ :
1210       value = fields->f_CRj;
1211       break;
1212     case FRV_OPERAND_CRJ_FLOAT :
1213       value = fields->f_CRj_float;
1214       break;
1215     case FRV_OPERAND_CRJ_INT :
1216       value = fields->f_CRj_int;
1217       break;
1218     case FRV_OPERAND_CRK :
1219       value = fields->f_CRk;
1220       break;
1221     case FRV_OPERAND_FCCI_1 :
1222       value = fields->f_FCCi_1;
1223       break;
1224     case FRV_OPERAND_FCCI_2 :
1225       value = fields->f_FCCi_2;
1226       break;
1227     case FRV_OPERAND_FCCI_3 :
1228       value = fields->f_FCCi_3;
1229       break;
1230     case FRV_OPERAND_FCCK :
1231       value = fields->f_FCCk;
1232       break;
1233     case FRV_OPERAND_FRDOUBLEI :
1234       value = fields->f_FRi;
1235       break;
1236     case FRV_OPERAND_FRDOUBLEJ :
1237       value = fields->f_FRj;
1238       break;
1239     case FRV_OPERAND_FRDOUBLEK :
1240       value = fields->f_FRk;
1241       break;
1242     case FRV_OPERAND_FRI :
1243       value = fields->f_FRi;
1244       break;
1245     case FRV_OPERAND_FRINTI :
1246       value = fields->f_FRi;
1247       break;
1248     case FRV_OPERAND_FRINTIEVEN :
1249       value = fields->f_FRi;
1250       break;
1251     case FRV_OPERAND_FRINTJ :
1252       value = fields->f_FRj;
1253       break;
1254     case FRV_OPERAND_FRINTJEVEN :
1255       value = fields->f_FRj;
1256       break;
1257     case FRV_OPERAND_FRINTK :
1258       value = fields->f_FRk;
1259       break;
1260     case FRV_OPERAND_FRINTKEVEN :
1261       value = fields->f_FRk;
1262       break;
1263     case FRV_OPERAND_FRJ :
1264       value = fields->f_FRj;
1265       break;
1266     case FRV_OPERAND_FRK :
1267       value = fields->f_FRk;
1268       break;
1269     case FRV_OPERAND_FRKHI :
1270       value = fields->f_FRk;
1271       break;
1272     case FRV_OPERAND_FRKLO :
1273       value = fields->f_FRk;
1274       break;
1275     case FRV_OPERAND_GRDOUBLEK :
1276       value = fields->f_GRk;
1277       break;
1278     case FRV_OPERAND_GRI :
1279       value = fields->f_GRi;
1280       break;
1281     case FRV_OPERAND_GRJ :
1282       value = fields->f_GRj;
1283       break;
1284     case FRV_OPERAND_GRK :
1285       value = fields->f_GRk;
1286       break;
1287     case FRV_OPERAND_GRKHI :
1288       value = fields->f_GRk;
1289       break;
1290     case FRV_OPERAND_GRKLO :
1291       value = fields->f_GRk;
1292       break;
1293     case FRV_OPERAND_ICCI_1 :
1294       value = fields->f_ICCi_1;
1295       break;
1296     case FRV_OPERAND_ICCI_2 :
1297       value = fields->f_ICCi_2;
1298       break;
1299     case FRV_OPERAND_ICCI_3 :
1300       value = fields->f_ICCi_3;
1301       break;
1302     case FRV_OPERAND_LI :
1303       value = fields->f_LI;
1304       break;
1305     case FRV_OPERAND_AE :
1306       value = fields->f_ae;
1307       break;
1308     case FRV_OPERAND_CCOND :
1309       value = fields->f_ccond;
1310       break;
1311     case FRV_OPERAND_COND :
1312       value = fields->f_cond;
1313       break;
1314     case FRV_OPERAND_D12 :
1315       value = fields->f_d12;
1316       break;
1317     case FRV_OPERAND_DEBUG :
1318       value = fields->f_debug;
1319       break;
1320     case FRV_OPERAND_EIR :
1321       value = fields->f_eir;
1322       break;
1323     case FRV_OPERAND_HINT :
1324       value = fields->f_hint;
1325       break;
1326     case FRV_OPERAND_HINT_NOT_TAKEN :
1327       value = fields->f_hint;
1328       break;
1329     case FRV_OPERAND_HINT_TAKEN :
1330       value = fields->f_hint;
1331       break;
1332     case FRV_OPERAND_LABEL16 :
1333       value = fields->f_label16;
1334       break;
1335     case FRV_OPERAND_LABEL24 :
1336       value = fields->f_label24;
1337       break;
1338     case FRV_OPERAND_LOCK :
1339       value = fields->f_lock;
1340       break;
1341     case FRV_OPERAND_PACK :
1342       value = fields->f_pack;
1343       break;
1344     case FRV_OPERAND_S10 :
1345       value = fields->f_s10;
1346       break;
1347     case FRV_OPERAND_S12 :
1348       value = fields->f_d12;
1349       break;
1350     case FRV_OPERAND_S16 :
1351       value = fields->f_s16;
1352       break;
1353     case FRV_OPERAND_S5 :
1354       value = fields->f_s5;
1355       break;
1356     case FRV_OPERAND_S6 :
1357       value = fields->f_s6;
1358       break;
1359     case FRV_OPERAND_S6_1 :
1360       value = fields->f_s6_1;
1361       break;
1362     case FRV_OPERAND_SLO16 :
1363       value = fields->f_s16;
1364       break;
1365     case FRV_OPERAND_SPR :
1366       value = fields->f_spr;
1367       break;
1368     case FRV_OPERAND_U12 :
1369       value = fields->f_u12;
1370       break;
1371     case FRV_OPERAND_U16 :
1372       value = fields->f_u16;
1373       break;
1374     case FRV_OPERAND_U6 :
1375       value = fields->f_u6;
1376       break;
1377     case FRV_OPERAND_UHI16 :
1378       value = fields->f_u16;
1379       break;
1380     case FRV_OPERAND_ULO16 :
1381       value = fields->f_u16;
1382       break;
1383
1384     default :
1385       /* xgettext:c-format */
1386       fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
1387                        opindex);
1388       abort ();
1389   }
1390
1391   return value;
1392 }
1393
1394 bfd_vma
1395 frv_cgen_get_vma_operand (cd, opindex, fields)
1396      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1397      int opindex;
1398      const CGEN_FIELDS * fields;
1399 {
1400   bfd_vma value;
1401
1402   switch (opindex)
1403     {
1404     case FRV_OPERAND_A0 :
1405       value = fields->f_A;
1406       break;
1407     case FRV_OPERAND_A1 :
1408       value = fields->f_A;
1409       break;
1410     case FRV_OPERAND_ACC40SI :
1411       value = fields->f_ACC40Si;
1412       break;
1413     case FRV_OPERAND_ACC40SK :
1414       value = fields->f_ACC40Sk;
1415       break;
1416     case FRV_OPERAND_ACC40UI :
1417       value = fields->f_ACC40Ui;
1418       break;
1419     case FRV_OPERAND_ACC40UK :
1420       value = fields->f_ACC40Uk;
1421       break;
1422     case FRV_OPERAND_ACCGI :
1423       value = fields->f_ACCGi;
1424       break;
1425     case FRV_OPERAND_ACCGK :
1426       value = fields->f_ACCGk;
1427       break;
1428     case FRV_OPERAND_CCI :
1429       value = fields->f_CCi;
1430       break;
1431     case FRV_OPERAND_CPRDOUBLEK :
1432       value = fields->f_CPRk;
1433       break;
1434     case FRV_OPERAND_CPRI :
1435       value = fields->f_CPRi;
1436       break;
1437     case FRV_OPERAND_CPRJ :
1438       value = fields->f_CPRj;
1439       break;
1440     case FRV_OPERAND_CPRK :
1441       value = fields->f_CPRk;
1442       break;
1443     case FRV_OPERAND_CRI :
1444       value = fields->f_CRi;
1445       break;
1446     case FRV_OPERAND_CRJ :
1447       value = fields->f_CRj;
1448       break;
1449     case FRV_OPERAND_CRJ_FLOAT :
1450       value = fields->f_CRj_float;
1451       break;
1452     case FRV_OPERAND_CRJ_INT :
1453       value = fields->f_CRj_int;
1454       break;
1455     case FRV_OPERAND_CRK :
1456       value = fields->f_CRk;
1457       break;
1458     case FRV_OPERAND_FCCI_1 :
1459       value = fields->f_FCCi_1;
1460       break;
1461     case FRV_OPERAND_FCCI_2 :
1462       value = fields->f_FCCi_2;
1463       break;
1464     case FRV_OPERAND_FCCI_3 :
1465       value = fields->f_FCCi_3;
1466       break;
1467     case FRV_OPERAND_FCCK :
1468       value = fields->f_FCCk;
1469       break;
1470     case FRV_OPERAND_FRDOUBLEI :
1471       value = fields->f_FRi;
1472       break;
1473     case FRV_OPERAND_FRDOUBLEJ :
1474       value = fields->f_FRj;
1475       break;
1476     case FRV_OPERAND_FRDOUBLEK :
1477       value = fields->f_FRk;
1478       break;
1479     case FRV_OPERAND_FRI :
1480       value = fields->f_FRi;
1481       break;
1482     case FRV_OPERAND_FRINTI :
1483       value = fields->f_FRi;
1484       break;
1485     case FRV_OPERAND_FRINTIEVEN :
1486       value = fields->f_FRi;
1487       break;
1488     case FRV_OPERAND_FRINTJ :
1489       value = fields->f_FRj;
1490       break;
1491     case FRV_OPERAND_FRINTJEVEN :
1492       value = fields->f_FRj;
1493       break;
1494     case FRV_OPERAND_FRINTK :
1495       value = fields->f_FRk;
1496       break;
1497     case FRV_OPERAND_FRINTKEVEN :
1498       value = fields->f_FRk;
1499       break;
1500     case FRV_OPERAND_FRJ :
1501       value = fields->f_FRj;
1502       break;
1503     case FRV_OPERAND_FRK :
1504       value = fields->f_FRk;
1505       break;
1506     case FRV_OPERAND_FRKHI :
1507       value = fields->f_FRk;
1508       break;
1509     case FRV_OPERAND_FRKLO :
1510       value = fields->f_FRk;
1511       break;
1512     case FRV_OPERAND_GRDOUBLEK :
1513       value = fields->f_GRk;
1514       break;
1515     case FRV_OPERAND_GRI :
1516       value = fields->f_GRi;
1517       break;
1518     case FRV_OPERAND_GRJ :
1519       value = fields->f_GRj;
1520       break;
1521     case FRV_OPERAND_GRK :
1522       value = fields->f_GRk;
1523       break;
1524     case FRV_OPERAND_GRKHI :
1525       value = fields->f_GRk;
1526       break;
1527     case FRV_OPERAND_GRKLO :
1528       value = fields->f_GRk;
1529       break;
1530     case FRV_OPERAND_ICCI_1 :
1531       value = fields->f_ICCi_1;
1532       break;
1533     case FRV_OPERAND_ICCI_2 :
1534       value = fields->f_ICCi_2;
1535       break;
1536     case FRV_OPERAND_ICCI_3 :
1537       value = fields->f_ICCi_3;
1538       break;
1539     case FRV_OPERAND_LI :
1540       value = fields->f_LI;
1541       break;
1542     case FRV_OPERAND_AE :
1543       value = fields->f_ae;
1544       break;
1545     case FRV_OPERAND_CCOND :
1546       value = fields->f_ccond;
1547       break;
1548     case FRV_OPERAND_COND :
1549       value = fields->f_cond;
1550       break;
1551     case FRV_OPERAND_D12 :
1552       value = fields->f_d12;
1553       break;
1554     case FRV_OPERAND_DEBUG :
1555       value = fields->f_debug;
1556       break;
1557     case FRV_OPERAND_EIR :
1558       value = fields->f_eir;
1559       break;
1560     case FRV_OPERAND_HINT :
1561       value = fields->f_hint;
1562       break;
1563     case FRV_OPERAND_HINT_NOT_TAKEN :
1564       value = fields->f_hint;
1565       break;
1566     case FRV_OPERAND_HINT_TAKEN :
1567       value = fields->f_hint;
1568       break;
1569     case FRV_OPERAND_LABEL16 :
1570       value = fields->f_label16;
1571       break;
1572     case FRV_OPERAND_LABEL24 :
1573       value = fields->f_label24;
1574       break;
1575     case FRV_OPERAND_LOCK :
1576       value = fields->f_lock;
1577       break;
1578     case FRV_OPERAND_PACK :
1579       value = fields->f_pack;
1580       break;
1581     case FRV_OPERAND_S10 :
1582       value = fields->f_s10;
1583       break;
1584     case FRV_OPERAND_S12 :
1585       value = fields->f_d12;
1586       break;
1587     case FRV_OPERAND_S16 :
1588       value = fields->f_s16;
1589       break;
1590     case FRV_OPERAND_S5 :
1591       value = fields->f_s5;
1592       break;
1593     case FRV_OPERAND_S6 :
1594       value = fields->f_s6;
1595       break;
1596     case FRV_OPERAND_S6_1 :
1597       value = fields->f_s6_1;
1598       break;
1599     case FRV_OPERAND_SLO16 :
1600       value = fields->f_s16;
1601       break;
1602     case FRV_OPERAND_SPR :
1603       value = fields->f_spr;
1604       break;
1605     case FRV_OPERAND_U12 :
1606       value = fields->f_u12;
1607       break;
1608     case FRV_OPERAND_U16 :
1609       value = fields->f_u16;
1610       break;
1611     case FRV_OPERAND_U6 :
1612       value = fields->f_u6;
1613       break;
1614     case FRV_OPERAND_UHI16 :
1615       value = fields->f_u16;
1616       break;
1617     case FRV_OPERAND_ULO16 :
1618       value = fields->f_u16;
1619       break;
1620
1621     default :
1622       /* xgettext:c-format */
1623       fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
1624                        opindex);
1625       abort ();
1626   }
1627
1628   return value;
1629 }
1630
1631 void frv_cgen_set_int_operand
1632   PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int));
1633 void frv_cgen_set_vma_operand
1634   PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma));
1635
1636 /* Stuffing values in cgen_fields is handled by a collection of functions.
1637    They are distinguished by the type of the VALUE argument they accept.
1638    TODO: floating point, inlining support, remove cases where argument type
1639    not appropriate.  */
1640
1641 void
1642 frv_cgen_set_int_operand (cd, opindex, fields, value)
1643      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1644      int opindex;
1645      CGEN_FIELDS * fields;
1646      int value;
1647 {
1648   switch (opindex)
1649     {
1650     case FRV_OPERAND_A0 :
1651       fields->f_A = value;
1652       break;
1653     case FRV_OPERAND_A1 :
1654       fields->f_A = value;
1655       break;
1656     case FRV_OPERAND_ACC40SI :
1657       fields->f_ACC40Si = value;
1658       break;
1659     case FRV_OPERAND_ACC40SK :
1660       fields->f_ACC40Sk = value;
1661       break;
1662     case FRV_OPERAND_ACC40UI :
1663       fields->f_ACC40Ui = value;
1664       break;
1665     case FRV_OPERAND_ACC40UK :
1666       fields->f_ACC40Uk = value;
1667       break;
1668     case FRV_OPERAND_ACCGI :
1669       fields->f_ACCGi = value;
1670       break;
1671     case FRV_OPERAND_ACCGK :
1672       fields->f_ACCGk = value;
1673       break;
1674     case FRV_OPERAND_CCI :
1675       fields->f_CCi = value;
1676       break;
1677     case FRV_OPERAND_CPRDOUBLEK :
1678       fields->f_CPRk = value;
1679       break;
1680     case FRV_OPERAND_CPRI :
1681       fields->f_CPRi = value;
1682       break;
1683     case FRV_OPERAND_CPRJ :
1684       fields->f_CPRj = value;
1685       break;
1686     case FRV_OPERAND_CPRK :
1687       fields->f_CPRk = value;
1688       break;
1689     case FRV_OPERAND_CRI :
1690       fields->f_CRi = value;
1691       break;
1692     case FRV_OPERAND_CRJ :
1693       fields->f_CRj = value;
1694       break;
1695     case FRV_OPERAND_CRJ_FLOAT :
1696       fields->f_CRj_float = value;
1697       break;
1698     case FRV_OPERAND_CRJ_INT :
1699       fields->f_CRj_int = value;
1700       break;
1701     case FRV_OPERAND_CRK :
1702       fields->f_CRk = value;
1703       break;
1704     case FRV_OPERAND_FCCI_1 :
1705       fields->f_FCCi_1 = value;
1706       break;
1707     case FRV_OPERAND_FCCI_2 :
1708       fields->f_FCCi_2 = value;
1709       break;
1710     case FRV_OPERAND_FCCI_3 :
1711       fields->f_FCCi_3 = value;
1712       break;
1713     case FRV_OPERAND_FCCK :
1714       fields->f_FCCk = value;
1715       break;
1716     case FRV_OPERAND_FRDOUBLEI :
1717       fields->f_FRi = value;
1718       break;
1719     case FRV_OPERAND_FRDOUBLEJ :
1720       fields->f_FRj = value;
1721       break;
1722     case FRV_OPERAND_FRDOUBLEK :
1723       fields->f_FRk = value;
1724       break;
1725     case FRV_OPERAND_FRI :
1726       fields->f_FRi = value;
1727       break;
1728     case FRV_OPERAND_FRINTI :
1729       fields->f_FRi = value;
1730       break;
1731     case FRV_OPERAND_FRINTIEVEN :
1732       fields->f_FRi = value;
1733       break;
1734     case FRV_OPERAND_FRINTJ :
1735       fields->f_FRj = value;
1736       break;
1737     case FRV_OPERAND_FRINTJEVEN :
1738       fields->f_FRj = value;
1739       break;
1740     case FRV_OPERAND_FRINTK :
1741       fields->f_FRk = value;
1742       break;
1743     case FRV_OPERAND_FRINTKEVEN :
1744       fields->f_FRk = value;
1745       break;
1746     case FRV_OPERAND_FRJ :
1747       fields->f_FRj = value;
1748       break;
1749     case FRV_OPERAND_FRK :
1750       fields->f_FRk = value;
1751       break;
1752     case FRV_OPERAND_FRKHI :
1753       fields->f_FRk = value;
1754       break;
1755     case FRV_OPERAND_FRKLO :
1756       fields->f_FRk = value;
1757       break;
1758     case FRV_OPERAND_GRDOUBLEK :
1759       fields->f_GRk = value;
1760       break;
1761     case FRV_OPERAND_GRI :
1762       fields->f_GRi = value;
1763       break;
1764     case FRV_OPERAND_GRJ :
1765       fields->f_GRj = value;
1766       break;
1767     case FRV_OPERAND_GRK :
1768       fields->f_GRk = value;
1769       break;
1770     case FRV_OPERAND_GRKHI :
1771       fields->f_GRk = value;
1772       break;
1773     case FRV_OPERAND_GRKLO :
1774       fields->f_GRk = value;
1775       break;
1776     case FRV_OPERAND_ICCI_1 :
1777       fields->f_ICCi_1 = value;
1778       break;
1779     case FRV_OPERAND_ICCI_2 :
1780       fields->f_ICCi_2 = value;
1781       break;
1782     case FRV_OPERAND_ICCI_3 :
1783       fields->f_ICCi_3 = value;
1784       break;
1785     case FRV_OPERAND_LI :
1786       fields->f_LI = value;
1787       break;
1788     case FRV_OPERAND_AE :
1789       fields->f_ae = value;
1790       break;
1791     case FRV_OPERAND_CCOND :
1792       fields->f_ccond = value;
1793       break;
1794     case FRV_OPERAND_COND :
1795       fields->f_cond = value;
1796       break;
1797     case FRV_OPERAND_D12 :
1798       fields->f_d12 = value;
1799       break;
1800     case FRV_OPERAND_DEBUG :
1801       fields->f_debug = value;
1802       break;
1803     case FRV_OPERAND_EIR :
1804       fields->f_eir = value;
1805       break;
1806     case FRV_OPERAND_HINT :
1807       fields->f_hint = value;
1808       break;
1809     case FRV_OPERAND_HINT_NOT_TAKEN :
1810       fields->f_hint = value;
1811       break;
1812     case FRV_OPERAND_HINT_TAKEN :
1813       fields->f_hint = value;
1814       break;
1815     case FRV_OPERAND_LABEL16 :
1816       fields->f_label16 = value;
1817       break;
1818     case FRV_OPERAND_LABEL24 :
1819       fields->f_label24 = value;
1820       break;
1821     case FRV_OPERAND_LOCK :
1822       fields->f_lock = value;
1823       break;
1824     case FRV_OPERAND_PACK :
1825       fields->f_pack = value;
1826       break;
1827     case FRV_OPERAND_S10 :
1828       fields->f_s10 = value;
1829       break;
1830     case FRV_OPERAND_S12 :
1831       fields->f_d12 = value;
1832       break;
1833     case FRV_OPERAND_S16 :
1834       fields->f_s16 = value;
1835       break;
1836     case FRV_OPERAND_S5 :
1837       fields->f_s5 = value;
1838       break;
1839     case FRV_OPERAND_S6 :
1840       fields->f_s6 = value;
1841       break;
1842     case FRV_OPERAND_S6_1 :
1843       fields->f_s6_1 = value;
1844       break;
1845     case FRV_OPERAND_SLO16 :
1846       fields->f_s16 = value;
1847       break;
1848     case FRV_OPERAND_SPR :
1849       fields->f_spr = value;
1850       break;
1851     case FRV_OPERAND_U12 :
1852       fields->f_u12 = value;
1853       break;
1854     case FRV_OPERAND_U16 :
1855       fields->f_u16 = value;
1856       break;
1857     case FRV_OPERAND_U6 :
1858       fields->f_u6 = value;
1859       break;
1860     case FRV_OPERAND_UHI16 :
1861       fields->f_u16 = value;
1862       break;
1863     case FRV_OPERAND_ULO16 :
1864       fields->f_u16 = value;
1865       break;
1866
1867     default :
1868       /* xgettext:c-format */
1869       fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
1870                        opindex);
1871       abort ();
1872   }
1873 }
1874
1875 void
1876 frv_cgen_set_vma_operand (cd, opindex, fields, value)
1877      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1878      int opindex;
1879      CGEN_FIELDS * fields;
1880      bfd_vma value;
1881 {
1882   switch (opindex)
1883     {
1884     case FRV_OPERAND_A0 :
1885       fields->f_A = value;
1886       break;
1887     case FRV_OPERAND_A1 :
1888       fields->f_A = value;
1889       break;
1890     case FRV_OPERAND_ACC40SI :
1891       fields->f_ACC40Si = value;
1892       break;
1893     case FRV_OPERAND_ACC40SK :
1894       fields->f_ACC40Sk = value;
1895       break;
1896     case FRV_OPERAND_ACC40UI :
1897       fields->f_ACC40Ui = value;
1898       break;
1899     case FRV_OPERAND_ACC40UK :
1900       fields->f_ACC40Uk = value;
1901       break;
1902     case FRV_OPERAND_ACCGI :
1903       fields->f_ACCGi = value;
1904       break;
1905     case FRV_OPERAND_ACCGK :
1906       fields->f_ACCGk = value;
1907       break;
1908     case FRV_OPERAND_CCI :
1909       fields->f_CCi = value;
1910       break;
1911     case FRV_OPERAND_CPRDOUBLEK :
1912       fields->f_CPRk = value;
1913       break;
1914     case FRV_OPERAND_CPRI :
1915       fields->f_CPRi = value;
1916       break;
1917     case FRV_OPERAND_CPRJ :
1918       fields->f_CPRj = value;
1919       break;
1920     case FRV_OPERAND_CPRK :
1921       fields->f_CPRk = value;
1922       break;
1923     case FRV_OPERAND_CRI :
1924       fields->f_CRi = value;
1925       break;
1926     case FRV_OPERAND_CRJ :
1927       fields->f_CRj = value;
1928       break;
1929     case FRV_OPERAND_CRJ_FLOAT :
1930       fields->f_CRj_float = value;
1931       break;
1932     case FRV_OPERAND_CRJ_INT :
1933       fields->f_CRj_int = value;
1934       break;
1935     case FRV_OPERAND_CRK :
1936       fields->f_CRk = value;
1937       break;
1938     case FRV_OPERAND_FCCI_1 :
1939       fields->f_FCCi_1 = value;
1940       break;
1941     case FRV_OPERAND_FCCI_2 :
1942       fields->f_FCCi_2 = value;
1943       break;
1944     case FRV_OPERAND_FCCI_3 :
1945       fields->f_FCCi_3 = value;
1946       break;
1947     case FRV_OPERAND_FCCK :
1948       fields->f_FCCk = value;
1949       break;
1950     case FRV_OPERAND_FRDOUBLEI :
1951       fields->f_FRi = value;
1952       break;
1953     case FRV_OPERAND_FRDOUBLEJ :
1954       fields->f_FRj = value;
1955       break;
1956     case FRV_OPERAND_FRDOUBLEK :
1957       fields->f_FRk = value;
1958       break;
1959     case FRV_OPERAND_FRI :
1960       fields->f_FRi = value;
1961       break;
1962     case FRV_OPERAND_FRINTI :
1963       fields->f_FRi = value;
1964       break;
1965     case FRV_OPERAND_FRINTIEVEN :
1966       fields->f_FRi = value;
1967       break;
1968     case FRV_OPERAND_FRINTJ :
1969       fields->f_FRj = value;
1970       break;
1971     case FRV_OPERAND_FRINTJEVEN :
1972       fields->f_FRj = value;
1973       break;
1974     case FRV_OPERAND_FRINTK :
1975       fields->f_FRk = value;
1976       break;
1977     case FRV_OPERAND_FRINTKEVEN :
1978       fields->f_FRk = value;
1979       break;
1980     case FRV_OPERAND_FRJ :
1981       fields->f_FRj = value;
1982       break;
1983     case FRV_OPERAND_FRK :
1984       fields->f_FRk = value;
1985       break;
1986     case FRV_OPERAND_FRKHI :
1987       fields->f_FRk = value;
1988       break;
1989     case FRV_OPERAND_FRKLO :
1990       fields->f_FRk = value;
1991       break;
1992     case FRV_OPERAND_GRDOUBLEK :
1993       fields->f_GRk = value;
1994       break;
1995     case FRV_OPERAND_GRI :
1996       fields->f_GRi = value;
1997       break;
1998     case FRV_OPERAND_GRJ :
1999       fields->f_GRj = value;
2000       break;
2001     case FRV_OPERAND_GRK :
2002       fields->f_GRk = value;
2003       break;
2004     case FRV_OPERAND_GRKHI :
2005       fields->f_GRk = value;
2006       break;
2007     case FRV_OPERAND_GRKLO :
2008       fields->f_GRk = value;
2009       break;
2010     case FRV_OPERAND_ICCI_1 :
2011       fields->f_ICCi_1 = value;
2012       break;
2013     case FRV_OPERAND_ICCI_2 :
2014       fields->f_ICCi_2 = value;
2015       break;
2016     case FRV_OPERAND_ICCI_3 :
2017       fields->f_ICCi_3 = value;
2018       break;
2019     case FRV_OPERAND_LI :
2020       fields->f_LI = value;
2021       break;
2022     case FRV_OPERAND_AE :
2023       fields->f_ae = value;
2024       break;
2025     case FRV_OPERAND_CCOND :
2026       fields->f_ccond = value;
2027       break;
2028     case FRV_OPERAND_COND :
2029       fields->f_cond = value;
2030       break;
2031     case FRV_OPERAND_D12 :
2032       fields->f_d12 = value;
2033       break;
2034     case FRV_OPERAND_DEBUG :
2035       fields->f_debug = value;
2036       break;
2037     case FRV_OPERAND_EIR :
2038       fields->f_eir = value;
2039       break;
2040     case FRV_OPERAND_HINT :
2041       fields->f_hint = value;
2042       break;
2043     case FRV_OPERAND_HINT_NOT_TAKEN :
2044       fields->f_hint = value;
2045       break;
2046     case FRV_OPERAND_HINT_TAKEN :
2047       fields->f_hint = value;
2048       break;
2049     case FRV_OPERAND_LABEL16 :
2050       fields->f_label16 = value;
2051       break;
2052     case FRV_OPERAND_LABEL24 :
2053       fields->f_label24 = value;
2054       break;
2055     case FRV_OPERAND_LOCK :
2056       fields->f_lock = value;
2057       break;
2058     case FRV_OPERAND_PACK :
2059       fields->f_pack = value;
2060       break;
2061     case FRV_OPERAND_S10 :
2062       fields->f_s10 = value;
2063       break;
2064     case FRV_OPERAND_S12 :
2065       fields->f_d12 = value;
2066       break;
2067     case FRV_OPERAND_S16 :
2068       fields->f_s16 = value;
2069       break;
2070     case FRV_OPERAND_S5 :
2071       fields->f_s5 = value;
2072       break;
2073     case FRV_OPERAND_S6 :
2074       fields->f_s6 = value;
2075       break;
2076     case FRV_OPERAND_S6_1 :
2077       fields->f_s6_1 = value;
2078       break;
2079     case FRV_OPERAND_SLO16 :
2080       fields->f_s16 = value;
2081       break;
2082     case FRV_OPERAND_SPR :
2083       fields->f_spr = value;
2084       break;
2085     case FRV_OPERAND_U12 :
2086       fields->f_u12 = value;
2087       break;
2088     case FRV_OPERAND_U16 :
2089       fields->f_u16 = value;
2090       break;
2091     case FRV_OPERAND_U6 :
2092       fields->f_u6 = value;
2093       break;
2094     case FRV_OPERAND_UHI16 :
2095       fields->f_u16 = value;
2096       break;
2097     case FRV_OPERAND_ULO16 :
2098       fields->f_u16 = value;
2099       break;
2100
2101     default :
2102       /* xgettext:c-format */
2103       fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
2104                        opindex);
2105       abort ();
2106   }
2107 }
2108
2109 /* Function to call before using the instruction builder tables.  */
2110
2111 void
2112 frv_cgen_init_ibld_table (cd)
2113      CGEN_CPU_DESC cd;
2114 {
2115   cd->insert_handlers = & frv_cgen_insert_handlers[0];
2116   cd->extract_handlers = & frv_cgen_extract_handlers[0];
2117
2118   cd->insert_operand = frv_cgen_insert_operand;
2119   cd->extract_operand = frv_cgen_extract_operand;
2120
2121   cd->get_int_operand = frv_cgen_get_int_operand;
2122   cd->set_int_operand = frv_cgen_set_int_operand;
2123   cd->get_vma_operand = frv_cgen_get_vma_operand;
2124   cd->set_vma_operand = frv_cgen_set_vma_operand;
2125 }