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, 2007,
   7    2008  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 "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_HI :
 741       break;
 742     case MEP_OPERAND_LO :
 743       break;
 744     case MEP_OPERAND_LP :
 745       break;
 746     case MEP_OPERAND_MB0 :
 747       break;
 748     case MEP_OPERAND_MB1 :
 749       break;
 750     case MEP_OPERAND_ME0 :
 751       break;
 752     case MEP_OPERAND_ME1 :
 753       break;
 754     case MEP_OPERAND_NPC :
 755       break;
 756     case MEP_OPERAND_OPT :
 757       break;
 758     case MEP_OPERAND_PCABS24A2 :
 759       {
 760 {
 761   FLD (f_24u5a2n_lo) = ((unsigned int) (((FLD (f_24u5a2n)) & (255))) >> (1));
 762   FLD (f_24u5a2n_hi) = ((unsigned int) (FLD (f_24u5a2n)) >> (8));
 763 }
 764         errmsg = insert_normal (cd, fields->f_24u5a2n_hi, 0, 0, 16, 16, 32, total_length, buffer);
 765         if (errmsg)
 766           break;
 767         errmsg = insert_normal (cd, fields->f_24u5a2n_lo, 0, 0, 5, 7, 32, total_length, buffer);
 768         if (errmsg)
 769           break;
 770       }
 771       break;
 772     case MEP_OPERAND_PCREL12A2 :
 773       {
 774         long value = fields->f_12s4a2;
 775         value = ((int) (((value) - (pc))) >> (1));
 776         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 4, 11, 32, total_length, buffer);
 777       }
 778       break;
 779     case MEP_OPERAND_PCREL17A2 :
 780       {
 781         long value = fields->f_17s16a2;
 782         value = ((int) (((value) - (pc))) >> (1));
 783         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 16, 16, 32, total_length, buffer);
 784       }
 785       break;
 786     case MEP_OPERAND_PCREL24A2 :
 787       {
 788 {
 789   FLD (f_24s5a2n) = ((FLD (f_24s5a2n)) - (pc));
 790   FLD (f_24s5a2n_lo) = ((unsigned int) (((FLD (f_24s5a2n)) & (254))) >> (1));
 791   FLD (f_24s5a2n_hi) = ((int) (FLD (f_24s5a2n)) >> (8));
 792 }
 793         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);
 794         if (errmsg)
 795           break;
 796         errmsg = insert_normal (cd, fields->f_24s5a2n_lo, 0|(1<<CGEN_IFLD_PCREL_ADDR), 0, 5, 7, 32, total_length, buffer);
 797         if (errmsg)
 798           break;
 799       }
 800       break;
 801     case MEP_OPERAND_PCREL8A2 :
 802       {
 803         long value = fields->f_8s8a2;
 804         value = ((int) (((value) - (pc))) >> (1));
 805         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 8, 7, 32, total_length, buffer);
 806       }
 807       break;
 808     case MEP_OPERAND_PSW :
 809       break;
 810     case MEP_OPERAND_R0 :
 811       break;
 812     case MEP_OPERAND_R1 :
 813       break;
 814     case MEP_OPERAND_RL :
 815       errmsg = insert_normal (cd, fields->f_rl, 0, 0, 12, 4, 32, total_length, buffer);
 816       break;
 817     case MEP_OPERAND_RM :
 818       errmsg = insert_normal (cd, fields->f_rm, 0, 0, 8, 4, 32, total_length, buffer);
 819       break;
 820     case MEP_OPERAND_RMA :
 821       errmsg = insert_normal (cd, fields->f_rm, 0, 0, 8, 4, 32, total_length, buffer);
 822       break;
 823     case MEP_OPERAND_RN :
 824       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 825       break;
 826     case MEP_OPERAND_RN3 :
 827       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 828       break;
 829     case MEP_OPERAND_RN3C :
 830       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 831       break;
 832     case MEP_OPERAND_RN3L :
 833       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 834       break;
 835     case MEP_OPERAND_RN3S :
 836       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 837       break;
 838     case MEP_OPERAND_RN3UC :
 839       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 840       break;
 841     case MEP_OPERAND_RN3UL :
 842       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 843       break;
 844     case MEP_OPERAND_RN3US :
 845       errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
 846       break;
 847     case MEP_OPERAND_RNC :
 848       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 849       break;
 850     case MEP_OPERAND_RNL :
 851       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 852       break;
 853     case MEP_OPERAND_RNS :
 854       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 855       break;
 856     case MEP_OPERAND_RNUC :
 857       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 858       break;
 859     case MEP_OPERAND_RNUL :
 860       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 861       break;
 862     case MEP_OPERAND_RNUS :
 863       errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
 864       break;
 865     case MEP_OPERAND_SAR :
 866       break;
 867     case MEP_OPERAND_SDISP16 :
 868       errmsg = insert_normal (cd, fields->f_16s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, buffer);
 869       break;
 870     case MEP_OPERAND_SIMM16 :
 871       errmsg = insert_normal (cd, fields->f_16s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, buffer);
 872       break;
 873     case MEP_OPERAND_SIMM6 :
 874       errmsg = insert_normal (cd, fields->f_6s8, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 6, 32, total_length, buffer);
 875       break;
 876     case MEP_OPERAND_SIMM8 :
 877       errmsg = insert_normal (cd, fields->f_8s8, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 8, 32, total_length, buffer);
 878       break;
 879     case MEP_OPERAND_SP :
 880       break;
 881     case MEP_OPERAND_SPR :
 882       break;
 883     case MEP_OPERAND_TP :
 884       break;
 885     case MEP_OPERAND_TPR :
 886       break;
 887     case MEP_OPERAND_UDISP2 :
 888       errmsg = insert_normal (cd, fields->f_2u6, 0, 0, 6, 2, 32, total_length, buffer);
 889       break;
 890     case MEP_OPERAND_UDISP7 :
 891       errmsg = insert_normal (cd, fields->f_7u9, 0, 0, 9, 7, 32, total_length, buffer);
 892       break;
 893     case MEP_OPERAND_UDISP7A2 :
 894       {
 895         long value = fields->f_7u9a2;
 896         value = ((unsigned int) (value) >> (1));
 897         errmsg = insert_normal (cd, value, 0, 0, 9, 6, 32, total_length, buffer);
 898       }
 899       break;
 900     case MEP_OPERAND_UDISP7A4 :
 901       {
 902         long value = fields->f_7u9a4;
 903         value = ((unsigned int) (value) >> (2));
 904         errmsg = insert_normal (cd, value, 0, 0, 9, 5, 32, total_length, buffer);
 905       }
 906       break;
 907     case MEP_OPERAND_UIMM16 :
 908       errmsg = insert_normal (cd, fields->f_16u16, 0, 0, 16, 16, 32, total_length, buffer);
 909       break;
 910     case MEP_OPERAND_UIMM2 :
 911       errmsg = insert_normal (cd, fields->f_2u10, 0, 0, 10, 2, 32, total_length, buffer);
 912       break;
 913     case MEP_OPERAND_UIMM24 :
 914       {
 915 {
 916   FLD (f_24u8n_hi) = ((unsigned int) (FLD (f_24u8n)) >> (8));
 917   FLD (f_24u8n_lo) = ((FLD (f_24u8n)) & (255));
 918 }
 919         errmsg = insert_normal (cd, fields->f_24u8n_hi, 0, 0, 16, 16, 32, total_length, buffer);
 920         if (errmsg)
 921           break;
 922         errmsg = insert_normal (cd, fields->f_24u8n_lo, 0, 0, 8, 8, 32, total_length, buffer);
 923         if (errmsg)
 924           break;
 925       }
 926       break;
 927     case MEP_OPERAND_UIMM3 :
 928       errmsg = insert_normal (cd, fields->f_3u5, 0, 0, 5, 3, 32, total_length, buffer);
 929       break;
 930     case MEP_OPERAND_UIMM4 :
 931       errmsg = insert_normal (cd, fields->f_4u8, 0, 0, 8, 4, 32, total_length, buffer);
 932       break;
 933     case MEP_OPERAND_UIMM5 :
 934       errmsg = insert_normal (cd, fields->f_5u8, 0, 0, 8, 5, 32, total_length, buffer);
 935       break;
 936     case MEP_OPERAND_UIMM7A4 :
 937       {
 938         long value = fields->f_7u9a4;
 939         value = ((unsigned int) (value) >> (2));
 940         errmsg = insert_normal (cd, value, 0, 0, 9, 5, 32, total_length, buffer);
 941       }
 942       break;
 943     case MEP_OPERAND_ZERO :
 944       break;
 945
 946     default :
 947       /* xgettext:c-format */
 948       fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
 949                opindex);
 950       abort ();
 951   }
 952
 953   return errmsg;
 954 }
 955
 956 int mep_cgen_extract_operand
 957   (CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
 958
 959 /* Main entry point for operand extraction.
 960    The result is <= 0 for error, >0 for success.
 961    ??? Actual values aren't well defined right now.
 962
 963    This function is basically just a big switch statement.  Earlier versions
 964    used tables to look up the function to use, but
 965    - if the table contains both assembler and disassembler functions then
 966      the disassembler contains much of the assembler and vice-versa,
 967    - there's a lot of inlining possibilities as things grow,
 968    - using a switch statement avoids the function call overhead.
 969
 970    This function could be moved into `print_insn_normal', but keeping it
 971    separate makes clear the interface between `print_insn_normal' and each of
 972    the handlers.  */
 973
 974 int
 975 mep_cgen_extract_operand (CGEN_CPU_DESC cd,
 976                              int opindex,
 977                              CGEN_EXTRACT_INFO *ex_info,
 978                              CGEN_INSN_INT insn_value,
 979                              CGEN_FIELDS * fields,
 980                              bfd_vma pc)
 981 {
 982   /* Assume success (for those operands that are nops).  */
 983   int length = 1;
 984   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 985
 986   switch (opindex)
 987     {
 988     case MEP_OPERAND_ADDR24A4 :
 989       {
 990         length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u8a4n_hi);
 991         if (length <= 0) break;
 992         length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 6, 32, total_length, pc, & fields->f_24u8a4n_lo);
 993         if (length <= 0) break;
 994   FLD (f_24u8a4n) = ((((FLD (f_24u8a4n_hi)) << (8))) | (((FLD (f_24u8a4n_lo)) << (2))));
 995       }
 996       break;
 997     case MEP_OPERAND_CALLNUM :
 998       {
 999         length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 1, 32, total_length, pc, & fields->f_5);
1000         if (length <= 0) break;
1001         length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 1, 32, total_length, pc, & fields->f_6);
1002         if (length <= 0) break;
1003         length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 1, 32, total_length, pc, & fields->f_7);
1004         if (length <= 0) break;
1005         length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 1, 32, total_length, pc, & fields->f_11);
1006         if (length <= 0) break;
1007   FLD (f_callnum) = ((((FLD (f_5)) << (3))) | (((((FLD (f_6)) << (2))) | (((((FLD (f_7)) << (1))) | (FLD (f_11)))))));
1008       }
1009       break;
1010     case MEP_OPERAND_CCCC :
1011       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_rm);
1012       break;
1013     case MEP_OPERAND_CCRN :
1014       {
1015         length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 2, 32, total_length, pc, & fields->f_ccrn_hi);
1016         if (length <= 0) break;
1017         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_ccrn_lo);
1018         if (length <= 0) break;
1019   FLD (f_ccrn) = ((((FLD (f_ccrn_hi)) << (4))) | (FLD (f_ccrn_lo)));
1020       }
1021       break;
1022     case MEP_OPERAND_CDISP8 :
1023       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 8, 32, total_length, pc, & fields->f_8s24);
1024       break;
1025     case MEP_OPERAND_CDISP8A2 :
1026       {
1027         long value;
1028         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 7, 32, total_length, pc, & value);
1029         value = ((value) << (1));
1030         fields->f_8s24a2 = value;
1031       }
1032       break;
1033     case MEP_OPERAND_CDISP8A4 :
1034       {
1035         long value;
1036         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 6, 32, total_length, pc, & value);
1037         value = ((value) << (2));
1038         fields->f_8s24a4 = value;
1039       }
1040       break;
1041     case MEP_OPERAND_CDISP8A8 :
1042       {
1043         long value;
1044         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 5, 32, total_length, pc, & value);
1045         value = ((value) << (3));
1046         fields->f_8s24a8 = value;
1047       }
1048       break;
1049     case MEP_OPERAND_CIMM4 :
1050       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1051       break;
1052     case MEP_OPERAND_CIMM5 :
1053       length = extract_normal (cd, ex_info, insn_value, 0, 0, 24, 5, 32, total_length, pc, & fields->f_5u24);
1054       break;
1055     case MEP_OPERAND_CODE16 :
1056       length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_16u16);
1057       break;
1058     case MEP_OPERAND_CODE24 :
1059       {
1060         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 8, 32, total_length, pc, & fields->f_24u4n_hi);
1061         if (length <= 0) break;
1062         length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u4n_lo);
1063         if (length <= 0) break;
1064   FLD (f_24u4n) = ((((FLD (f_24u4n_hi)) << (16))) | (FLD (f_24u4n_lo)));
1065       }
1066       break;
1067     case MEP_OPERAND_CP_FLAG :
1068       break;
1069     case MEP_OPERAND_CRN :
1070       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crn);
1071       break;
1072     case MEP_OPERAND_CRN64 :
1073       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crn);
1074       break;
1075     case MEP_OPERAND_CRNX :
1076       {
1077         length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_crnx_hi);
1078         if (length <= 0) break;
1079         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crnx_lo);
1080         if (length <= 0) break;
1081   FLD (f_crnx) = ((((FLD (f_crnx_hi)) << (4))) | (FLD (f_crnx_lo)));
1082       }
1083       break;
1084     case MEP_OPERAND_CRNX64 :
1085       {
1086         length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_crnx_hi);
1087         if (length <= 0) break;
1088         length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crnx_lo);
1089         if (length <= 0) break;
1090   FLD (f_crnx) = ((((FLD (f_crnx_hi)) << (4))) | (FLD (f_crnx_lo)));
1091       }
1092       break;
1093     case MEP_OPERAND_CSRN :
1094       {
1095         length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_csrn_hi);
1096         if (length <= 0) break;
1097         length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_csrn_lo);
1098         if (length <= 0) break;
1099   FLD (f_csrn) = ((((FLD (f_csrn_hi)) << (4))) | (FLD (f_csrn_lo)));
1100       }
1101       break;
1102     case MEP_OPERAND_CSRN_IDX :
1103       {
1104         length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_csrn_hi);
1105         if (length <= 0) break;
1106         length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_csrn_lo);
1107         if (length <= 0) break;
1108   FLD (f_csrn) = ((((FLD (f_csrn_hi)) << (4))) | (FLD (f_csrn_lo)));
1109       }
1110       break;
1111     case MEP_OPERAND_DBG :
1112       break;
1113     case MEP_OPERAND_DEPC :
1114       break;
1115     case MEP_OPERAND_EPC :
1116       break;
1117     case MEP_OPERAND_EXC :
1118       break;
1119     case MEP_OPERAND_HI :
1120       break;
1121     case MEP_OPERAND_LO :
1122       break;
1123     case MEP_OPERAND_LP :
1124       break;
1125     case MEP_OPERAND_MB0 :
1126       break;
1127     case MEP_OPERAND_MB1 :
1128       break;
1129     case MEP_OPERAND_ME0 :
1130       break;
1131     case MEP_OPERAND_ME1 :
1132       break;
1133     case MEP_OPERAND_NPC :
1134       break;
1135     case MEP_OPERAND_OPT :
1136       break;
1137     case MEP_OPERAND_PCABS24A2 :
1138       {
1139         length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u5a2n_hi);
1140         if (length <= 0) break;
1141         length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 7, 32, total_length, pc, & fields->f_24u5a2n_lo);
1142         if (length <= 0) break;
1143   FLD (f_24u5a2n) = ((((FLD (f_24u5a2n_hi)) << (8))) | (((FLD (f_24u5a2n_lo)) << (1))));
1144       }
1145       break;
1146     case MEP_OPERAND_PCREL12A2 :
1147       {
1148         long value;
1149         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);
1150         value = ((((value) << (1))) + (pc));
1151         fields->f_12s4a2 = value;
1152       }
1153       break;
1154     case MEP_OPERAND_PCREL17A2 :
1155       {
1156         long value;
1157         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);
1158         value = ((((value) << (1))) + (pc));
1159         fields->f_17s16a2 = value;
1160       }
1161       break;
1162     case MEP_OPERAND_PCREL24A2 :
1163       {
1164         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);
1165         if (length <= 0) break;
1166         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);
1167         if (length <= 0) break;
1168   FLD (f_24s5a2n) = ((((((FLD (f_24s5a2n_hi)) << (8))) | (((FLD (f_24s5a2n_lo)) << (1))))) + (pc));
1169       }
1170       break;
1171     case MEP_OPERAND_PCREL8A2 :
1172       {
1173         long value;
1174         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);
1175         value = ((((value) << (1))) + (pc));
1176         fields->f_8s8a2 = value;
1177       }
1178       break;
1179     case MEP_OPERAND_PSW :
1180       break;
1181     case MEP_OPERAND_R0 :
1182       break;
1183     case MEP_OPERAND_R1 :
1184       break;
1185     case MEP_OPERAND_RL :
1186       length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 4, 32, total_length, pc, & fields->f_rl);
1187       break;
1188     case MEP_OPERAND_RM :
1189       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_rm);
1190       break;
1191     case MEP_OPERAND_RMA :
1192       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_rm);
1193       break;
1194     case MEP_OPERAND_RN :
1195       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1196       break;
1197     case MEP_OPERAND_RN3 :
1198       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1199       break;
1200     case MEP_OPERAND_RN3C :
1201       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1202       break;
1203     case MEP_OPERAND_RN3L :
1204       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1205       break;
1206     case MEP_OPERAND_RN3S :
1207       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1208       break;
1209     case MEP_OPERAND_RN3UC :
1210       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1211       break;
1212     case MEP_OPERAND_RN3UL :
1213       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1214       break;
1215     case MEP_OPERAND_RN3US :
1216       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1217       break;
1218     case MEP_OPERAND_RNC :
1219       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1220       break;
1221     case MEP_OPERAND_RNL :
1222       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1223       break;
1224     case MEP_OPERAND_RNS :
1225       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1226       break;
1227     case MEP_OPERAND_RNUC :
1228       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1229       break;
1230     case MEP_OPERAND_RNUL :
1231       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1232       break;
1233     case MEP_OPERAND_RNUS :
1234       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1235       break;
1236     case MEP_OPERAND_SAR :
1237       break;
1238     case MEP_OPERAND_SDISP16 :
1239       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, pc, & fields->f_16s16);
1240       break;
1241     case MEP_OPERAND_SIMM16 :
1242       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, pc, & fields->f_16s16);
1243       break;
1244     case MEP_OPERAND_SIMM6 :
1245       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 6, 32, total_length, pc, & fields->f_6s8);
1246       break;
1247     case MEP_OPERAND_SIMM8 :
1248       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 8, 32, total_length, pc, & fields->f_8s8);
1249       break;
1250     case MEP_OPERAND_SP :
1251       break;
1252     case MEP_OPERAND_SPR :
1253       break;
1254     case MEP_OPERAND_TP :
1255       break;
1256     case MEP_OPERAND_TPR :
1257       break;
1258     case MEP_OPERAND_UDISP2 :
1259       length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 2, 32, total_length, pc, & fields->f_2u6);
1260       break;
1261     case MEP_OPERAND_UDISP7 :
1262       length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 7, 32, total_length, pc, & fields->f_7u9);
1263       break;
1264     case MEP_OPERAND_UDISP7A2 :
1265       {
1266         long value;
1267         length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 6, 32, total_length, pc, & value);
1268         value = ((value) << (1));
1269         fields->f_7u9a2 = value;
1270       }
1271       break;
1272     case MEP_OPERAND_UDISP7A4 :
1273       {
1274         long value;
1275         length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 5, 32, total_length, pc, & value);
1276         value = ((value) << (2));
1277         fields->f_7u9a4 = value;
1278       }
1279       break;
1280     case MEP_OPERAND_UIMM16 :
1281       length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_16u16);
1282       break;
1283     case MEP_OPERAND_UIMM2 :
1284       length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 2, 32, total_length, pc, & fields->f_2u10);
1285       break;
1286     case MEP_OPERAND_UIMM24 :
1287       {
1288         length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u8n_hi);
1289         if (length <= 0) break;
1290         length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 8, 32, total_length, pc, & fields->f_24u8n_lo);
1291         if (length <= 0) break;
1292   FLD (f_24u8n) = ((((FLD (f_24u8n_hi)) << (8))) | (FLD (f_24u8n_lo)));
1293       }
1294       break;
1295     case MEP_OPERAND_UIMM3 :
1296       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_3u5);
1297       break;
1298     case MEP_OPERAND_UIMM4 :
1299       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_4u8);
1300       break;
1301     case MEP_OPERAND_UIMM5 :
1302       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 5, 32, total_length, pc, & fields->f_5u8);
1303       break;
1304     case MEP_OPERAND_UIMM7A4 :
1305       {
1306         long value;
1307         length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 5, 32, total_length, pc, & value);
1308         value = ((value) << (2));
1309         fields->f_7u9a4 = value;
1310       }
1311       break;
1312     case MEP_OPERAND_ZERO :
1313       break;
1314
1315     default :
1316       /* xgettext:c-format */
1317       fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
1318                opindex);
1319       abort ();
1320     }
1321
1322   return length;
1323 }
1324
1325 cgen_insert_fn * const mep_cgen_insert_handlers[] =
1326 {
1327   insert_insn_normal,
1328 };
1329
1330 cgen_extract_fn * const mep_cgen_extract_handlers[] =
1331 {
1332   extract_insn_normal,
1333 };
1334
1335 int mep_cgen_get_int_operand     (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
1336 bfd_vma mep_cgen_get_vma_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
1337
1338 /* Getting values from cgen_fields is handled by a collection of functions.
1339    They are distinguished by the type of the VALUE argument they return.
1340    TODO: floating point, inlining support, remove cases where result type
1341    not appropriate.  */
1342
1343 int
1344 mep_cgen_get_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1345                              int opindex,
1346                              const CGEN_FIELDS * fields)
1347 {
1348   int value;
1349
1350   switch (opindex)
1351     {
1352     case MEP_OPERAND_ADDR24A4 :
1353       value = fields->f_24u8a4n;
1354       break;
1355     case MEP_OPERAND_CALLNUM :
1356       value = fields->f_callnum;
1357       break;
1358     case MEP_OPERAND_CCCC :
1359       value = fields->f_rm;
1360       break;
1361     case MEP_OPERAND_CCRN :
1362       value = fields->f_ccrn;
1363       break;
1364     case MEP_OPERAND_CDISP8 :
1365       value = fields->f_8s24;
1366       break;
1367     case MEP_OPERAND_CDISP8A2 :
1368       value = fields->f_8s24a2;
1369       break;
1370     case MEP_OPERAND_CDISP8A4 :
1371       value = fields->f_8s24a4;
1372       break;
1373     case MEP_OPERAND_CDISP8A8 :
1374       value = fields->f_8s24a8;
1375       break;
1376     case MEP_OPERAND_CIMM4 :
1377       value = fields->f_rn;
1378       break;
1379     case MEP_OPERAND_CIMM5 :
1380       value = fields->f_5u24;
1381       break;
1382     case MEP_OPERAND_CODE16 :
1383       value = fields->f_16u16;
1384       break;
1385     case MEP_OPERAND_CODE24 :
1386       value = fields->f_24u4n;
1387       break;
1388     case MEP_OPERAND_CP_FLAG :
1389       value = 0;
1390       break;
1391     case MEP_OPERAND_CRN :
1392       value = fields->f_crn;
1393       break;
1394     case MEP_OPERAND_CRN64 :
1395       value = fields->f_crn;
1396       break;
1397     case MEP_OPERAND_CRNX :
1398       value = fields->f_crnx;
1399       break;
1400     case MEP_OPERAND_CRNX64 :
1401       value = fields->f_crnx;
1402       break;
1403     case MEP_OPERAND_CSRN :
1404       value = fields->f_csrn;
1405       break;
1406     case MEP_OPERAND_CSRN_IDX :
1407       value = fields->f_csrn;
1408       break;
1409     case MEP_OPERAND_DBG :
1410       value = 0;
1411       break;
1412     case MEP_OPERAND_DEPC :
1413       value = 0;
1414       break;
1415     case MEP_OPERAND_EPC :
1416       value = 0;
1417       break;
1418     case MEP_OPERAND_EXC :
1419       value = 0;
1420       break;
1421     case MEP_OPERAND_HI :
1422       value = 0;
1423       break;
1424     case MEP_OPERAND_LO :
1425       value = 0;
1426       break;
1427     case MEP_OPERAND_LP :
1428       value = 0;
1429       break;
1430     case MEP_OPERAND_MB0 :
1431       value = 0;
1432       break;
1433     case MEP_OPERAND_MB1 :
1434       value = 0;
1435       break;
1436     case MEP_OPERAND_ME0 :
1437       value = 0;
1438       break;
1439     case MEP_OPERAND_ME1 :
1440       value = 0;
1441       break;
1442     case MEP_OPERAND_NPC :
1443       value = 0;
1444       break;
1445     case MEP_OPERAND_OPT :
1446       value = 0;
1447       break;
1448     case MEP_OPERAND_PCABS24A2 :
1449       value = fields->f_24u5a2n;
1450       break;
1451     case MEP_OPERAND_PCREL12A2 :
1452       value = fields->f_12s4a2;
1453       break;
1454     case MEP_OPERAND_PCREL17A2 :
1455       value = fields->f_17s16a2;
1456       break;
1457     case MEP_OPERAND_PCREL24A2 :
1458       value = fields->f_24s5a2n;
1459       break;
1460     case MEP_OPERAND_PCREL8A2 :
1461       value = fields->f_8s8a2;
1462       break;
1463     case MEP_OPERAND_PSW :
1464       value = 0;
1465       break;
1466     case MEP_OPERAND_R0 :
1467       value = 0;
1468       break;
1469     case MEP_OPERAND_R1 :
1470       value = 0;
1471       break;
1472     case MEP_OPERAND_RL :
1473       value = fields->f_rl;
1474       break;
1475     case MEP_OPERAND_RM :
1476       value = fields->f_rm;
1477       break;
1478     case MEP_OPERAND_RMA :
1479       value = fields->f_rm;
1480       break;
1481     case MEP_OPERAND_RN :
1482       value = fields->f_rn;
1483       break;
1484     case MEP_OPERAND_RN3 :
1485       value = fields->f_rn3;
1486       break;
1487     case MEP_OPERAND_RN3C :
1488       value = fields->f_rn3;
1489       break;
1490     case MEP_OPERAND_RN3L :
1491       value = fields->f_rn3;
1492       break;
1493     case MEP_OPERAND_RN3S :
1494       value = fields->f_rn3;
1495       break;
1496     case MEP_OPERAND_RN3UC :
1497       value = fields->f_rn3;
1498       break;
1499     case MEP_OPERAND_RN3UL :
1500       value = fields->f_rn3;
1501       break;
1502     case MEP_OPERAND_RN3US :
1503       value = fields->f_rn3;
1504       break;
1505     case MEP_OPERAND_RNC :
1506       value = fields->f_rn;
1507       break;
1508     case MEP_OPERAND_RNL :
1509       value = fields->f_rn;
1510       break;
1511     case MEP_OPERAND_RNS :
1512       value = fields->f_rn;
1513       break;
1514     case MEP_OPERAND_RNUC :
1515       value = fields->f_rn;
1516       break;
1517     case MEP_OPERAND_RNUL :
1518       value = fields->f_rn;
1519       break;
1520     case MEP_OPERAND_RNUS :
1521       value = fields->f_rn;
1522       break;
1523     case MEP_OPERAND_SAR :
1524       value = 0;
1525       break;
1526     case MEP_OPERAND_SDISP16 :
1527       value = fields->f_16s16;
1528       break;
1529     case MEP_OPERAND_SIMM16 :
1530       value = fields->f_16s16;
1531       break;
1532     case MEP_OPERAND_SIMM6 :
1533       value = fields->f_6s8;
1534       break;
1535     case MEP_OPERAND_SIMM8 :
1536       value = fields->f_8s8;
1537       break;
1538     case MEP_OPERAND_SP :
1539       value = 0;
1540       break;
1541     case MEP_OPERAND_SPR :
1542       value = 0;
1543       break;
1544     case MEP_OPERAND_TP :
1545       value = 0;
1546       break;
1547     case MEP_OPERAND_TPR :
1548       value = 0;
1549       break;
1550     case MEP_OPERAND_UDISP2 :
1551       value = fields->f_2u6;
1552       break;
1553     case MEP_OPERAND_UDISP7 :
1554       value = fields->f_7u9;
1555       break;
1556     case MEP_OPERAND_UDISP7A2 :
1557       value = fields->f_7u9a2;
1558       break;
1559     case MEP_OPERAND_UDISP7A4 :
1560       value = fields->f_7u9a4;
1561       break;
1562     case MEP_OPERAND_UIMM16 :
1563       value = fields->f_16u16;
1564       break;
1565     case MEP_OPERAND_UIMM2 :
1566       value = fields->f_2u10;
1567       break;
1568     case MEP_OPERAND_UIMM24 :
1569       value = fields->f_24u8n;
1570       break;
1571     case MEP_OPERAND_UIMM3 :
1572       value = fields->f_3u5;
1573       break;
1574     case MEP_OPERAND_UIMM4 :
1575       value = fields->f_4u8;
1576       break;
1577     case MEP_OPERAND_UIMM5 :
1578       value = fields->f_5u8;
1579       break;
1580     case MEP_OPERAND_UIMM7A4 :
1581       value = fields->f_7u9a4;
1582       break;
1583     case MEP_OPERAND_ZERO :
1584       value = 0;
1585       break;
1586
1587     default :
1588       /* xgettext:c-format */
1589       fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
1590                        opindex);
1591       abort ();
1592   }
1593
1594   return value;
1595 }
1596
1597 bfd_vma
1598 mep_cgen_get_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1599                              int opindex,
1600                              const CGEN_FIELDS * fields)
1601 {
1602   bfd_vma value;
1603
1604   switch (opindex)
1605     {
1606     case MEP_OPERAND_ADDR24A4 :
1607       value = fields->f_24u8a4n;
1608       break;
1609     case MEP_OPERAND_CALLNUM :
1610       value = fields->f_callnum;
1611       break;
1612     case MEP_OPERAND_CCCC :
1613       value = fields->f_rm;
1614       break;
1615     case MEP_OPERAND_CCRN :
1616       value = fields->f_ccrn;
1617       break;
1618     case MEP_OPERAND_CDISP8 :
1619       value = fields->f_8s24;
1620       break;
1621     case MEP_OPERAND_CDISP8A2 :
1622       value = fields->f_8s24a2;
1623       break;
1624     case MEP_OPERAND_CDISP8A4 :
1625       value = fields->f_8s24a4;
1626       break;
1627     case MEP_OPERAND_CDISP8A8 :
1628       value = fields->f_8s24a8;
1629       break;
1630     case MEP_OPERAND_CIMM4 :
1631       value = fields->f_rn;
1632       break;
1633     case MEP_OPERAND_CIMM5 :
1634       value = fields->f_5u24;
1635       break;
1636     case MEP_OPERAND_CODE16 :
1637       value = fields->f_16u16;
1638       break;
1639     case MEP_OPERAND_CODE24 :
1640       value = fields->f_24u4n;
1641       break;
1642     case MEP_OPERAND_CP_FLAG :
1643       value = 0;
1644       break;
1645     case MEP_OPERAND_CRN :
1646       value = fields->f_crn;
1647       break;
1648     case MEP_OPERAND_CRN64 :
1649       value = fields->f_crn;
1650       break;
1651     case MEP_OPERAND_CRNX :
1652       value = fields->f_crnx;
1653       break;
1654     case MEP_OPERAND_CRNX64 :
1655       value = fields->f_crnx;
1656       break;
1657     case MEP_OPERAND_CSRN :
1658       value = fields->f_csrn;
1659       break;
1660     case MEP_OPERAND_CSRN_IDX :
1661       value = fields->f_csrn;
1662       break;
1663     case MEP_OPERAND_DBG :
1664       value = 0;
1665       break;
1666     case MEP_OPERAND_DEPC :
1667       value = 0;
1668       break;
1669     case MEP_OPERAND_EPC :
1670       value = 0;
1671       break;
1672     case MEP_OPERAND_EXC :
1673       value = 0;
1674       break;
1675     case MEP_OPERAND_HI :
1676       value = 0;
1677       break;
1678     case MEP_OPERAND_LO :
1679       value = 0;
1680       break;
1681     case MEP_OPERAND_LP :
1682       value = 0;
1683       break;
1684     case MEP_OPERAND_MB0 :
1685       value = 0;
1686       break;
1687     case MEP_OPERAND_MB1 :
1688       value = 0;
1689       break;
1690     case MEP_OPERAND_ME0 :
1691       value = 0;
1692       break;
1693     case MEP_OPERAND_ME1 :
1694       value = 0;
1695       break;
1696     case MEP_OPERAND_NPC :
1697       value = 0;
1698       break;
1699     case MEP_OPERAND_OPT :
1700       value = 0;
1701       break;
1702     case MEP_OPERAND_PCABS24A2 :
1703       value = fields->f_24u5a2n;
1704       break;
1705     case MEP_OPERAND_PCREL12A2 :
1706       value = fields->f_12s4a2;
1707       break;
1708     case MEP_OPERAND_PCREL17A2 :
1709       value = fields->f_17s16a2;
1710       break;
1711     case MEP_OPERAND_PCREL24A2 :
1712       value = fields->f_24s5a2n;
1713       break;
1714     case MEP_OPERAND_PCREL8A2 :
1715       value = fields->f_8s8a2;
1716       break;
1717     case MEP_OPERAND_PSW :
1718       value = 0;
1719       break;
1720     case MEP_OPERAND_R0 :
1721       value = 0;
1722       break;
1723     case MEP_OPERAND_R1 :
1724       value = 0;
1725       break;
1726     case MEP_OPERAND_RL :
1727       value = fields->f_rl;
1728       break;
1729     case MEP_OPERAND_RM :
1730       value = fields->f_rm;
1731       break;
1732     case MEP_OPERAND_RMA :
1733       value = fields->f_rm;
1734       break;
1735     case MEP_OPERAND_RN :
1736       value = fields->f_rn;
1737       break;
1738     case MEP_OPERAND_RN3 :
1739       value = fields->f_rn3;
1740       break;
1741     case MEP_OPERAND_RN3C :
1742       value = fields->f_rn3;
1743       break;
1744     case MEP_OPERAND_RN3L :
1745       value = fields->f_rn3;
1746       break;
1747     case MEP_OPERAND_RN3S :
1748       value = fields->f_rn3;
1749       break;
1750     case MEP_OPERAND_RN3UC :
1751       value = fields->f_rn3;
1752       break;
1753     case MEP_OPERAND_RN3UL :
1754       value = fields->f_rn3;
1755       break;
1756     case MEP_OPERAND_RN3US :
1757       value = fields->f_rn3;
1758       break;
1759     case MEP_OPERAND_RNC :
1760       value = fields->f_rn;
1761       break;
1762     case MEP_OPERAND_RNL :
1763       value = fields->f_rn;
1764       break;
1765     case MEP_OPERAND_RNS :
1766       value = fields->f_rn;
1767       break;
1768     case MEP_OPERAND_RNUC :
1769       value = fields->f_rn;
1770       break;
1771     case MEP_OPERAND_RNUL :
1772       value = fields->f_rn;
1773       break;
1774     case MEP_OPERAND_RNUS :
1775       value = fields->f_rn;
1776       break;
1777     case MEP_OPERAND_SAR :
1778       value = 0;
1779       break;
1780     case MEP_OPERAND_SDISP16 :
1781       value = fields->f_16s16;
1782       break;
1783     case MEP_OPERAND_SIMM16 :
1784       value = fields->f_16s16;
1785       break;
1786     case MEP_OPERAND_SIMM6 :
1787       value = fields->f_6s8;
1788       break;
1789     case MEP_OPERAND_SIMM8 :
1790       value = fields->f_8s8;
1791       break;
1792     case MEP_OPERAND_SP :
1793       value = 0;
1794       break;
1795     case MEP_OPERAND_SPR :
1796       value = 0;
1797       break;
1798     case MEP_OPERAND_TP :
1799       value = 0;
1800       break;
1801     case MEP_OPERAND_TPR :
1802       value = 0;
1803       break;
1804     case MEP_OPERAND_UDISP2 :
1805       value = fields->f_2u6;
1806       break;
1807     case MEP_OPERAND_UDISP7 :
1808       value = fields->f_7u9;
1809       break;
1810     case MEP_OPERAND_UDISP7A2 :
1811       value = fields->f_7u9a2;
1812       break;
1813     case MEP_OPERAND_UDISP7A4 :
1814       value = fields->f_7u9a4;
1815       break;
1816     case MEP_OPERAND_UIMM16 :
1817       value = fields->f_16u16;
1818       break;
1819     case MEP_OPERAND_UIMM2 :
1820       value = fields->f_2u10;
1821       break;
1822     case MEP_OPERAND_UIMM24 :
1823       value = fields->f_24u8n;
1824       break;
1825     case MEP_OPERAND_UIMM3 :
1826       value = fields->f_3u5;
1827       break;
1828     case MEP_OPERAND_UIMM4 :
1829       value = fields->f_4u8;
1830       break;
1831     case MEP_OPERAND_UIMM5 :
1832       value = fields->f_5u8;
1833       break;
1834     case MEP_OPERAND_UIMM7A4 :
1835       value = fields->f_7u9a4;
1836       break;
1837     case MEP_OPERAND_ZERO :
1838       value = 0;
1839       break;
1840
1841     default :
1842       /* xgettext:c-format */
1843       fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
1844                        opindex);
1845       abort ();
1846   }
1847
1848   return value;
1849 }
1850
1851 void mep_cgen_set_int_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, int);
1852 void mep_cgen_set_vma_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma);
1853
1854 /* Stuffing values in cgen_fields is handled by a collection of functions.
1855    They are distinguished by the type of the VALUE argument they accept.
1856    TODO: floating point, inlining support, remove cases where argument type
1857    not appropriate.  */
1858
1859 void
1860 mep_cgen_set_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1861                              int opindex,
1862                              CGEN_FIELDS * fields,
1863                              int value)
1864 {
1865   switch (opindex)
1866     {
1867     case MEP_OPERAND_ADDR24A4 :
1868       fields->f_24u8a4n = value;
1869       break;
1870     case MEP_OPERAND_CALLNUM :
1871       fields->f_callnum = value;
1872       break;
1873     case MEP_OPERAND_CCCC :
1874       fields->f_rm = value;
1875       break;
1876     case MEP_OPERAND_CCRN :
1877       fields->f_ccrn = value;
1878       break;
1879     case MEP_OPERAND_CDISP8 :
1880       fields->f_8s24 = value;
1881       break;
1882     case MEP_OPERAND_CDISP8A2 :
1883       fields->f_8s24a2 = value;
1884       break;
1885     case MEP_OPERAND_CDISP8A4 :
1886       fields->f_8s24a4 = value;
1887       break;
1888     case MEP_OPERAND_CDISP8A8 :
1889       fields->f_8s24a8 = value;
1890       break;
1891     case MEP_OPERAND_CIMM4 :
1892       fields->f_rn = value;
1893       break;
1894     case MEP_OPERAND_CIMM5 :
1895       fields->f_5u24 = value;
1896       break;
1897     case MEP_OPERAND_CODE16 :
1898       fields->f_16u16 = value;
1899       break;
1900     case MEP_OPERAND_CODE24 :
1901       fields->f_24u4n = value;
1902       break;
1903     case MEP_OPERAND_CP_FLAG :
1904       break;
1905     case MEP_OPERAND_CRN :
1906       fields->f_crn = value;
1907       break;
1908     case MEP_OPERAND_CRN64 :
1909       fields->f_crn = value;
1910       break;
1911     case MEP_OPERAND_CRNX :
1912       fields->f_crnx = value;
1913       break;
1914     case MEP_OPERAND_CRNX64 :
1915       fields->f_crnx = value;
1916       break;
1917     case MEP_OPERAND_CSRN :
1918       fields->f_csrn = value;
1919       break;
1920     case MEP_OPERAND_CSRN_IDX :
1921       fields->f_csrn = value;
1922       break;
1923     case MEP_OPERAND_DBG :
1924       break;
1925     case MEP_OPERAND_DEPC :
1926       break;
1927     case MEP_OPERAND_EPC :
1928       break;
1929     case MEP_OPERAND_EXC :
1930       break;
1931     case MEP_OPERAND_HI :
1932       break;
1933     case MEP_OPERAND_LO :
1934       break;
1935     case MEP_OPERAND_LP :
1936       break;
1937     case MEP_OPERAND_MB0 :
1938       break;
1939     case MEP_OPERAND_MB1 :
1940       break;
1941     case MEP_OPERAND_ME0 :
1942       break;
1943     case MEP_OPERAND_ME1 :
1944       break;
1945     case MEP_OPERAND_NPC :
1946       break;
1947     case MEP_OPERAND_OPT :
1948       break;
1949     case MEP_OPERAND_PCABS24A2 :
1950       fields->f_24u5a2n = value;
1951       break;
1952     case MEP_OPERAND_PCREL12A2 :
1953       fields->f_12s4a2 = value;
1954       break;
1955     case MEP_OPERAND_PCREL17A2 :
1956       fields->f_17s16a2 = value;
1957       break;
1958     case MEP_OPERAND_PCREL24A2 :
1959       fields->f_24s5a2n = value;
1960       break;
1961     case MEP_OPERAND_PCREL8A2 :
1962       fields->f_8s8a2 = value;
1963       break;
1964     case MEP_OPERAND_PSW :
1965       break;
1966     case MEP_OPERAND_R0 :
1967       break;
1968     case MEP_OPERAND_R1 :
1969       break;
1970     case MEP_OPERAND_RL :
1971       fields->f_rl = value;
1972       break;
1973     case MEP_OPERAND_RM :
1974       fields->f_rm = value;
1975       break;
1976     case MEP_OPERAND_RMA :
1977       fields->f_rm = value;
1978       break;
1979     case MEP_OPERAND_RN :
1980       fields->f_rn = value;
1981       break;
1982     case MEP_OPERAND_RN3 :
1983       fields->f_rn3 = value;
1984       break;
1985     case MEP_OPERAND_RN3C :
1986       fields->f_rn3 = value;
1987       break;
1988     case MEP_OPERAND_RN3L :
1989       fields->f_rn3 = value;
1990       break;
1991     case MEP_OPERAND_RN3S :
1992       fields->f_rn3 = value;
1993       break;
1994     case MEP_OPERAND_RN3UC :
1995       fields->f_rn3 = value;
1996       break;
1997     case MEP_OPERAND_RN3UL :
1998       fields->f_rn3 = value;
1999       break;
2000     case MEP_OPERAND_RN3US :
2001       fields->f_rn3 = value;
2002       break;
2003     case MEP_OPERAND_RNC :
2004       fields->f_rn = value;
2005       break;
2006     case MEP_OPERAND_RNL :
2007       fields->f_rn = value;
2008       break;
2009     case MEP_OPERAND_RNS :
2010       fields->f_rn = value;
2011       break;
2012     case MEP_OPERAND_RNUC :
2013       fields->f_rn = value;
2014       break;
2015     case MEP_OPERAND_RNUL :
2016       fields->f_rn = value;
2017       break;
2018     case MEP_OPERAND_RNUS :
2019       fields->f_rn = value;
2020       break;
2021     case MEP_OPERAND_SAR :
2022       break;
2023     case MEP_OPERAND_SDISP16 :
2024       fields->f_16s16 = value;
2025       break;
2026     case MEP_OPERAND_SIMM16 :
2027       fields->f_16s16 = value;
2028       break;
2029     case MEP_OPERAND_SIMM6 :
2030       fields->f_6s8 = value;
2031       break;
2032     case MEP_OPERAND_SIMM8 :
2033       fields->f_8s8 = value;
2034       break;
2035     case MEP_OPERAND_SP :
2036       break;
2037     case MEP_OPERAND_SPR :
2038       break;
2039     case MEP_OPERAND_TP :
2040       break;
2041     case MEP_OPERAND_TPR :
2042       break;
2043     case MEP_OPERAND_UDISP2 :
2044       fields->f_2u6 = value;
2045       break;
2046     case MEP_OPERAND_UDISP7 :
2047       fields->f_7u9 = value;
2048       break;
2049     case MEP_OPERAND_UDISP7A2 :
2050       fields->f_7u9a2 = value;
2051       break;
2052     case MEP_OPERAND_UDISP7A4 :
2053       fields->f_7u9a4 = value;
2054       break;
2055     case MEP_OPERAND_UIMM16 :
2056       fields->f_16u16 = value;
2057       break;
2058     case MEP_OPERAND_UIMM2 :
2059       fields->f_2u10 = value;
2060       break;
2061     case MEP_OPERAND_UIMM24 :
2062       fields->f_24u8n = value;
2063       break;
2064     case MEP_OPERAND_UIMM3 :
2065       fields->f_3u5 = value;
2066       break;
2067     case MEP_OPERAND_UIMM4 :
2068       fields->f_4u8 = value;
2069       break;
2070     case MEP_OPERAND_UIMM5 :
2071       fields->f_5u8 = value;
2072       break;
2073     case MEP_OPERAND_UIMM7A4 :
2074       fields->f_7u9a4 = value;
2075       break;
2076     case MEP_OPERAND_ZERO :
2077       break;
2078
2079     default :
2080       /* xgettext:c-format */
2081       fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
2082                        opindex);
2083       abort ();
2084   }
2085 }
2086
2087 void
2088 mep_cgen_set_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
2089                              int opindex,
2090                              CGEN_FIELDS * fields,
2091                              bfd_vma value)
2092 {
2093   switch (opindex)
2094     {
2095     case MEP_OPERAND_ADDR24A4 :
2096       fields->f_24u8a4n = value;
2097       break;
2098     case MEP_OPERAND_CALLNUM :
2099       fields->f_callnum = value;
2100       break;
2101     case MEP_OPERAND_CCCC :
2102       fields->f_rm = value;
2103       break;
2104     case MEP_OPERAND_CCRN :
2105       fields->f_ccrn = value;
2106       break;
2107     case MEP_OPERAND_CDISP8 :
2108       fields->f_8s24 = value;
2109       break;
2110     case MEP_OPERAND_CDISP8A2 :
2111       fields->f_8s24a2 = value;
2112       break;
2113     case MEP_OPERAND_CDISP8A4 :
2114       fields->f_8s24a4 = value;
2115       break;
2116     case MEP_OPERAND_CDISP8A8 :
2117       fields->f_8s24a8 = value;
2118       break;
2119     case MEP_OPERAND_CIMM4 :
2120       fields->f_rn = value;
2121       break;
2122     case MEP_OPERAND_CIMM5 :
2123       fields->f_5u24 = value;
2124       break;
2125     case MEP_OPERAND_CODE16 :
2126       fields->f_16u16 = value;
2127       break;
2128     case MEP_OPERAND_CODE24 :
2129       fields->f_24u4n = value;
2130       break;
2131     case MEP_OPERAND_CP_FLAG :
2132       break;
2133     case MEP_OPERAND_CRN :
2134       fields->f_crn = value;
2135       break;
2136     case MEP_OPERAND_CRN64 :
2137       fields->f_crn = value;
2138       break;
2139     case MEP_OPERAND_CRNX :
2140       fields->f_crnx = value;
2141       break;
2142     case MEP_OPERAND_CRNX64 :
2143       fields->f_crnx = value;
2144       break;
2145     case MEP_OPERAND_CSRN :
2146       fields->f_csrn = value;
2147       break;
2148     case MEP_OPERAND_CSRN_IDX :
2149       fields->f_csrn = value;
2150       break;
2151     case MEP_OPERAND_DBG :
2152       break;
2153     case MEP_OPERAND_DEPC :
2154       break;
2155     case MEP_OPERAND_EPC :
2156       break;
2157     case MEP_OPERAND_EXC :
2158       break;
2159     case MEP_OPERAND_HI :
2160       break;
2161     case MEP_OPERAND_LO :
2162       break;
2163     case MEP_OPERAND_LP :
2164       break;
2165     case MEP_OPERAND_MB0 :
2166       break;
2167     case MEP_OPERAND_MB1 :
2168       break;
2169     case MEP_OPERAND_ME0 :
2170       break;
2171     case MEP_OPERAND_ME1 :
2172       break;
2173     case MEP_OPERAND_NPC :
2174       break;
2175     case MEP_OPERAND_OPT :
2176       break;
2177     case MEP_OPERAND_PCABS24A2 :
2178       fields->f_24u5a2n = value;
2179       break;
2180     case MEP_OPERAND_PCREL12A2 :
2181       fields->f_12s4a2 = value;
2182       break;
2183     case MEP_OPERAND_PCREL17A2 :
2184       fields->f_17s16a2 = value;
2185       break;
2186     case MEP_OPERAND_PCREL24A2 :
2187       fields->f_24s5a2n = value;
2188       break;
2189     case MEP_OPERAND_PCREL8A2 :
2190       fields->f_8s8a2 = value;
2191       break;
2192     case MEP_OPERAND_PSW :
2193       break;
2194     case MEP_OPERAND_R0 :
2195       break;
2196     case MEP_OPERAND_R1 :
2197       break;
2198     case MEP_OPERAND_RL :
2199       fields->f_rl = value;
2200       break;
2201     case MEP_OPERAND_RM :
2202       fields->f_rm = value;
2203       break;
2204     case MEP_OPERAND_RMA :
2205       fields->f_rm = value;
2206       break;
2207     case MEP_OPERAND_RN :
2208       fields->f_rn = value;
2209       break;
2210     case MEP_OPERAND_RN3 :
2211       fields->f_rn3 = value;
2212       break;
2213     case MEP_OPERAND_RN3C :
2214       fields->f_rn3 = value;
2215       break;
2216     case MEP_OPERAND_RN3L :
2217       fields->f_rn3 = value;
2218       break;
2219     case MEP_OPERAND_RN3S :
2220       fields->f_rn3 = value;
2221       break;
2222     case MEP_OPERAND_RN3UC :
2223       fields->f_rn3 = value;
2224       break;
2225     case MEP_OPERAND_RN3UL :
2226       fields->f_rn3 = value;
2227       break;
2228     case MEP_OPERAND_RN3US :
2229       fields->f_rn3 = value;
2230       break;
2231     case MEP_OPERAND_RNC :
2232       fields->f_rn = value;
2233       break;
2234     case MEP_OPERAND_RNL :
2235       fields->f_rn = value;
2236       break;
2237     case MEP_OPERAND_RNS :
2238       fields->f_rn = value;
2239       break;
2240     case MEP_OPERAND_RNUC :
2241       fields->f_rn = value;
2242       break;
2243     case MEP_OPERAND_RNUL :
2244       fields->f_rn = value;
2245       break;
2246     case MEP_OPERAND_RNUS :
2247       fields->f_rn = value;
2248       break;
2249     case MEP_OPERAND_SAR :
2250       break;
2251     case MEP_OPERAND_SDISP16 :
2252       fields->f_16s16 = value;
2253       break;
2254     case MEP_OPERAND_SIMM16 :
2255       fields->f_16s16 = value;
2256       break;
2257     case MEP_OPERAND_SIMM6 :
2258       fields->f_6s8 = value;
2259       break;
2260     case MEP_OPERAND_SIMM8 :
2261       fields->f_8s8 = value;
2262       break;
2263     case MEP_OPERAND_SP :
2264       break;
2265     case MEP_OPERAND_SPR :
2266       break;
2267     case MEP_OPERAND_TP :
2268       break;
2269     case MEP_OPERAND_TPR :
2270       break;
2271     case MEP_OPERAND_UDISP2 :
2272       fields->f_2u6 = value;
2273       break;
2274     case MEP_OPERAND_UDISP7 :
2275       fields->f_7u9 = value;
2276       break;
2277     case MEP_OPERAND_UDISP7A2 :
2278       fields->f_7u9a2 = value;
2279       break;
2280     case MEP_OPERAND_UDISP7A4 :
2281       fields->f_7u9a4 = value;
2282       break;
2283     case MEP_OPERAND_UIMM16 :
2284       fields->f_16u16 = value;
2285       break;
2286     case MEP_OPERAND_UIMM2 :
2287       fields->f_2u10 = value;
2288       break;
2289     case MEP_OPERAND_UIMM24 :
2290       fields->f_24u8n = value;
2291       break;
2292     case MEP_OPERAND_UIMM3 :
2293       fields->f_3u5 = value;
2294       break;
2295     case MEP_OPERAND_UIMM4 :
2296       fields->f_4u8 = value;
2297       break;
2298     case MEP_OPERAND_UIMM5 :
2299       fields->f_5u8 = value;
2300       break;
2301     case MEP_OPERAND_UIMM7A4 :
2302       fields->f_7u9a4 = value;
2303       break;
2304     case MEP_OPERAND_ZERO :
2305       break;
2306
2307     default :
2308       /* xgettext:c-format */
2309       fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
2310                        opindex);
2311       abort ();
2312   }
2313 }
2314
2315 /* Function to call before using the instruction builder tables.  */
2316
2317 void
2318 mep_cgen_init_ibld_table (CGEN_CPU_DESC cd)
2319 {
2320   cd->insert_handlers = & mep_cgen_insert_handlers[0];
2321   cd->extract_handlers = & mep_cgen_extract_handlers[0];
2322
2323   cd->insert_operand = mep_cgen_insert_operand;
2324   cd->extract_operand = mep_cgen_extract_operand;
2325
2326   cd->get_int_operand = mep_cgen_get_int_operand;
2327   cd->set_int_operand = mep_cgen_set_int_operand;
2328   cd->get_vma_operand = mep_cgen_get_vma_operand;
2329   cd->set_vma_operand = mep_cgen_set_vma_operand;
2330 }