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