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