contrib/binutils/opcodes/mep-ibld.c

   1 /* Instruction building/extraction support for mep. -*- 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
   7    Free Software Foundation, Inc.
   8
   9    This file is part of the GNU Binutils and GDB, the GNU debugger.
  10
  11    This program 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 2, or (at your option)
  14    any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public 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 "mep-desc.h"
  35 #include "mep-opc.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 > 32)
 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;
 211
 212     if (CGEN_INSN_LSB0_P)
 213       shift = (word_offset + start + 1) - length;
 214     else
 215       shift = total_length - (word_offset + start + length);
 216     *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
 217   }
 218
 219 #else /* ! CGEN_INT_INSN_P */
 220
 221   {
 222     unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
 223
 224     insert_1 (cd, value, start, length, word_length, bufp);
 225   }
 226
 227 #endif /* ! CGEN_INT_INSN_P */
 228
 229   return NULL;
 230 }
 231
 232 /* Default insn builder (insert handler).
 233    The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
 234    that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
 235    recorded in host byte order, otherwise BUFFER is an array of bytes
 236    and the value is recorded in target byte order).
 237    The result is an error message or NULL if success.  */
 238
 239 static const char *
 240 insert_insn_normal (CGEN_CPU_DESC cd,
 241                     const CGEN_INSN * insn,
 242                     CGEN_FIELDS * fields,
 243                     CGEN_INSN_BYTES_PTR buffer,
 244                     bfd_vma pc)
 245 {
 246   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
 247   unsigned long value;
 248   const CGEN_SYNTAX_CHAR_TYPE * syn;
 249
 250   CGEN_INIT_INSERT (cd);
 251   value = CGEN_INSN_BASE_VALUE (insn);
 252
 253   /* If we're recording insns as numbers (rather than a string of bytes),
 254      target byte order handling is deferred until later.  */
 255
 256 #if CGEN_INT_INSN_P
 257
 258   put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
 259                       CGEN_FIELDS_BITSIZE (fields), value);
 260
 261 #else
 262
 263   cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
 264                                         (unsigned) CGEN_FIELDS_BITSIZE (fields)),
 265                        value);
 266
 267 #endif /* ! CGEN_INT_INSN_P */
 268
 269   /* ??? It would be better to scan the format's fields.
 270      Still need to be able to insert a value based on the operand though;
 271      e.g. storing a branch displacement that got resolved later.
 272      Needs more thought first.  */
 273
 274   for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
 275     {
 276       const char *errmsg;
 277
 278       if (CGEN_SYNTAX_CHAR_P (* syn))
 279         continue;
 280
 281       errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
 282                                        fields, buffer, pc);
 283       if (errmsg)
 284         return errmsg;
 285     }
 286
 287   return NULL;
 288 }
 289
 290 #if CGEN_INT_INSN_P
 291 /* Cover function to store an insn value into an integral insn.  Must go here
 292    because it needs <prefix>-desc.h for CGEN_INT_INSN_P.  */
 293
 294 static void
 295 put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 296                     CGEN_INSN_BYTES_PTR buf,
 297                     int length,
 298                     int insn_length,
 299                     CGEN_INSN_INT value)
 300 {
 301   /* For architectures with insns smaller than the base-insn-bitsize,
 302      length may be too big.  */
 303   if (length > insn_length)
 304     *buf = value;
 305   else
 306     {
 307       int shift = insn_length - length;
 308       /* Written this way to avoid undefined behaviour.  */
 309       CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
 310
 311       *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
 312     }
 313 }
 314 #endif
 315 \f
 316 /* Operand extraction.  */
 317
 318 #if ! CGEN_INT_INSN_P
 319
 320 /* Subroutine of extract_normal.
 321    Ensure sufficient bytes are cached in EX_INFO.
 322    OFFSET is the offset in bytes from the start of the insn of the value.
 323    BYTES is the length of the needed value.
 324    Returns 1 for success, 0 for failure.  */
 325
 326 static CGEN_INLINE int
 327 fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 328             CGEN_EXTRACT_INFO *ex_info,
 329             int offset,
 330             int bytes,
 331             bfd_vma pc)
 332 {
 333   /* It's doubtful that the middle part has already been fetched so
 334      we don't optimize that case.  kiss.  */
 335   unsigned int mask;
 336   disassemble_info *info = (disassemble_info *) ex_info->dis_info;
 337
 338   /* First do a quick check.  */
 339   mask = (1 << bytes) - 1;
 340   if (((ex_info->valid >> offset) & mask) == mask)
 341     return 1;
 342
 343   /* Search for the first byte we need to read.  */
 344   for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
 345     if (! (mask & ex_info->valid))
 346       break;
 347
 348   if (bytes)
 349     {
 350       int status;
 351
 352       pc += offset;
 353       status = (*info->read_memory_func)
 354         (pc, ex_info->insn_bytes + offset, bytes, info);
 355
 356       if (status != 0)
 357         {
 358           (*info->memory_error_func) (status, pc, info);
 359           return 0;
 360         }
 361
 362       ex_info->valid |= ((1 << bytes) - 1) << offset;
 363     }
 364
 365   return 1;
 366 }
 367
 368 /* Subroutine of extract_normal.  */
 369
 370 static CGEN_INLINE long
 371 extract_1 (CGEN_CPU_DESC cd,
 372            CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
 373            int start,
 374            int length,
 375            int word_length,
 376            unsigned char *bufp,
 377            bfd_vma pc ATTRIBUTE_UNUSED)
 378 {
 379   unsigned long x;
 380   int shift;
 381
 382   x = cgen_get_insn_value (cd, bufp, word_length);
 383
 384   if (CGEN_INSN_LSB0_P)
 385     shift = (start + 1) - length;
 386   else
 387     shift = (word_length - (start + length));
 388   return x >> shift;
 389 }
 390
 391 #endif /* ! CGEN_INT_INSN_P */
 392
 393 /* Default extraction routine.
 394
 395    INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
 396    or sometimes less for cases like the m32r where the base insn size is 32
 397    but some insns are 16 bits.
 398    ATTRS is a mask of the boolean attributes.  We only need `SIGNED',
 399    but for generality we take a bitmask of all of them.
 400    WORD_OFFSET is the offset in bits from the start of the insn of the value.
 401    WORD_LENGTH is the length of the word in bits in which the value resides.
 402    START is the starting bit number in the word, architecture origin.
 403    LENGTH is the length of VALUE in bits.
 404    TOTAL_LENGTH is the total length of the insn in bits.
 405
 406    Returns 1 for success, 0 for failure.  */
 407
 408 /* ??? The return code isn't properly used.  wip.  */
 409
 410 /* ??? This doesn't handle bfd_vma's.  Create another function when
 411    necessary.  */
 412
 413 static int
 414 extract_normal (CGEN_CPU_DESC cd,
 415 #if ! CGEN_INT_INSN_P
 416                 CGEN_EXTRACT_INFO *ex_info,
 417 #else
 418                 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
 419 #endif
 420                 CGEN_INSN_INT insn_value,
 421                 unsigned int attrs,
 422                 unsigned int word_offset,
 423                 unsigned int start,
 424                 unsigned int length,
 425                 unsigned int word_length,
 426                 unsigned int total_length,
 427 #if ! CGEN_INT_INSN_P
 428                 bfd_vma pc,
 429 #else
 430                 bfd_vma pc ATTRIBUTE_UNUSED,
 431 #endif
 432                 long *valuep)
 433 {
 434   long value, mask;
 435
 436   /* If LENGTH is zero, this operand doesn't contribute to the value
 437      so give it a standard value of zero.  */
 438   if (length == 0)
 439     {
 440       *valuep = 0;
 441       return 1;
 442     }
 443
 444   if (word_length > 32)
 445     abort ();
 446
 447   /* For architectures with insns smaller than the insn-base-bitsize,
 448      word_length may be too big.  */
 449   if (cd->min_insn_bitsize < cd->base_insn_bitsize)
 450     {
 451       if (word_offset + word_length > total_length)
 452         word_length = total_length - word_offset;
 453     }
 454
 455   /* Does the value reside in INSN_VALUE, and at the right alignment?  */
 456
 457   if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
 458     {
 459       if (CGEN_INSN_LSB0_P)
 460         value = insn_value >> ((word_offset + start + 1) - length);
 461       else
 462         value = insn_value >> (total_length - ( word_offset + start + length));
 463     }
 464
 465 #if ! CGEN_INT_INSN_P
 466
 467   else
 468     {
 469       unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
 470
 471       if (word_length > 32)
 472         abort ();
 473
 474       if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
 475         return 0;
 476
 477       value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
 478     }
 479
 480 #endif /* ! CGEN_INT_INSN_P */
 481
 482   /* Written this way to avoid undefined behaviour.  */
 483   mask = (((1L << (length - 1)) - 1) << 1) | 1;
 484
 485   value &= mask;
 486   /* sign extend? */
 487   if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
 488       && (value & (1L << (length - 1))))
 489     value |= ~mask;
 490
 491   *valuep = value;
 492
 493   return 1;
 494 }
 495
 496 /* Default insn extractor.
 497
 498    INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
 499    The extracted fields are stored in FIELDS.
 500    EX_INFO is used to handle reading variable length insns.
 501    Return the length of the insn in bits, or 0 if no match,
 502    or -1 if an error occurs fetching data (memory_error_func will have
 503    been called).  */
 504
 505 static int
 506 extract_insn_normal (CGEN_CPU_DESC cd,
 507                      const CGEN_INSN *insn,
 508                      CGEN_EXTRACT_INFO *ex_info,
 509                      CGEN_INSN_INT insn_value,
 510                      CGEN_FIELDS *fields,
 511                      bfd_vma pc)
 512 {
 513   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
 514   const CGEN_SYNTAX_CHAR_TYPE *syn;
 515
 516   CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
 517
 518   CGEN_INIT_EXTRACT (cd);
 519
 520   for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
 521     {
 522       int length;
 523
 524       if (CGEN_SYNTAX_CHAR_P (*syn))
 525         continue;
 526
 527       length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
 528                                         ex_info, insn_value, fields, pc);
 529       if (length <= 0)
 530         return length;
 531     }
 532
 533   /* We recognized and successfully extracted this insn.  */
 534   return CGEN_INSN_BITSIZE (insn);
 535 }
 536 \f
 537 /* Machine generated code added here.  */
 538
 539 const char * mep_cgen_insert_operand
 540   (CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
 541
 542 /* Main entry point for operand insertion.
 543
 544    This function is basically just a big switch statement.  Earlier versions
 545    used tables to look up the function to use, but
 546    - if the table contains both assembler and disassembler functions then
 547      the disassembler contains much of the assembler and vice-versa,
 548    - there's a lot of inlining possibilities as things grow,
 549    - using a switch statement avoids the function call overhead.
 550
 551    This function could be moved into `parse_insn_normal', but keeping it
 552    separate makes clear the interface between `parse_insn_normal' and each of
 553    the handlers.  It's also needed by GAS to insert operands that couldn't be
 554    resolved during parsing.  */
 555
 556 const char *
 557 mep_cgen_insert_operand (CGEN_CPU_DESC cd,
 558                              int opindex,
 559                              CGEN_FIELDS * fields,
 560                              CGEN_INSN_BYTES_PTR buffer,
 561                              bfd_vma pc ATTRIBUTE_UNUSED)
 562 {
 563   const char * errmsg = NULL;
 564   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 565
 566   switch (opindex)
 567     {
 568     case MEP_OPERAND_ADDR24A4 :
 569       {
 570 {
 571   FLD (f_24u8a4n_hi) = ((unsigned int) (FLD (f_24u8a4n)) >> (8));
 572   FLD (f_24u8a4n_lo) = ((unsigned int) (((FLD (f_24u8a4n)) & (252))) >> (2));
 573 }
 574         errmsg = insert_normal (cd, fields->f_24u8a4n_hi, 0, 0, 16, 16, 32, total_length, buffer);
 575         if (errmsg)
 576           break;
 577         errmsg = insert_normal (cd, fields->f_24u8a4n_lo, 0, 0, 8, 6, 32, total_length, buffer);
 578         if (errmsg)
 579           break;
 580       }
 581       break;
 582     case MEP_OPERAND_CALLNUM :
 583       {
 584 {
 585   FLD (f_5) = ((((unsigned int) (FLD (f_callnum)) >> (3))) & (1));
 586   FLD (f_6) = ((((unsigned int) (FLD (f_callnum)) >> (2))) & (1));
 587   FLD (f_7) = ((((unsigned int) (FLD (f_callnum)) >> (1))) & (1));
 588   FLD (f_11) = ((FLD (f_callnum)) & (1));
 589 }
 590         errmsg = insert_normal (cd, fields->f_5, 0, 0, 5, 1, 32, total_length, buffer);
 591         if (errmsg)
 592           break;
 593         errmsg = insert_normal (cd, fields->f_6, 0, 0, 6, 1, 32, total_length, buffer);
 594         if (errmsg)
 595           break;
 596         errmsg = insert_normal (cd, fields->f_7, 0, 0, 7, 1, 32, total_length, buffer);
 597         if (errmsg)
 598           break;
 599         errmsg = insert_normal (cd, fields->f_11, 0, 0, 11, 1, 32, total_length, buffer);
 600         if (errmsg)
 601           break;
 602       }
 603       break;
 604     case MEP_OPERAND_CCCC :
 605       errmsg = insert_normal (cd, fields->f_rm, 0, 0, 8, 4, 32, total_length, buffer);
 606       break;
 607     case MEP_OPERAND_CCRN :
 608       {
 609 {
 610   FLD (f_ccrn_hi) = ((((unsigned int) (FLD (f_ccrn)) >> (4))) & (3));
 611   FLD (f_ccrn_lo) = ((FLD (f_ccrn)) & (15));
 612 }
 613         errmsg = insert_normal (cd, fields->f_ccrn_hi, 0, 0, 28, 2, 32, total_length, buffer);
 614         if (errmsg)
 615           break;
 616         errmsg = insert_normal (cd, fields->f_ccrn_lo, 0, 0, 4, 4, 32, total_length, buffer);
 617         if (errmsg)
 618           break;
 619       }
 620       break;
 621     case MEP_OPERAND_CDISP8 :
 622       errmsg = insert_normal (cd, fields->f_8s24, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 8, 32, total_length, buffer);
 623       break;
 624     case MEP_OPERAND_CDISP8A2 :
 625       {
 626         long value = fields->f_8s24a2;
 627         value = ((int) (value) >> (1));
 628         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 7, 32, total_length, buffer);
 629       }
 630       break;
 631     case MEP_OPERAND_CDISP8A4 :
 632       {
 633         long value = fields->f_8s24a4;
 634         value = ((int) (value) >> (2));
 635         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 6, 32, total_length, buffer);
 636       }
 637       break;
 638     case MEP_OPERAND_CDISP8A8 :
 639       {
 640         long value = fields->f_8s24a8;
 641         value = ((int) (value) >> (3));
 642         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 5, 32, total_length, buffer);
 643       }
 644       break;
 645     case MEP_OPERAND_CIMM4 :
 646       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 647       break;
 648     case MEP_OPERAND_CIMM5 :
 649       errmsg = insert_normal (cd, fields->f_5u24, 0, 0, 24, 5, 32, total_length, buffer);
 650       break;
 651     case MEP_OPERAND_CODE16 :
 652       errmsg = insert_normal (cd, fields->f_16u16, 0, 0, 16, 16, 32, total_length, buffer);
 653       break;
 654     case MEP_OPERAND_CODE24 :
 655       {
 656 {
 657   FLD (f_24u4n_hi) = ((unsigned int) (FLD (f_24u4n)) >> (16));
 658   FLD (f_24u4n_lo) = ((FLD (f_24u4n)) & (65535));
 659 }
 660         errmsg = insert_normal (cd, fields->f_24u4n_hi, 0, 0, 4, 8, 32, total_length, buffer);
 661         if (errmsg)
 662           break;
 663         errmsg = insert_normal (cd, fields->f_24u4n_lo, 0, 0, 16, 16, 32, total_length, buffer);
 664         if (errmsg)
 665           break;
 666       }
 667       break;
 668     case MEP_OPERAND_CP_FLAG :
 669       break;
 670     case MEP_OPERAND_CRN :
 671       errmsg = insert_normal (cd, fields->f_crn, 0, 0, 4, 4, 32, total_length, buffer);
 672       break;
 673     case MEP_OPERAND_CRN64 :
 674       errmsg = insert_normal (cd, fields->f_crn, 0, 0, 4, 4, 32, total_length, buffer);
 675       break;
 676     case MEP_OPERAND_CRNX :
 677       {
 678 {
 679   FLD (f_crnx_lo) = ((FLD (f_crnx)) & (15));
 680   FLD (f_crnx_hi) = ((unsigned int) (FLD (f_crnx)) >> (4));
 681 }
 682         errmsg = insert_normal (cd, fields->f_crnx_hi, 0, 0, 28, 1, 32, total_length, buffer);
 683         if (errmsg)
 684           break;
 685         errmsg = insert_normal (cd, fields->f_crnx_lo, 0, 0, 4, 4, 32, total_length, buffer);
 686         if (errmsg)
 687           break;
 688       }
 689       break;
 690     case MEP_OPERAND_CRNX64 :
 691       {
 692 {
 693   FLD (f_crnx_lo) = ((FLD (f_crnx)) & (15));
 694   FLD (f_crnx_hi) = ((unsigned int) (FLD (f_crnx)) >> (4));
 695 }
 696         errmsg = insert_normal (cd, fields->f_crnx_hi, 0, 0, 28, 1, 32, total_length, buffer);
 697         if (errmsg)
 698           break;
 699         errmsg = insert_normal (cd, fields->f_crnx_lo, 0, 0, 4, 4, 32, total_length, buffer);
 700         if (errmsg)
 701           break;
 702       }
 703       break;
 704     case MEP_OPERAND_CSRN :
 705       {
 706 {
 707   FLD (f_csrn_lo) = ((FLD (f_csrn)) & (15));
 708   FLD (f_csrn_hi) = ((unsigned int) (FLD (f_csrn)) >> (4));
 709 }
 710         errmsg = insert_normal (cd, fields->f_csrn_hi, 0, 0, 15, 1, 32, total_length, buffer);
 711         if (errmsg)
 712           break;
 713         errmsg = insert_normal (cd, fields->f_csrn_lo, 0, 0, 8, 4, 32, total_length, buffer);
 714         if (errmsg)
 715           break;
 716       }
 717       break;
 718     case MEP_OPERAND_CSRN_IDX :
 719       {
 720 {
 721   FLD (f_csrn_lo) = ((FLD (f_csrn)) & (15));
 722   FLD (f_csrn_hi) = ((unsigned int) (FLD (f_csrn)) >> (4));
 723 }
 724         errmsg = insert_normal (cd, fields->f_csrn_hi, 0, 0, 15, 1, 32, total_length, buffer);
 725         if (errmsg)
 726           break;
 727         errmsg = insert_normal (cd, fields->f_csrn_lo, 0, 0, 8, 4, 32, total_length, buffer);
 728         if (errmsg)
 729           break;
 730       }
 731       break;
 732     case MEP_OPERAND_DBG :
 733       break;
 734     case MEP_OPERAND_DEPC :
 735       break;
 736     case MEP_OPERAND_EPC :
 737       break;
 738     case MEP_OPERAND_EXC :
 739       break;
 740     case MEP_OPERAND_FMAX_CCRN :
 741       errmsg = insert_normal (cd, fields->f_fmax_4_4, 0, 0, 4, 4, 32, total_length, buffer);
 742       break;
 743     case MEP_OPERAND_FMAX_FRD :
 744       {
 745 {
 746   FLD (f_fmax_4_4) = ((FLD (f_fmax_frd)) & (15));
 747   FLD (f_fmax_28_1) = ((unsigned int) (FLD (f_fmax_frd)) >> (4));
 748 }
 749         errmsg = insert_normal (cd, fields->f_fmax_28_1, 0, 0, 28, 1, 32, total_length, buffer);
 750         if (errmsg)
 751           break;
 752         errmsg = insert_normal (cd, fields->f_fmax_4_4, 0, 0, 4, 4, 32, total_length, buffer);
 753         if (errmsg)
 754           break;
 755       }
 756       break;
 757     case MEP_OPERAND_FMAX_FRD_INT :
 758       {
 759 {
 760   FLD (f_fmax_4_4) = ((FLD (f_fmax_frd)) & (15));
 761   FLD (f_fmax_28_1) = ((unsigned int) (FLD (f_fmax_frd)) >> (4));
 762 }
 763         errmsg = insert_normal (cd, fields->f_fmax_28_1, 0, 0, 28, 1, 32, total_length, buffer);
 764         if (errmsg)
 765           break;
 766         errmsg = insert_normal (cd, fields->f_fmax_4_4, 0, 0, 4, 4, 32, total_length, buffer);
 767         if (errmsg)
 768           break;
 769       }
 770       break;
 771     case MEP_OPERAND_FMAX_FRM :
 772       {
 773 {
 774   FLD (f_fmax_24_4) = ((FLD (f_fmax_frm)) & (15));
 775   FLD (f_fmax_30_1) = ((unsigned int) (FLD (f_fmax_frm)) >> (4));
 776 }
 777         errmsg = insert_normal (cd, fields->f_fmax_30_1, 0, 0, 30, 1, 32, total_length, buffer);
 778         if (errmsg)
 779           break;
 780         errmsg = insert_normal (cd, fields->f_fmax_24_4, 0, 0, 24, 4, 32, total_length, buffer);
 781         if (errmsg)
 782           break;
 783       }
 784       break;
 785     case MEP_OPERAND_FMAX_FRN :
 786       {
 787 {
 788   FLD (f_fmax_20_4) = ((FLD (f_fmax_frn)) & (15));
 789   FLD (f_fmax_29_1) = ((unsigned int) (FLD (f_fmax_frn)) >> (4));
 790 }
 791         errmsg = insert_normal (cd, fields->f_fmax_29_1, 0, 0, 29, 1, 32, total_length, buffer);
 792         if (errmsg)
 793           break;
 794         errmsg = insert_normal (cd, fields->f_fmax_20_4, 0, 0, 20, 4, 32, total_length, buffer);
 795         if (errmsg)
 796           break;
 797       }
 798       break;
 799     case MEP_OPERAND_FMAX_FRN_INT :
 800       {
 801 {
 802   FLD (f_fmax_20_4) = ((FLD (f_fmax_frn)) & (15));
 803   FLD (f_fmax_29_1) = ((unsigned int) (FLD (f_fmax_frn)) >> (4));
 804 }
 805         errmsg = insert_normal (cd, fields->f_fmax_29_1, 0, 0, 29, 1, 32, total_length, buffer);
 806         if (errmsg)
 807           break;
 808         errmsg = insert_normal (cd, fields->f_fmax_20_4, 0, 0, 20, 4, 32, total_length, buffer);
 809         if (errmsg)
 810           break;
 811       }
 812       break;
 813     case MEP_OPERAND_FMAX_RM :
 814       errmsg = insert_normal (cd, fields->f_fmax_rm, 0, 0, 8, 4, 32, total_length, buffer);
 815       break;
 816     case MEP_OPERAND_HI :
 817       break;
 818     case MEP_OPERAND_LO :
 819       break;
 820     case MEP_OPERAND_LP :
 821       break;
 822     case MEP_OPERAND_MB0 :
 823       break;
 824     case MEP_OPERAND_MB1 :
 825       break;
 826     case MEP_OPERAND_ME0 :
 827       break;
 828     case MEP_OPERAND_ME1 :
 829       break;
 830     case MEP_OPERAND_NPC :
 831       break;
 832     case MEP_OPERAND_OPT :
 833       break;
 834     case MEP_OPERAND_PCABS24A2 :
 835       {
 836 {
 837   FLD (f_24u5a2n_lo) = ((unsigned int) (((FLD (f_24u5a2n)) & (255))) >> (1));
 838   FLD (f_24u5a2n_hi) = ((unsigned int) (FLD (f_24u5a2n)) >> (8));
 839 }
 840         errmsg = insert_normal (cd, fields->f_24u5a2n_hi, 0, 0, 16, 16, 32, total_length, buffer);
 841         if (errmsg)
 842           break;
 843         errmsg = insert_normal (cd, fields->f_24u5a2n_lo, 0, 0, 5, 7, 32, total_length, buffer);
 844         if (errmsg)
 845           break;
 846       }
 847       break;
 848     case MEP_OPERAND_PCREL12A2 :
 849       {
 850         long value = fields->f_12s4a2;
 851         value = ((int) (((value) - (pc))) >> (1));
 852         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 4, 11, 32, total_length, buffer);
 853       }
 854       break;
 855     case MEP_OPERAND_PCREL17A2 :
 856       {
 857         long value = fields->f_17s16a2;
 858         value = ((int) (((value) - (pc))) >> (1));
 859         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 16, 16, 32, total_length, buffer);
 860       }
 861       break;
 862     case MEP_OPERAND_PCREL24A2 :
 863       {
 864 {
 865   FLD (f_24s5a2n) = ((FLD (f_24s5a2n)) - (pc));
 866   FLD (f_24s5a2n_lo) = ((unsigned int) (((FLD (f_24s5a2n)) & (254))) >> (1));
 867   FLD (f_24s5a2n_hi) = ((int) (FLD (f_24s5a2n)) >> (8));
 868 }
 869         errmsg = insert_normal (cd, fields->f_24s5a2n_hi, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 16, 16, 32, total_length, buffer);
 870         if (errmsg)
 871           break;
 872         errmsg = insert_normal (cd, fields->f_24s5a2n_lo, 0|(1<<CGEN_IFLD_PCREL_ADDR), 0, 5, 7, 32, total_length, buffer);
 873         if (errmsg)
 874           break;
 875       }
 876       break;
 877     case MEP_OPERAND_PCREL8A2 :
 878       {
 879         long value = fields->f_8s8a2;
 880         value = ((int) (((value) - (pc))) >> (1));
 881         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 8, 7, 32, total_length, buffer);
 882       }
 883       break;
 884     case MEP_OPERAND_PSW :
 885       break;
 886     case MEP_OPERAND_R0 :
 887       break;
 888     case MEP_OPERAND_R1 :
 889       break;
 890     case MEP_OPERAND_RL :
 891       errmsg = insert_normal (cd, fields->f_rl, 0, 0, 12, 4, 32, total_length, buffer);
 892       break;
 893     case MEP_OPERAND_RM :
 894       errmsg = insert_normal (cd, fields->f_rm, 0, 0, 8, 4, 32, total_length, buffer);
 895       break;
 896     case MEP_OPERAND_RMA :
 897       errmsg = insert_normal (cd, fields->f_rm, 0, 0, 8, 4, 32, total_length, buffer);
 898       break;
 899     case MEP_OPERAND_RN :
 900       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 901       break;
 902     case MEP_OPERAND_RN3 :
 903       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 904       break;
 905     case MEP_OPERAND_RN3C :
 906       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 907       break;
 908     case MEP_OPERAND_RN3L :
 909       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 910       break;
 911     case MEP_OPERAND_RN3S :
 912       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 913       break;
 914     case MEP_OPERAND_RN3UC :
 915       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 916       break;
 917     case MEP_OPERAND_RN3UL :
 918       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 919       break;
 920     case MEP_OPERAND_RN3US :
 921       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 922       break;
 923     case MEP_OPERAND_RNC :
 924       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 925       break;
 926     case MEP_OPERAND_RNL :
 927       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 928       break;
 929     case MEP_OPERAND_RNS :
 930       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 931       break;
 932     case MEP_OPERAND_RNUC :
 933       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 934       break;
 935     case MEP_OPERAND_RNUL :
 936       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 937       break;
 938     case MEP_OPERAND_RNUS :
 939       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 940       break;
 941     case MEP_OPERAND_SAR :
 942       break;
 943     case MEP_OPERAND_SDISP16 :
 944       errmsg = insert_normal (cd, fields->f_16s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, buffer);
 945       break;
 946     case MEP_OPERAND_SIMM16 :
 947       errmsg = insert_normal (cd, fields->f_16s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, buffer);
 948       break;
 949     case MEP_OPERAND_SIMM6 :
 950       errmsg = insert_normal (cd, fields->f_6s8, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 6, 32, total_length, buffer);
 951       break;
 952     case MEP_OPERAND_SIMM8 :
 953       errmsg = insert_normal (cd, fields->f_8s8, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 8, 32, total_length, buffer);
 954       break;
 955     case MEP_OPERAND_SP :
 956       break;
 957     case MEP_OPERAND_SPR :
 958       break;
 959     case MEP_OPERAND_TP :
 960       break;
 961     case MEP_OPERAND_TPR :
 962       break;
 963     case MEP_OPERAND_UDISP2 :
 964       errmsg = insert_normal (cd, fields->f_2u6, 0, 0, 6, 2, 32, total_length, buffer);
 965       break;
 966     case MEP_OPERAND_UDISP7 :
 967       errmsg = insert_normal (cd, fields->f_7u9, 0, 0, 9, 7, 32, total_length, buffer);
 968       break;
 969     case MEP_OPERAND_UDISP7A2 :
 970       {
 971         long value = fields->f_7u9a2;
 972         value = ((unsigned int) (value) >> (1));
 973         errmsg = insert_normal (cd, value, 0, 0, 9, 6, 32, total_length, buffer);
 974       }
 975       break;
 976     case MEP_OPERAND_UDISP7A4 :
 977       {
 978         long value = fields->f_7u9a4;
 979         value = ((unsigned int) (value) >> (2));
 980         errmsg = insert_normal (cd, value, 0, 0, 9, 5, 32, total_length, buffer);
 981       }
 982       break;
 983     case MEP_OPERAND_UIMM16 :
 984       errmsg = insert_normal (cd, fields->f_16u16, 0, 0, 16, 16, 32, total_length, buffer);
 985       break;
 986     case MEP_OPERAND_UIMM2 :
 987       errmsg = insert_normal (cd, fields->f_2u10, 0, 0, 10, 2, 32, total_length, buffer);
 988       break;
 989     case MEP_OPERAND_UIMM24 :
 990       {
 991 {
 992   FLD (f_24u8n_hi) = ((unsigned int) (FLD (f_24u8n)) >> (8));
 993   FLD (f_24u8n_lo) = ((FLD (f_24u8n)) & (255));
 994 }
 995         errmsg = insert_normal (cd, fields->f_24u8n_hi, 0, 0, 16, 16, 32, total_length, buffer);
 996         if (errmsg)
 997           break;
 998         errmsg = insert_normal (cd, fields->f_24u8n_lo, 0, 0, 8, 8, 32, total_length, buffer);
 999         if (errmsg)
1000           break;
1001       }
1002       break;
1003     case MEP_OPERAND_UIMM3 :
1004       errmsg = insert_normal (cd, fields->f_3u5, 0, 0, 5, 3, 32, total_length, buffer);
1005       break;
1006     case MEP_OPERAND_UIMM4 :
1007       errmsg = insert_normal (cd, fields->f_4u8, 0, 0, 8, 4, 32, total_length, buffer);
1008       break;
1009     case MEP_OPERAND_UIMM5 :
1010       errmsg = insert_normal (cd, fields->f_5u8, 0, 0, 8, 5, 32, total_length, buffer);
1011       break;
1012     case MEP_OPERAND_UIMM7A4 :
1013       {
1014         long value = fields->f_7u9a4;
1015         value = ((unsigned int) (value) >> (2));
1016         errmsg = insert_normal (cd, value, 0, 0, 9, 5, 32, total_length, buffer);
1017       }
1018       break;
1019     case MEP_OPERAND_ZERO :
1020       break;
1021
1022     default :
1023       /* xgettext:c-format */
1024       fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
1025                opindex);
1026       abort ();
1027   }
1028
1029   return errmsg;
1030 }
1031
1032 int mep_cgen_extract_operand
1033   (CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
1034
1035 /* Main entry point for operand extraction.
1036    The result is <= 0 for error, >0 for success.
1037    ??? Actual values aren't well defined right now.
1038
1039    This function is basically just a big switch statement.  Earlier versions
1040    used tables to look up the function to use, but
1041    - if the table contains both assembler and disassembler functions then
1042      the disassembler contains much of the assembler and vice-versa,
1043    - there's a lot of inlining possibilities as things grow,
1044    - using a switch statement avoids the function call overhead.
1045
1046    This function could be moved into `print_insn_normal', but keeping it
1047    separate makes clear the interface between `print_insn_normal' and each of
1048    the handlers.  */
1049
1050 int
1051 mep_cgen_extract_operand (CGEN_CPU_DESC cd,
1052                              int opindex,
1053                              CGEN_EXTRACT_INFO *ex_info,
1054                              CGEN_INSN_INT insn_value,
1055                              CGEN_FIELDS * fields,
1056                              bfd_vma pc)
1057 {
1058   /* Assume success (for those operands that are nops).  */
1059   int length = 1;
1060   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
1061
1062   switch (opindex)
1063     {
1064     case MEP_OPERAND_ADDR24A4 :
1065       {
1066         length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u8a4n_hi);
1067         if (length <= 0) break;
1068         length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 6, 32, total_length, pc, & fields->f_24u8a4n_lo);
1069         if (length <= 0) break;
1070   FLD (f_24u8a4n) = ((((FLD (f_24u8a4n_hi)) << (8))) | (((FLD (f_24u8a4n_lo)) << (2))));
1071       }
1072       break;
1073     case MEP_OPERAND_CALLNUM :
1074       {
1075         length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 1, 32, total_length, pc, & fields->f_5);
1076         if (length <= 0) break;
1077         length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 1, 32, total_length, pc, & fields->f_6);
1078         if (length <= 0) break;
1079         length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 1, 32, total_length, pc, & fields->f_7);
1080         if (length <= 0) break;
1081         length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 1, 32, total_length, pc, & fields->f_11);
1082         if (length <= 0) break;
1083   FLD (f_callnum) = ((((FLD (f_5)) << (3))) | (((((FLD (f_6)) << (2))) | (((((FLD (f_7)) << (1))) | (FLD (f_11)))))));
1084       }
1085       break;
1086     case MEP_OPERAND_CCCC :
1087       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_rm);
1088       break;
1089     case MEP_OPERAND_CCRN :
1090       {
1091         length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 2, 32, total_length, pc, & fields->f_ccrn_hi);
1092         if (length <= 0) break;
1093         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_ccrn_lo);
1094         if (length <= 0) break;
1095   FLD (f_ccrn) = ((((FLD (f_ccrn_hi)) << (4))) | (FLD (f_ccrn_lo)));
1096       }
1097       break;
1098     case MEP_OPERAND_CDISP8 :
1099       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 8, 32, total_length, pc, & fields->f_8s24);
1100       break;
1101     case MEP_OPERAND_CDISP8A2 :
1102       {
1103         long value;
1104         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 7, 32, total_length, pc, & value);
1105         value = ((value) << (1));
1106         fields->f_8s24a2 = value;
1107       }
1108       break;
1109     case MEP_OPERAND_CDISP8A4 :
1110       {
1111         long value;
1112         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 6, 32, total_length, pc, & value);
1113         value = ((value) << (2));
1114         fields->f_8s24a4 = value;
1115       }
1116       break;
1117     case MEP_OPERAND_CDISP8A8 :
1118       {
1119         long value;
1120         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 5, 32, total_length, pc, & value);
1121         value = ((value) << (3));
1122         fields->f_8s24a8 = value;
1123       }
1124       break;
1125     case MEP_OPERAND_CIMM4 :
1126       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1127       break;
1128     case MEP_OPERAND_CIMM5 :
1129       length = extract_normal (cd, ex_info, insn_value, 0, 0, 24, 5, 32, total_length, pc, & fields->f_5u24);
1130       break;
1131     case MEP_OPERAND_CODE16 :
1132       length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_16u16);
1133       break;
1134     case MEP_OPERAND_CODE24 :
1135       {
1136         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 8, 32, total_length, pc, & fields->f_24u4n_hi);
1137         if (length <= 0) break;
1138         length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u4n_lo);
1139         if (length <= 0) break;
1140   FLD (f_24u4n) = ((((FLD (f_24u4n_hi)) << (16))) | (FLD (f_24u4n_lo)));
1141       }
1142       break;
1143     case MEP_OPERAND_CP_FLAG :
1144       break;
1145     case MEP_OPERAND_CRN :
1146       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crn);
1147       break;
1148     case MEP_OPERAND_CRN64 :
1149       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crn);
1150       break;
1151     case MEP_OPERAND_CRNX :
1152       {
1153         length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_crnx_hi);
1154         if (length <= 0) break;
1155         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crnx_lo);
1156         if (length <= 0) break;
1157   FLD (f_crnx) = ((((FLD (f_crnx_hi)) << (4))) | (FLD (f_crnx_lo)));
1158       }
1159       break;
1160     case MEP_OPERAND_CRNX64 :
1161       {
1162         length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_crnx_hi);
1163         if (length <= 0) break;
1164         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crnx_lo);
1165         if (length <= 0) break;
1166   FLD (f_crnx) = ((((FLD (f_crnx_hi)) << (4))) | (FLD (f_crnx_lo)));
1167       }
1168       break;
1169     case MEP_OPERAND_CSRN :
1170       {
1171         length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_csrn_hi);
1172         if (length <= 0) break;
1173         length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_csrn_lo);
1174         if (length <= 0) break;
1175   FLD (f_csrn) = ((((FLD (f_csrn_hi)) << (4))) | (FLD (f_csrn_lo)));
1176       }
1177       break;
1178     case MEP_OPERAND_CSRN_IDX :
1179       {
1180         length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_csrn_hi);
1181         if (length <= 0) break;
1182         length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_csrn_lo);
1183         if (length <= 0) break;
1184   FLD (f_csrn) = ((((FLD (f_csrn_hi)) << (4))) | (FLD (f_csrn_lo)));
1185       }
1186       break;
1187     case MEP_OPERAND_DBG :
1188       break;
1189     case MEP_OPERAND_DEPC :
1190       break;
1191     case MEP_OPERAND_EPC :
1192       break;
1193     case MEP_OPERAND_EXC :
1194       break;
1195     case MEP_OPERAND_FMAX_CCRN :
1196       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_fmax_4_4);
1197       break;
1198     case MEP_OPERAND_FMAX_FRD :
1199       {
1200         length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_fmax_28_1);
1201         if (length <= 0) break;
1202         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_fmax_4_4);
1203         if (length <= 0) break;
1204   FLD (f_fmax_frd) = ((((FLD (f_fmax_28_1)) << (4))) | (FLD (f_fmax_4_4)));
1205       }
1206       break;
1207     case MEP_OPERAND_FMAX_FRD_INT :
1208       {
1209         length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_fmax_28_1);
1210         if (length <= 0) break;
1211         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_fmax_4_4);
1212         if (length <= 0) break;
1213   FLD (f_fmax_frd) = ((((FLD (f_fmax_28_1)) << (4))) | (FLD (f_fmax_4_4)));
1214       }
1215       break;
1216     case MEP_OPERAND_FMAX_FRM :
1217       {
1218         length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 1, 32, total_length, pc, & fields->f_fmax_30_1);
1219         if (length <= 0) break;
1220         length = extract_normal (cd, ex_info, insn_value, 0, 0, 24, 4, 32, total_length, pc, & fields->f_fmax_24_4);
1221         if (length <= 0) break;
1222   FLD (f_fmax_frm) = ((((FLD (f_fmax_30_1)) << (4))) | (FLD (f_fmax_24_4)));
1223       }
1224       break;
1225     case MEP_OPERAND_FMAX_FRN :
1226       {
1227         length = extract_normal (cd, ex_info, insn_value, 0, 0, 29, 1, 32, total_length, pc, & fields->f_fmax_29_1);
1228         if (length <= 0) break;
1229         length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 4, 32, total_length, pc, & fields->f_fmax_20_4);
1230         if (length <= 0) break;
1231   FLD (f_fmax_frn) = ((((FLD (f_fmax_29_1)) << (4))) | (FLD (f_fmax_20_4)));
1232       }
1233       break;
1234     case MEP_OPERAND_FMAX_FRN_INT :
1235       {
1236         length = extract_normal (cd, ex_info, insn_value, 0, 0, 29, 1, 32, total_length, pc, & fields->f_fmax_29_1);
1237         if (length <= 0) break;
1238         length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 4, 32, total_length, pc, & fields->f_fmax_20_4);
1239         if (length <= 0) break;
1240   FLD (f_fmax_frn) = ((((FLD (f_fmax_29_1)) << (4))) | (FLD (f_fmax_20_4)));
1241       }
1242       break;
1243     case MEP_OPERAND_FMAX_RM :
1244       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_fmax_rm);
1245       break;
1246     case MEP_OPERAND_HI :
1247       break;
1248     case MEP_OPERAND_LO :
1249       break;
1250     case MEP_OPERAND_LP :
1251       break;
1252     case MEP_OPERAND_MB0 :
1253       break;
1254     case MEP_OPERAND_MB1 :
1255       break;
1256     case MEP_OPERAND_ME0 :
1257       break;
1258     case MEP_OPERAND_ME1 :
1259       break;
1260     case MEP_OPERAND_NPC :
1261       break;
1262     case MEP_OPERAND_OPT :
1263       break;
1264     case MEP_OPERAND_PCABS24A2 :
1265       {
1266         length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u5a2n_hi);
1267         if (length <= 0) break;
1268         length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 7, 32, total_length, pc, & fields->f_24u5a2n_lo);
1269         if (length <= 0) break;
1270   FLD (f_24u5a2n) = ((((FLD (f_24u5a2n_hi)) << (8))) | (((FLD (f_24u5a2n_lo)) << (1))));
1271       }
1272       break;
1273     case MEP_OPERAND_PCREL12A2 :
1274       {
1275         long value;
1276         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 4, 11, 32, total_length, pc, & value);
1277         value = ((((value) << (1))) + (pc));
1278         fields->f_12s4a2 = value;
1279       }
1280       break;
1281     case MEP_OPERAND_PCREL17A2 :
1282       {
1283         long value;
1284         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 16, 16, 32, total_length, pc, & value);
1285         value = ((((value) << (1))) + (pc));
1286         fields->f_17s16a2 = value;
1287       }
1288       break;
1289     case MEP_OPERAND_PCREL24A2 :
1290       {
1291         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 16, 16, 32, total_length, pc, & fields->f_24s5a2n_hi);
1292         if (length <= 0) break;
1293         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_PCREL_ADDR), 0, 5, 7, 32, total_length, pc, & fields->f_24s5a2n_lo);
1294         if (length <= 0) break;
1295   FLD (f_24s5a2n) = ((((((FLD (f_24s5a2n_hi)) << (8))) | (((FLD (f_24s5a2n_lo)) << (1))))) + (pc));
1296       }
1297       break;
1298     case MEP_OPERAND_PCREL8A2 :
1299       {
1300         long value;
1301         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 8, 7, 32, total_length, pc, & value);
1302         value = ((((value) << (1))) + (pc));
1303         fields->f_8s8a2 = value;
1304       }
1305       break;
1306     case MEP_OPERAND_PSW :
1307       break;
1308     case MEP_OPERAND_R0 :
1309       break;
1310     case MEP_OPERAND_R1 :
1311       break;
1312     case MEP_OPERAND_RL :
1313       length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 4, 32, total_length, pc, & fields->f_rl);
1314       break;
1315     case MEP_OPERAND_RM :
1316       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_rm);
1317       break;
1318     case MEP_OPERAND_RMA :
1319       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_rm);
1320       break;
1321     case MEP_OPERAND_RN :
1322       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1323       break;
1324     case MEP_OPERAND_RN3 :
1325       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1326       break;
1327     case MEP_OPERAND_RN3C :
1328       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1329       break;
1330     case MEP_OPERAND_RN3L :
1331       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1332       break;
1333     case MEP_OPERAND_RN3S :
1334       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1335       break;
1336     case MEP_OPERAND_RN3UC :
1337       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1338       break;
1339     case MEP_OPERAND_RN3UL :
1340       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1341       break;
1342     case MEP_OPERAND_RN3US :
1343       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1344       break;
1345     case MEP_OPERAND_RNC :
1346       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1347       break;
1348     case MEP_OPERAND_RNL :
1349       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1350       break;
1351     case MEP_OPERAND_RNS :
1352       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1353       break;
1354     case MEP_OPERAND_RNUC :
1355       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1356       break;
1357     case MEP_OPERAND_RNUL :
1358       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1359       break;
1360     case MEP_OPERAND_RNUS :
1361       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1362       break;
1363     case MEP_OPERAND_SAR :
1364       break;
1365     case MEP_OPERAND_SDISP16 :
1366       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, pc, & fields->f_16s16);
1367       break;
1368     case MEP_OPERAND_SIMM16 :
1369       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, pc, & fields->f_16s16);
1370       break;
1371     case MEP_OPERAND_SIMM6 :
1372       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 6, 32, total_length, pc, & fields->f_6s8);
1373       break;
1374     case MEP_OPERAND_SIMM8 :
1375       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 8, 32, total_length, pc, & fields->f_8s8);
1376       break;
1377     case MEP_OPERAND_SP :
1378       break;
1379     case MEP_OPERAND_SPR :
1380       break;
1381     case MEP_OPERAND_TP :
1382       break;
1383     case MEP_OPERAND_TPR :
1384       break;
1385     case MEP_OPERAND_UDISP2 :
1386       length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 2, 32, total_length, pc, & fields->f_2u6);
1387       break;
1388     case MEP_OPERAND_UDISP7 :
1389       length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 7, 32, total_length, pc, & fields->f_7u9);
1390       break;
1391     case MEP_OPERAND_UDISP7A2 :
1392       {
1393         long value;
1394         length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 6, 32, total_length, pc, & value);
1395         value = ((value) << (1));
1396         fields->f_7u9a2 = value;
1397       }
1398       break;
1399     case MEP_OPERAND_UDISP7A4 :
1400       {
1401         long value;
1402         length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 5, 32, total_length, pc, & value);
1403         value = ((value) << (2));
1404         fields->f_7u9a4 = value;
1405       }
1406       break;
1407     case MEP_OPERAND_UIMM16 :
1408       length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_16u16);
1409       break;
1410     case MEP_OPERAND_UIMM2 :
1411       length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 2, 32, total_length, pc, & fields->f_2u10);
1412       break;
1413     case MEP_OPERAND_UIMM24 :
1414       {
1415         length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u8n_hi);
1416         if (length <= 0) break;
1417         length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 8, 32, total_length, pc, & fields->f_24u8n_lo);
1418         if (length <= 0) break;
1419   FLD (f_24u8n) = ((((FLD (f_24u8n_hi)) << (8))) | (FLD (f_24u8n_lo)));
1420       }
1421       break;
1422     case MEP_OPERAND_UIMM3 :
1423       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_3u5);
1424       break;
1425     case MEP_OPERAND_UIMM4 :
1426       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_4u8);
1427       break;
1428     case MEP_OPERAND_UIMM5 :
1429       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 5, 32, total_length, pc, & fields->f_5u8);
1430       break;
1431     case MEP_OPERAND_UIMM7A4 :
1432       {
1433         long value;
1434         length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 5, 32, total_length, pc, & value);
1435         value = ((value) << (2));
1436         fields->f_7u9a4 = value;
1437       }
1438       break;
1439     case MEP_OPERAND_ZERO :
1440       break;
1441
1442     default :
1443       /* xgettext:c-format */
1444       fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
1445                opindex);
1446       abort ();
1447     }
1448
1449   return length;
1450 }
1451
1452 cgen_insert_fn * const mep_cgen_insert_handlers[] =
1453 {
1454   insert_insn_normal,
1455 };
1456
1457 cgen_extract_fn * const mep_cgen_extract_handlers[] =
1458 {
1459   extract_insn_normal,
1460 };
1461
1462 int mep_cgen_get_int_operand     (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
1463 bfd_vma mep_cgen_get_vma_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
1464
1465 /* Getting values from cgen_fields is handled by a collection of functions.
1466    They are distinguished by the type of the VALUE argument they return.
1467    TODO: floating point, inlining support, remove cases where result type
1468    not appropriate.  */
1469
1470 int
1471 mep_cgen_get_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1472                              int opindex,
1473                              const CGEN_FIELDS * fields)
1474 {
1475   int value;
1476
1477   switch (opindex)
1478     {
1479     case MEP_OPERAND_ADDR24A4 :
1480       value = fields->f_24u8a4n;
1481       break;
1482     case MEP_OPERAND_CALLNUM :
1483       value = fields->f_callnum;
1484       break;
1485     case MEP_OPERAND_CCCC :
1486       value = fields->f_rm;
1487       break;
1488     case MEP_OPERAND_CCRN :
1489       value = fields->f_ccrn;
1490       break;
1491     case MEP_OPERAND_CDISP8 :
1492       value = fields->f_8s24;
1493       break;
1494     case MEP_OPERAND_CDISP8A2 :
1495       value = fields->f_8s24a2;
1496       break;
1497     case MEP_OPERAND_CDISP8A4 :
1498       value = fields->f_8s24a4;
1499       break;
1500     case MEP_OPERAND_CDISP8A8 :
1501       value = fields->f_8s24a8;
1502       break;
1503     case MEP_OPERAND_CIMM4 :
1504       value = fields->f_rn;
1505       break;
1506     case MEP_OPERAND_CIMM5 :
1507       value = fields->f_5u24;
1508       break;
1509     case MEP_OPERAND_CODE16 :
1510       value = fields->f_16u16;
1511       break;
1512     case MEP_OPERAND_CODE24 :
1513       value = fields->f_24u4n;
1514       break;
1515     case MEP_OPERAND_CP_FLAG :
1516       value = 0;
1517       break;
1518     case MEP_OPERAND_CRN :
1519       value = fields->f_crn;
1520       break;
1521     case MEP_OPERAND_CRN64 :
1522       value = fields->f_crn;
1523       break;
1524     case MEP_OPERAND_CRNX :
1525       value = fields->f_crnx;
1526       break;
1527     case MEP_OPERAND_CRNX64 :
1528       value = fields->f_crnx;
1529       break;
1530     case MEP_OPERAND_CSRN :
1531       value = fields->f_csrn;
1532       break;
1533     case MEP_OPERAND_CSRN_IDX :
1534       value = fields->f_csrn;
1535       break;
1536     case MEP_OPERAND_DBG :
1537       value = 0;
1538       break;
1539     case MEP_OPERAND_DEPC :
1540       value = 0;
1541       break;
1542     case MEP_OPERAND_EPC :
1543       value = 0;
1544       break;
1545     case MEP_OPERAND_EXC :
1546       value = 0;
1547       break;
1548     case MEP_OPERAND_FMAX_CCRN :
1549       value = fields->f_fmax_4_4;
1550       break;
1551     case MEP_OPERAND_FMAX_FRD :
1552       value = fields->f_fmax_frd;
1553       break;
1554     case MEP_OPERAND_FMAX_FRD_INT :
1555       value = fields->f_fmax_frd;
1556       break;
1557     case MEP_OPERAND_FMAX_FRM :
1558       value = fields->f_fmax_frm;
1559       break;
1560     case MEP_OPERAND_FMAX_FRN :
1561       value = fields->f_fmax_frn;
1562       break;
1563     case MEP_OPERAND_FMAX_FRN_INT :
1564       value = fields->f_fmax_frn;
1565       break;
1566     case MEP_OPERAND_FMAX_RM :
1567       value = fields->f_fmax_rm;
1568       break;
1569     case MEP_OPERAND_HI :
1570       value = 0;
1571       break;
1572     case MEP_OPERAND_LO :
1573       value = 0;
1574       break;
1575     case MEP_OPERAND_LP :
1576       value = 0;
1577       break;
1578     case MEP_OPERAND_MB0 :
1579       value = 0;
1580       break;
1581     case MEP_OPERAND_MB1 :
1582       value = 0;
1583       break;
1584     case MEP_OPERAND_ME0 :
1585       value = 0;
1586       break;
1587     case MEP_OPERAND_ME1 :
1588       value = 0;
1589       break;
1590     case MEP_OPERAND_NPC :
1591       value = 0;
1592       break;
1593     case MEP_OPERAND_OPT :
1594       value = 0;
1595       break;
1596     case MEP_OPERAND_PCABS24A2 :
1597       value = fields->f_24u5a2n;
1598       break;
1599     case MEP_OPERAND_PCREL12A2 :
1600       value = fields->f_12s4a2;
1601       break;
1602     case MEP_OPERAND_PCREL17A2 :
1603       value = fields->f_17s16a2;
1604       break;
1605     case MEP_OPERAND_PCREL24A2 :
1606       value = fields->f_24s5a2n;
1607       break;
1608     case MEP_OPERAND_PCREL8A2 :
1609       value = fields->f_8s8a2;
1610       break;
1611     case MEP_OPERAND_PSW :
1612       value = 0;
1613       break;
1614     case MEP_OPERAND_R0 :
1615       value = 0;
1616       break;
1617     case MEP_OPERAND_R1 :
1618       value = 0;
1619       break;
1620     case MEP_OPERAND_RL :
1621       value = fields->f_rl;
1622       break;
1623     case MEP_OPERAND_RM :
1624       value = fields->f_rm;
1625       break;
1626     case MEP_OPERAND_RMA :
1627       value = fields->f_rm;
1628       break;
1629     case MEP_OPERAND_RN :
1630       value = fields->f_rn;
1631       break;
1632     case MEP_OPERAND_RN3 :
1633       value = fields->f_rn3;
1634       break;
1635     case MEP_OPERAND_RN3C :
1636       value = fields->f_rn3;
1637       break;
1638     case MEP_OPERAND_RN3L :
1639       value = fields->f_rn3;
1640       break;
1641     case MEP_OPERAND_RN3S :
1642       value = fields->f_rn3;
1643       break;
1644     case MEP_OPERAND_RN3UC :
1645       value = fields->f_rn3;
1646       break;
1647     case MEP_OPERAND_RN3UL :
1648       value = fields->f_rn3;
1649       break;
1650     case MEP_OPERAND_RN3US :
1651       value = fields->f_rn3;
1652       break;
1653     case MEP_OPERAND_RNC :
1654       value = fields->f_rn;
1655       break;
1656     case MEP_OPERAND_RNL :
1657       value = fields->f_rn;
1658       break;
1659     case MEP_OPERAND_RNS :
1660       value = fields->f_rn;
1661       break;
1662     case MEP_OPERAND_RNUC :
1663       value = fields->f_rn;
1664       break;
1665     case MEP_OPERAND_RNUL :
1666       value = fields->f_rn;
1667       break;
1668     case MEP_OPERAND_RNUS :
1669       value = fields->f_rn;
1670       break;
1671     case MEP_OPERAND_SAR :
1672       value = 0;
1673       break;
1674     case MEP_OPERAND_SDISP16 :
1675       value = fields->f_16s16;
1676       break;
1677     case MEP_OPERAND_SIMM16 :
1678       value = fields->f_16s16;
1679       break;
1680     case MEP_OPERAND_SIMM6 :
1681       value = fields->f_6s8;
1682       break;
1683     case MEP_OPERAND_SIMM8 :
1684       value = fields->f_8s8;
1685       break;
1686     case MEP_OPERAND_SP :
1687       value = 0;
1688       break;
1689     case MEP_OPERAND_SPR :
1690       value = 0;
1691       break;
1692     case MEP_OPERAND_TP :
1693       value = 0;
1694       break;
1695     case MEP_OPERAND_TPR :
1696       value = 0;
1697       break;
1698     case MEP_OPERAND_UDISP2 :
1699       value = fields->f_2u6;
1700       break;
1701     case MEP_OPERAND_UDISP7 :
1702       value = fields->f_7u9;
1703       break;
1704     case MEP_OPERAND_UDISP7A2 :
1705       value = fields->f_7u9a2;
1706       break;
1707     case MEP_OPERAND_UDISP7A4 :
1708       value = fields->f_7u9a4;
1709       break;
1710     case MEP_OPERAND_UIMM16 :
1711       value = fields->f_16u16;
1712       break;
1713     case MEP_OPERAND_UIMM2 :
1714       value = fields->f_2u10;
1715       break;
1716     case MEP_OPERAND_UIMM24 :
1717       value = fields->f_24u8n;
1718       break;
1719     case MEP_OPERAND_UIMM3 :
1720       value = fields->f_3u5;
1721       break;
1722     case MEP_OPERAND_UIMM4 :
1723       value = fields->f_4u8;
1724       break;
1725     case MEP_OPERAND_UIMM5 :
1726       value = fields->f_5u8;
1727       break;
1728     case MEP_OPERAND_UIMM7A4 :
1729       value = fields->f_7u9a4;
1730       break;
1731     case MEP_OPERAND_ZERO :
1732       value = 0;
1733       break;
1734
1735     default :
1736       /* xgettext:c-format */
1737       fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
1738                        opindex);
1739       abort ();
1740   }
1741
1742   return value;
1743 }
1744
1745 bfd_vma
1746 mep_cgen_get_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1747                              int opindex,
1748                              const CGEN_FIELDS * fields)
1749 {
1750   bfd_vma value;
1751
1752   switch (opindex)
1753     {
1754     case MEP_OPERAND_ADDR24A4 :
1755       value = fields->f_24u8a4n;
1756       break;
1757     case MEP_OPERAND_CALLNUM :
1758       value = fields->f_callnum;
1759       break;
1760     case MEP_OPERAND_CCCC :
1761       value = fields->f_rm;
1762       break;
1763     case MEP_OPERAND_CCRN :
1764       value = fields->f_ccrn;
1765       break;
1766     case MEP_OPERAND_CDISP8 :
1767       value = fields->f_8s24;
1768       break;
1769     case MEP_OPERAND_CDISP8A2 :
1770       value = fields->f_8s24a2;
1771       break;
1772     case MEP_OPERAND_CDISP8A4 :
1773       value = fields->f_8s24a4;
1774       break;
1775     case MEP_OPERAND_CDISP8A8 :
1776       value = fields->f_8s24a8;
1777       break;
1778     case MEP_OPERAND_CIMM4 :
1779       value = fields->f_rn;
1780       break;
1781     case MEP_OPERAND_CIMM5 :
1782       value = fields->f_5u24;
1783       break;
1784     case MEP_OPERAND_CODE16 :
1785       value = fields->f_16u16;
1786       break;
1787     case MEP_OPERAND_CODE24 :
1788       value = fields->f_24u4n;
1789       break;
1790     case MEP_OPERAND_CP_FLAG :
1791       value = 0;
1792       break;
1793     case MEP_OPERAND_CRN :
1794       value = fields->f_crn;
1795       break;
1796     case MEP_OPERAND_CRN64 :
1797       value = fields->f_crn;
1798       break;
1799     case MEP_OPERAND_CRNX :
1800       value = fields->f_crnx;
1801       break;
1802     case MEP_OPERAND_CRNX64 :
1803       value = fields->f_crnx;
1804       break;
1805     case MEP_OPERAND_CSRN :
1806       value = fields->f_csrn;
1807       break;
1808     case MEP_OPERAND_CSRN_IDX :
1809       value = fields->f_csrn;
1810       break;
1811     case MEP_OPERAND_DBG :
1812       value = 0;
1813       break;
1814     case MEP_OPERAND_DEPC :
1815       value = 0;
1816       break;
1817     case MEP_OPERAND_EPC :
1818       value = 0;
1819       break;
1820     case MEP_OPERAND_EXC :
1821       value = 0;
1822       break;
1823     case MEP_OPERAND_FMAX_CCRN :
1824       value = fields->f_fmax_4_4;
1825       break;
1826     case MEP_OPERAND_FMAX_FRD :
1827       value = fields->f_fmax_frd;
1828       break;
1829     case MEP_OPERAND_FMAX_FRD_INT :
1830       value = fields->f_fmax_frd;
1831       break;
1832     case MEP_OPERAND_FMAX_FRM :
1833       value = fields->f_fmax_frm;
1834       break;
1835     case MEP_OPERAND_FMAX_FRN :
1836       value = fields->f_fmax_frn;
1837       break;
1838     case MEP_OPERAND_FMAX_FRN_INT :
1839       value = fields->f_fmax_frn;
1840       break;
1841     case MEP_OPERAND_FMAX_RM :
1842       value = fields->f_fmax_rm;
1843       break;
1844     case MEP_OPERAND_HI :
1845       value = 0;
1846       break;
1847     case MEP_OPERAND_LO :
1848       value = 0;
1849       break;
1850     case MEP_OPERAND_LP :
1851       value = 0;
1852       break;
1853     case MEP_OPERAND_MB0 :
1854       value = 0;
1855       break;
1856     case MEP_OPERAND_MB1 :
1857       value = 0;
1858       break;
1859     case MEP_OPERAND_ME0 :
1860       value = 0;
1861       break;
1862     case MEP_OPERAND_ME1 :
1863       value = 0;
1864       break;
1865     case MEP_OPERAND_NPC :
1866       value = 0;
1867       break;
1868     case MEP_OPERAND_OPT :
1869       value = 0;
1870       break;
1871     case MEP_OPERAND_PCABS24A2 :
1872       value = fields->f_24u5a2n;
1873       break;
1874     case MEP_OPERAND_PCREL12A2 :
1875       value = fields->f_12s4a2;
1876       break;
1877     case MEP_OPERAND_PCREL17A2 :
1878       value = fields->f_17s16a2;
1879       break;
1880     case MEP_OPERAND_PCREL24A2 :
1881       value = fields->f_24s5a2n;
1882       break;
1883     case MEP_OPERAND_PCREL8A2 :
1884       value = fields->f_8s8a2;
1885       break;
1886     case MEP_OPERAND_PSW :
1887       value = 0;
1888       break;
1889     case MEP_OPERAND_R0 :
1890       value = 0;
1891       break;
1892     case MEP_OPERAND_R1 :
1893       value = 0;
1894       break;
1895     case MEP_OPERAND_RL :
1896       value = fields->f_rl;
1897       break;
1898     case MEP_OPERAND_RM :
1899       value = fields->f_rm;
1900       break;
1901     case MEP_OPERAND_RMA :
1902       value = fields->f_rm;
1903       break;
1904     case MEP_OPERAND_RN :
1905       value = fields->f_rn;
1906       break;
1907     case MEP_OPERAND_RN3 :
1908       value = fields->f_rn3;
1909       break;
1910     case MEP_OPERAND_RN3C :
1911       value = fields->f_rn3;
1912       break;
1913     case MEP_OPERAND_RN3L :
1914       value = fields->f_rn3;
1915       break;
1916     case MEP_OPERAND_RN3S :
1917       value = fields->f_rn3;
1918       break;
1919     case MEP_OPERAND_RN3UC :
1920       value = fields->f_rn3;
1921       break;
1922     case MEP_OPERAND_RN3UL :
1923       value = fields->f_rn3;
1924       break;
1925     case MEP_OPERAND_RN3US :
1926       value = fields->f_rn3;
1927       break;
1928     case MEP_OPERAND_RNC :
1929       value = fields->f_rn;
1930       break;
1931     case MEP_OPERAND_RNL :
1932       value = fields->f_rn;
1933       break;
1934     case MEP_OPERAND_RNS :
1935       value = fields->f_rn;
1936       break;
1937     case MEP_OPERAND_RNUC :
1938       value = fields->f_rn;
1939       break;
1940     case MEP_OPERAND_RNUL :
1941       value = fields->f_rn;
1942       break;
1943     case MEP_OPERAND_RNUS :
1944       value = fields->f_rn;
1945       break;
1946     case MEP_OPERAND_SAR :
1947       value = 0;
1948       break;
1949     case MEP_OPERAND_SDISP16 :
1950       value = fields->f_16s16;
1951       break;
1952     case MEP_OPERAND_SIMM16 :
1953       value = fields->f_16s16;
1954       break;
1955     case MEP_OPERAND_SIMM6 :
1956       value = fields->f_6s8;
1957       break;
1958     case MEP_OPERAND_SIMM8 :
1959       value = fields->f_8s8;
1960       break;
1961     case MEP_OPERAND_SP :
1962       value = 0;
1963       break;
1964     case MEP_OPERAND_SPR :
1965       value = 0;
1966       break;
1967     case MEP_OPERAND_TP :
1968       value = 0;
1969       break;
1970     case MEP_OPERAND_TPR :
1971       value = 0;
1972       break;
1973     case MEP_OPERAND_UDISP2 :
1974       value = fields->f_2u6;
1975       break;
1976     case MEP_OPERAND_UDISP7 :
1977       value = fields->f_7u9;
1978       break;
1979     case MEP_OPERAND_UDISP7A2 :
1980       value = fields->f_7u9a2;
1981       break;
1982     case MEP_OPERAND_UDISP7A4 :
1983       value = fields->f_7u9a4;
1984       break;
1985     case MEP_OPERAND_UIMM16 :
1986       value = fields->f_16u16;
1987       break;
1988     case MEP_OPERAND_UIMM2 :
1989       value = fields->f_2u10;
1990       break;
1991     case MEP_OPERAND_UIMM24 :
1992       value = fields->f_24u8n;
1993       break;
1994     case MEP_OPERAND_UIMM3 :
1995       value = fields->f_3u5;
1996       break;
1997     case MEP_OPERAND_UIMM4 :
1998       value = fields->f_4u8;
1999       break;
2000     case MEP_OPERAND_UIMM5 :
2001       value = fields->f_5u8;
2002       break;
2003     case MEP_OPERAND_UIMM7A4 :
2004       value = fields->f_7u9a4;
2005       break;
2006     case MEP_OPERAND_ZERO :
2007       value = 0;
2008       break;
2009
2010     default :
2011       /* xgettext:c-format */
2012       fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
2013                        opindex);
2014       abort ();
2015   }
2016
2017   return value;
2018 }
2019
2020 void mep_cgen_set_int_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, int);
2021 void mep_cgen_set_vma_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma);
2022
2023 /* Stuffing values in cgen_fields is handled by a collection of functions.
2024    They are distinguished by the type of the VALUE argument they accept.
2025    TODO: floating point, inlining support, remove cases where argument type
2026    not appropriate.  */
2027
2028 void
2029 mep_cgen_set_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
2030                              int opindex,
2031                              CGEN_FIELDS * fields,
2032                              int value)
2033 {
2034   switch (opindex)
2035     {
2036     case MEP_OPERAND_ADDR24A4 :
2037       fields->f_24u8a4n = value;
2038       break;
2039     case MEP_OPERAND_CALLNUM :
2040       fields->f_callnum = value;
2041       break;
2042     case MEP_OPERAND_CCCC :
2043       fields->f_rm = value;
2044       break;
2045     case MEP_OPERAND_CCRN :
2046       fields->f_ccrn = value;
2047       break;
2048     case MEP_OPERAND_CDISP8 :
2049       fields->f_8s24 = value;
2050       break;
2051     case MEP_OPERAND_CDISP8A2 :
2052       fields->f_8s24a2 = value;
2053       break;
2054     case MEP_OPERAND_CDISP8A4 :
2055       fields->f_8s24a4 = value;
2056       break;
2057     case MEP_OPERAND_CDISP8A8 :
2058       fields->f_8s24a8 = value;
2059       break;
2060     case MEP_OPERAND_CIMM4 :
2061       fields->f_rn = value;
2062       break;
2063     case MEP_OPERAND_CIMM5 :
2064       fields->f_5u24 = value;
2065       break;
2066     case MEP_OPERAND_CODE16 :
2067       fields->f_16u16 = value;
2068       break;
2069     case MEP_OPERAND_CODE24 :
2070       fields->f_24u4n = value;
2071       break;
2072     case MEP_OPERAND_CP_FLAG :
2073       break;
2074     case MEP_OPERAND_CRN :
2075       fields->f_crn = value;
2076       break;
2077     case MEP_OPERAND_CRN64 :
2078       fields->f_crn = value;
2079       break;
2080     case MEP_OPERAND_CRNX :
2081       fields->f_crnx = value;
2082       break;
2083     case MEP_OPERAND_CRNX64 :
2084       fields->f_crnx = value;
2085       break;
2086     case MEP_OPERAND_CSRN :
2087       fields->f_csrn = value;
2088       break;
2089     case MEP_OPERAND_CSRN_IDX :
2090       fields->f_csrn = value;
2091       break;
2092     case MEP_OPERAND_DBG :
2093       break;
2094     case MEP_OPERAND_DEPC :
2095       break;
2096     case MEP_OPERAND_EPC :
2097       break;
2098     case MEP_OPERAND_EXC :
2099       break;
2100     case MEP_OPERAND_FMAX_CCRN :
2101       fields->f_fmax_4_4 = value;
2102       break;
2103     case MEP_OPERAND_FMAX_FRD :
2104       fields->f_fmax_frd = value;
2105       break;
2106     case MEP_OPERAND_FMAX_FRD_INT :
2107       fields->f_fmax_frd = value;
2108       break;
2109     case MEP_OPERAND_FMAX_FRM :
2110       fields->f_fmax_frm = value;
2111       break;
2112     case MEP_OPERAND_FMAX_FRN :
2113       fields->f_fmax_frn = value;
2114       break;
2115     case MEP_OPERAND_FMAX_FRN_INT :
2116       fields->f_fmax_frn = value;
2117       break;
2118     case MEP_OPERAND_FMAX_RM :
2119       fields->f_fmax_rm = value;
2120       break;
2121     case MEP_OPERAND_HI :
2122       break;
2123     case MEP_OPERAND_LO :
2124       break;
2125     case MEP_OPERAND_LP :
2126       break;
2127     case MEP_OPERAND_MB0 :
2128       break;
2129     case MEP_OPERAND_MB1 :
2130       break;
2131     case MEP_OPERAND_ME0 :
2132       break;
2133     case MEP_OPERAND_ME1 :
2134       break;
2135     case MEP_OPERAND_NPC :
2136       break;
2137     case MEP_OPERAND_OPT :
2138       break;
2139     case MEP_OPERAND_PCABS24A2 :
2140       fields->f_24u5a2n = value;
2141       break;
2142     case MEP_OPERAND_PCREL12A2 :
2143       fields->f_12s4a2 = value;
2144       break;
2145     case MEP_OPERAND_PCREL17A2 :
2146       fields->f_17s16a2 = value;
2147       break;
2148     case MEP_OPERAND_PCREL24A2 :
2149       fields->f_24s5a2n = value;
2150       break;
2151     case MEP_OPERAND_PCREL8A2 :
2152       fields->f_8s8a2 = value;
2153       break;
2154     case MEP_OPERAND_PSW :
2155       break;
2156     case MEP_OPERAND_R0 :
2157       break;
2158     case MEP_OPERAND_R1 :
2159       break;
2160     case MEP_OPERAND_RL :
2161       fields->f_rl = value;
2162       break;
2163     case MEP_OPERAND_RM :
2164       fields->f_rm = value;
2165       break;
2166     case MEP_OPERAND_RMA :
2167       fields->f_rm = value;
2168       break;
2169     case MEP_OPERAND_RN :
2170       fields->f_rn = value;
2171       break;
2172     case MEP_OPERAND_RN3 :
2173       fields->f_rn3 = value;
2174       break;
2175     case MEP_OPERAND_RN3C :
2176       fields->f_rn3 = value;
2177       break;
2178     case MEP_OPERAND_RN3L :
2179       fields->f_rn3 = value;
2180       break;
2181     case MEP_OPERAND_RN3S :
2182       fields->f_rn3 = value;
2183       break;
2184     case MEP_OPERAND_RN3UC :
2185       fields->f_rn3 = value;
2186       break;
2187     case MEP_OPERAND_RN3UL :
2188       fields->f_rn3 = value;
2189       break;
2190     case MEP_OPERAND_RN3US :
2191       fields->f_rn3 = value;
2192       break;
2193     case MEP_OPERAND_RNC :
2194       fields->f_rn = value;
2195       break;
2196     case MEP_OPERAND_RNL :
2197       fields->f_rn = value;
2198       break;
2199     case MEP_OPERAND_RNS :
2200       fields->f_rn = value;
2201       break;
2202     case MEP_OPERAND_RNUC :
2203       fields->f_rn = value;
2204       break;
2205     case MEP_OPERAND_RNUL :
2206       fields->f_rn = value;
2207       break;
2208     case MEP_OPERAND_RNUS :
2209       fields->f_rn = value;
2210       break;
2211     case MEP_OPERAND_SAR :
2212       break;
2213     case MEP_OPERAND_SDISP16 :
2214       fields->f_16s16 = value;
2215       break;
2216     case MEP_OPERAND_SIMM16 :
2217       fields->f_16s16 = value;
2218       break;
2219     case MEP_OPERAND_SIMM6 :
2220       fields->f_6s8 = value;
2221       break;
2222     case MEP_OPERAND_SIMM8 :
2223       fields->f_8s8 = value;
2224       break;
2225     case MEP_OPERAND_SP :
2226       break;
2227     case MEP_OPERAND_SPR :
2228       break;
2229     case MEP_OPERAND_TP :
2230       break;
2231     case MEP_OPERAND_TPR :
2232       break;
2233     case MEP_OPERAND_UDISP2 :
2234       fields->f_2u6 = value;
2235       break;
2236     case MEP_OPERAND_UDISP7 :
2237       fields->f_7u9 = value;
2238       break;
2239     case MEP_OPERAND_UDISP7A2 :
2240       fields->f_7u9a2 = value;
2241       break;
2242     case MEP_OPERAND_UDISP7A4 :
2243       fields->f_7u9a4 = value;
2244       break;
2245     case MEP_OPERAND_UIMM16 :
2246       fields->f_16u16 = value;
2247       break;
2248     case MEP_OPERAND_UIMM2 :
2249       fields->f_2u10 = value;
2250       break;
2251     case MEP_OPERAND_UIMM24 :
2252       fields->f_24u8n = value;
2253       break;
2254     case MEP_OPERAND_UIMM3 :
2255       fields->f_3u5 = value;
2256       break;
2257     case MEP_OPERAND_UIMM4 :
2258       fields->f_4u8 = value;
2259       break;
2260     case MEP_OPERAND_UIMM5 :
2261       fields->f_5u8 = value;
2262       break;
2263     case MEP_OPERAND_UIMM7A4 :
2264       fields->f_7u9a4 = value;
2265       break;
2266     case MEP_OPERAND_ZERO :
2267       break;
2268
2269     default :
2270       /* xgettext:c-format */
2271       fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
2272                        opindex);
2273       abort ();
2274   }
2275 }
2276
2277 void
2278 mep_cgen_set_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
2279                              int opindex,
2280                              CGEN_FIELDS * fields,
2281                              bfd_vma value)
2282 {
2283   switch (opindex)
2284     {
2285     case MEP_OPERAND_ADDR24A4 :
2286       fields->f_24u8a4n = value;
2287       break;
2288     case MEP_OPERAND_CALLNUM :
2289       fields->f_callnum = value;
2290       break;
2291     case MEP_OPERAND_CCCC :
2292       fields->f_rm = value;
2293       break;
2294     case MEP_OPERAND_CCRN :
2295       fields->f_ccrn = value;
2296       break;
2297     case MEP_OPERAND_CDISP8 :
2298       fields->f_8s24 = value;
2299       break;
2300     case MEP_OPERAND_CDISP8A2 :
2301       fields->f_8s24a2 = value;
2302       break;
2303     case MEP_OPERAND_CDISP8A4 :
2304       fields->f_8s24a4 = value;
2305       break;
2306     case MEP_OPERAND_CDISP8A8 :
2307       fields->f_8s24a8 = value;
2308       break;
2309     case MEP_OPERAND_CIMM4 :
2310       fields->f_rn = value;
2311       break;
2312     case MEP_OPERAND_CIMM5 :
2313       fields->f_5u24 = value;
2314       break;
2315     case MEP_OPERAND_CODE16 :
2316       fields->f_16u16 = value;
2317       break;
2318     case MEP_OPERAND_CODE24 :
2319       fields->f_24u4n = value;
2320       break;
2321     case MEP_OPERAND_CP_FLAG :
2322       break;
2323     case MEP_OPERAND_CRN :
2324       fields->f_crn = value;
2325       break;
2326     case MEP_OPERAND_CRN64 :
2327       fields->f_crn = value;
2328       break;
2329     case MEP_OPERAND_CRNX :
2330       fields->f_crnx = value;
2331       break;
2332     case MEP_OPERAND_CRNX64 :
2333       fields->f_crnx = value;
2334       break;
2335     case MEP_OPERAND_CSRN :
2336       fields->f_csrn = value;
2337       break;
2338     case MEP_OPERAND_CSRN_IDX :
2339       fields->f_csrn = value;
2340       break;
2341     case MEP_OPERAND_DBG :
2342       break;
2343     case MEP_OPERAND_DEPC :
2344       break;
2345     case MEP_OPERAND_EPC :
2346       break;
2347     case MEP_OPERAND_EXC :
2348       break;
2349     case MEP_OPERAND_FMAX_CCRN :
2350       fields->f_fmax_4_4 = value;
2351       break;
2352     case MEP_OPERAND_FMAX_FRD :
2353       fields->f_fmax_frd = value;
2354       break;
2355     case MEP_OPERAND_FMAX_FRD_INT :
2356       fields->f_fmax_frd = value;
2357       break;
2358     case MEP_OPERAND_FMAX_FRM :
2359       fields->f_fmax_frm = value;
2360       break;
2361     case MEP_OPERAND_FMAX_FRN :
2362       fields->f_fmax_frn = value;
2363       break;
2364     case MEP_OPERAND_FMAX_FRN_INT :
2365       fields->f_fmax_frn = value;
2366       break;
2367     case MEP_OPERAND_FMAX_RM :
2368       fields->f_fmax_rm = value;
2369       break;
2370     case MEP_OPERAND_HI :
2371       break;
2372     case MEP_OPERAND_LO :
2373       break;
2374     case MEP_OPERAND_LP :
2375       break;
2376     case MEP_OPERAND_MB0 :
2377       break;
2378     case MEP_OPERAND_MB1 :
2379       break;
2380     case MEP_OPERAND_ME0 :
2381       break;
2382     case MEP_OPERAND_ME1 :
2383       break;
2384     case MEP_OPERAND_NPC :
2385       break;
2386     case MEP_OPERAND_OPT :
2387       break;
2388     case MEP_OPERAND_PCABS24A2 :
2389       fields->f_24u5a2n = value;
2390       break;
2391     case MEP_OPERAND_PCREL12A2 :
2392       fields->f_12s4a2 = value;
2393       break;
2394     case MEP_OPERAND_PCREL17A2 :
2395       fields->f_17s16a2 = value;
2396       break;
2397     case MEP_OPERAND_PCREL24A2 :
2398       fields->f_24s5a2n = value;
2399       break;
2400     case MEP_OPERAND_PCREL8A2 :
2401       fields->f_8s8a2 = value;
2402       break;
2403     case MEP_OPERAND_PSW :
2404       break;
2405     case MEP_OPERAND_R0 :
2406       break;
2407     case MEP_OPERAND_R1 :
2408       break;
2409     case MEP_OPERAND_RL :
2410       fields->f_rl = value;
2411       break;
2412     case MEP_OPERAND_RM :
2413       fields->f_rm = value;
2414       break;
2415     case MEP_OPERAND_RMA :
2416       fields->f_rm = value;
2417       break;
2418     case MEP_OPERAND_RN :
2419       fields->f_rn = value;
2420       break;
2421     case MEP_OPERAND_RN3 :
2422       fields->f_rn3 = value;
2423       break;
2424     case MEP_OPERAND_RN3C :
2425       fields->f_rn3 = value;
2426       break;
2427     case MEP_OPERAND_RN3L :
2428       fields->f_rn3 = value;
2429       break;
2430     case MEP_OPERAND_RN3S :
2431       fields->f_rn3 = value;
2432       break;
2433     case MEP_OPERAND_RN3UC :
2434       fields->f_rn3 = value;
2435       break;
2436     case MEP_OPERAND_RN3UL :
2437       fields->f_rn3 = value;
2438       break;
2439     case MEP_OPERAND_RN3US :
2440       fields->f_rn3 = value;
2441       break;
2442     case MEP_OPERAND_RNC :
2443       fields->f_rn = value;
2444       break;
2445     case MEP_OPERAND_RNL :
2446       fields->f_rn = value;
2447       break;
2448     case MEP_OPERAND_RNS :
2449       fields->f_rn = value;
2450       break;
2451     case MEP_OPERAND_RNUC :
2452       fields->f_rn = value;
2453       break;
2454     case MEP_OPERAND_RNUL :
2455       fields->f_rn = value;
2456       break;
2457     case MEP_OPERAND_RNUS :
2458       fields->f_rn = value;
2459       break;
2460     case MEP_OPERAND_SAR :
2461       break;
2462     case MEP_OPERAND_SDISP16 :
2463       fields->f_16s16 = value;
2464       break;
2465     case MEP_OPERAND_SIMM16 :
2466       fields->f_16s16 = value;
2467       break;
2468     case MEP_OPERAND_SIMM6 :
2469       fields->f_6s8 = value;
2470       break;
2471     case MEP_OPERAND_SIMM8 :
2472       fields->f_8s8 = value;
2473       break;
2474     case MEP_OPERAND_SP :
2475       break;
2476     case MEP_OPERAND_SPR :
2477       break;
2478     case MEP_OPERAND_TP :
2479       break;
2480     case MEP_OPERAND_TPR :
2481       break;
2482     case MEP_OPERAND_UDISP2 :
2483       fields->f_2u6 = value;
2484       break;
2485     case MEP_OPERAND_UDISP7 :
2486       fields->f_7u9 = value;
2487       break;
2488     case MEP_OPERAND_UDISP7A2 :
2489       fields->f_7u9a2 = value;
2490       break;
2491     case MEP_OPERAND_UDISP7A4 :
2492       fields->f_7u9a4 = value;
2493       break;
2494     case MEP_OPERAND_UIMM16 :
2495       fields->f_16u16 = value;
2496       break;
2497     case MEP_OPERAND_UIMM2 :
2498       fields->f_2u10 = value;
2499       break;
2500     case MEP_OPERAND_UIMM24 :
2501       fields->f_24u8n = value;
2502       break;
2503     case MEP_OPERAND_UIMM3 :
2504       fields->f_3u5 = value;
2505       break;
2506     case MEP_OPERAND_UIMM4 :
2507       fields->f_4u8 = value;
2508       break;
2509     case MEP_OPERAND_UIMM5 :
2510       fields->f_5u8 = value;
2511       break;
2512     case MEP_OPERAND_UIMM7A4 :
2513       fields->f_7u9a4 = value;
2514       break;
2515     case MEP_OPERAND_ZERO :
2516       break;
2517
2518     default :
2519       /* xgettext:c-format */
2520       fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
2521                        opindex);
2522       abort ();
2523   }
2524 }
2525
2526 /* Function to call before using the instruction builder tables.  */
2527
2528 void
2529 mep_cgen_init_ibld_table (CGEN_CPU_DESC cd)
2530 {
2531   cd->insert_handlers = & mep_cgen_insert_handlers[0];
2532   cd->extract_handlers = & mep_cgen_extract_handlers[0];
2533
2534   cd->insert_operand = mep_cgen_insert_operand;
2535   cd->extract_operand = mep_cgen_extract_operand;
2536
2537   cd->get_int_operand = mep_cgen_get_int_operand;
2538   cd->set_int_operand = mep_cgen_set_int_operand;
2539   cd->get_vma_operand = mep_cgen_get_vma_operand;
2540   cd->set_vma_operand = mep_cgen_set_vma_operand;
2541 }