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