opcodes/mt-ibld.c

   1 /* Instruction building/extraction support for mt. -*- C -*-
   2
   3    THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
   4    - the resultant file is machine generated, cgen-ibld.in isn't
   5
   6    Copyright (C) 1996-2016 Free Software Foundation, Inc.
   7
   8    This file is part of libopcodes.
   9
  10    This library is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3, or (at your option)
  13    any later version.
  14
  15    It is distributed in the hope that it will be useful, but WITHOUT
  16    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  18    License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software Foundation, Inc.,
  22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  23
  24 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
  25    Keep that in mind.  */
  26
  27 #include "sysdep.h"
  28 #include <stdio.h>
  29 #include "ansidecl.h"
  30 #include "dis-asm.h"
  31 #include "bfd.h"
  32 #include "symcat.h"
  33 #include "mt-desc.h"
  34 #include "mt-opc.h"
  35 #include "cgen/basic-modes.h"
  36 #include "opintl.h"
  37 #include "safe-ctype.h"
  38
  39 #undef  min
  40 #define min(a,b) ((a) < (b) ? (a) : (b))
  41 #undef  max
  42 #define max(a,b) ((a) > (b) ? (a) : (b))
  43
  44 /* Used by the ifield rtx function.  */
  45 #define FLD(f) (fields->f)
  46
  47 static const char * insert_normal
  48   (CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int,
  49    unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR);
  50 static const char * insert_insn_normal
  51   (CGEN_CPU_DESC, const CGEN_INSN *,
  52    CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
  53 static int extract_normal
  54   (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
  55    unsigned int, unsigned int, unsigned int, unsigned int,
  56    unsigned int, unsigned int, bfd_vma, long *);
  57 static int extract_insn_normal
  58   (CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
  59    CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
  60 #if CGEN_INT_INSN_P
  61 static void put_insn_int_value
  62   (CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT);
  63 #endif
  64 #if ! CGEN_INT_INSN_P
  65 static CGEN_INLINE void insert_1
  66   (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *);
  67 static CGEN_INLINE int fill_cache
  68   (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *,  int, int, bfd_vma);
  69 static CGEN_INLINE long extract_1
  70   (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma);
  71 #endif
  72 \f
  73 /* Operand insertion.  */
  74
  75 #if ! CGEN_INT_INSN_P
  76
  77 /* Subroutine of insert_normal.  */
  78
  79 static CGEN_INLINE void
  80 insert_1 (CGEN_CPU_DESC cd,
  81           unsigned long value,
  82           int start,
  83           int length,
  84           int word_length,
  85           unsigned char *bufp)
  86 {
  87   unsigned long x,mask;
  88   int shift;
  89
  90   x = cgen_get_insn_value (cd, bufp, word_length);
  91
  92   /* Written this way to avoid undefined behaviour.  */
  93   mask = (((1L << (length - 1)) - 1) << 1) | 1;
  94   if (CGEN_INSN_LSB0_P)
  95     shift = (start + 1) - length;
  96   else
  97     shift = (word_length - (start + length));
  98   x = (x & ~(mask << shift)) | ((value & mask) << shift);
  99
 100   cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x);
 101 }
 102
 103 #endif /* ! CGEN_INT_INSN_P */
 104
 105 /* Default insertion routine.
 106
 107    ATTRS is a mask of the boolean attributes.
 108    WORD_OFFSET is the offset in bits from the start of the insn of the value.
 109    WORD_LENGTH is the length of the word in bits in which the value resides.
 110    START is the starting bit number in the word, architecture origin.
 111    LENGTH is the length of VALUE in bits.
 112    TOTAL_LENGTH is the total length of the insn in bits.
 113
 114    The result is an error message or NULL if success.  */
 115
 116 /* ??? This duplicates functionality with bfd's howto table and
 117    bfd_install_relocation.  */
 118 /* ??? This doesn't handle bfd_vma's.  Create another function when
 119    necessary.  */
 120
 121 static const char *
 122 insert_normal (CGEN_CPU_DESC cd,
 123                long value,
 124                unsigned int attrs,
 125                unsigned int word_offset,
 126                unsigned int start,
 127                unsigned int length,
 128                unsigned int word_length,
 129                unsigned int total_length,
 130                CGEN_INSN_BYTES_PTR buffer)
 131 {
 132   static char errbuf[100];
 133   /* Written this way to avoid undefined behaviour.  */
 134   unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
 135
 136   /* If LENGTH is zero, this operand doesn't contribute to the value.  */
 137   if (length == 0)
 138     return NULL;
 139
 140   if (word_length > 8 * sizeof (CGEN_INSN_INT))
 141     abort ();
 142
 143   /* For architectures with insns smaller than the base-insn-bitsize,
 144      word_length may be too big.  */
 145   if (cd->min_insn_bitsize < cd->base_insn_bitsize)
 146     {
 147       if (word_offset == 0
 148           && word_length > total_length)
 149         word_length = total_length;
 150     }
 151
 152   /* Ensure VALUE will fit.  */
 153   if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
 154     {
 155       long minval = - (1L << (length - 1));
 156       unsigned long maxval = mask;
 157
 158       if ((value > 0 && (unsigned long) value > maxval)
 159           || value < minval)
 160         {
 161           /* xgettext:c-format */
 162           sprintf (errbuf,
 163                    _("operand out of range (%ld not between %ld and %lu)"),
 164                    value, minval, maxval);
 165           return errbuf;
 166         }
 167     }
 168   else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
 169     {
 170       unsigned long maxval = mask;
 171       unsigned long val = (unsigned long) value;
 172
 173       /* For hosts with a word size > 32 check to see if value has been sign
 174          extended beyond 32 bits.  If so then ignore these higher sign bits
 175          as the user is attempting to store a 32-bit signed value into an
 176          unsigned 32-bit field which is allowed.  */
 177       if (sizeof (unsigned long) > 4 && ((value >> 32) == -1))
 178         val &= 0xFFFFFFFF;
 179
 180       if (val > maxval)
 181         {
 182           /* xgettext:c-format */
 183           sprintf (errbuf,
 184                    _("operand out of range (0x%lx not between 0 and 0x%lx)"),
 185                    val, maxval);
 186           return errbuf;
 187         }
 188     }
 189   else
 190     {
 191       if (! cgen_signed_overflow_ok_p (cd))
 192         {
 193           long minval = - (1L << (length - 1));
 194           long maxval =   (1L << (length - 1)) - 1;
 195
 196           if (value < minval || value > maxval)
 197             {
 198               sprintf
 199                 /* xgettext:c-format */
 200                 (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
 201                  value, minval, maxval);
 202               return errbuf;
 203             }
 204         }
 205     }
 206
 207 #if CGEN_INT_INSN_P
 208
 209   {
 210     int shift;
 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 > 8 * sizeof (CGEN_INSN_INT))
 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 > 8 * sizeof (CGEN_INSN_INT))
 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 * mt_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 mt_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 MT_OPERAND_A23 :
 569       errmsg = insert_normal (cd, fields->f_a23, 0, 0, 23, 1, 32, total_length, buffer);
 570       break;
 571     case MT_OPERAND_BALL :
 572       errmsg = insert_normal (cd, fields->f_ball, 0, 0, 19, 1, 32, total_length, buffer);
 573       break;
 574     case MT_OPERAND_BALL2 :
 575       errmsg = insert_normal (cd, fields->f_ball2, 0, 0, 15, 1, 32, total_length, buffer);
 576       break;
 577     case MT_OPERAND_BANKADDR :
 578       errmsg = insert_normal (cd, fields->f_bankaddr, 0, 0, 25, 13, 32, total_length, buffer);
 579       break;
 580     case MT_OPERAND_BRC :
 581       errmsg = insert_normal (cd, fields->f_brc, 0, 0, 18, 3, 32, total_length, buffer);
 582       break;
 583     case MT_OPERAND_BRC2 :
 584       errmsg = insert_normal (cd, fields->f_brc2, 0, 0, 14, 3, 32, total_length, buffer);
 585       break;
 586     case MT_OPERAND_CB1INCR :
 587       errmsg = insert_normal (cd, fields->f_cb1incr, 0|(1<<CGEN_IFLD_SIGNED), 0, 19, 6, 32, total_length, buffer);
 588       break;
 589     case MT_OPERAND_CB1SEL :
 590       errmsg = insert_normal (cd, fields->f_cb1sel, 0, 0, 25, 3, 32, total_length, buffer);
 591       break;
 592     case MT_OPERAND_CB2INCR :
 593       errmsg = insert_normal (cd, fields->f_cb2incr, 0|(1<<CGEN_IFLD_SIGNED), 0, 13, 6, 32, total_length, buffer);
 594       break;
 595     case MT_OPERAND_CB2SEL :
 596       errmsg = insert_normal (cd, fields->f_cb2sel, 0, 0, 22, 3, 32, total_length, buffer);
 597       break;
 598     case MT_OPERAND_CBRB :
 599       errmsg = insert_normal (cd, fields->f_cbrb, 0, 0, 10, 1, 32, total_length, buffer);
 600       break;
 601     case MT_OPERAND_CBS :
 602       errmsg = insert_normal (cd, fields->f_cbs, 0, 0, 19, 2, 32, total_length, buffer);
 603       break;
 604     case MT_OPERAND_CBX :
 605       errmsg = insert_normal (cd, fields->f_cbx, 0, 0, 14, 3, 32, total_length, buffer);
 606       break;
 607     case MT_OPERAND_CCB :
 608       errmsg = insert_normal (cd, fields->f_ccb, 0, 0, 11, 1, 32, total_length, buffer);
 609       break;
 610     case MT_OPERAND_CDB :
 611       errmsg = insert_normal (cd, fields->f_cdb, 0, 0, 10, 1, 32, total_length, buffer);
 612       break;
 613     case MT_OPERAND_CELL :
 614       errmsg = insert_normal (cd, fields->f_cell, 0, 0, 9, 3, 32, total_length, buffer);
 615       break;
 616     case MT_OPERAND_COLNUM :
 617       errmsg = insert_normal (cd, fields->f_colnum, 0, 0, 18, 3, 32, total_length, buffer);
 618       break;
 619     case MT_OPERAND_CONTNUM :
 620       errmsg = insert_normal (cd, fields->f_contnum, 0, 0, 8, 9, 32, total_length, buffer);
 621       break;
 622     case MT_OPERAND_CR :
 623       errmsg = insert_normal (cd, fields->f_cr, 0, 0, 22, 3, 32, total_length, buffer);
 624       break;
 625     case MT_OPERAND_CTXDISP :
 626       errmsg = insert_normal (cd, fields->f_ctxdisp, 0, 0, 5, 6, 32, total_length, buffer);
 627       break;
 628     case MT_OPERAND_DUP :
 629       errmsg = insert_normal (cd, fields->f_dup, 0, 0, 6, 1, 32, total_length, buffer);
 630       break;
 631     case MT_OPERAND_FBDISP :
 632       errmsg = insert_normal (cd, fields->f_fbdisp, 0, 0, 15, 6, 32, total_length, buffer);
 633       break;
 634     case MT_OPERAND_FBINCR :
 635       errmsg = insert_normal (cd, fields->f_fbincr, 0, 0, 23, 4, 32, total_length, buffer);
 636       break;
 637     case MT_OPERAND_FRDR :
 638       errmsg = insert_normal (cd, fields->f_dr, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 19, 4, 32, total_length, buffer);
 639       break;
 640     case MT_OPERAND_FRDRRR :
 641       errmsg = insert_normal (cd, fields->f_drrr, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 15, 4, 32, total_length, buffer);
 642       break;
 643     case MT_OPERAND_FRSR1 :
 644       errmsg = insert_normal (cd, fields->f_sr1, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 23, 4, 32, total_length, buffer);
 645       break;
 646     case MT_OPERAND_FRSR2 :
 647       errmsg = insert_normal (cd, fields->f_sr2, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 19, 4, 32, total_length, buffer);
 648       break;
 649     case MT_OPERAND_ID :
 650       errmsg = insert_normal (cd, fields->f_id, 0, 0, 14, 1, 32, total_length, buffer);
 651       break;
 652     case MT_OPERAND_IMM16 :
 653       {
 654         long value = fields->f_imm16s;
 655         value = ((value) + (0));
 656         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
 657       }
 658       break;
 659     case MT_OPERAND_IMM16L :
 660       errmsg = insert_normal (cd, fields->f_imm16l, 0, 0, 23, 16, 32, total_length, buffer);
 661       break;
 662     case MT_OPERAND_IMM16O :
 663       {
 664         long value = fields->f_imm16s;
 665         value = ((value) + (0));
 666         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
 667       }
 668       break;
 669     case MT_OPERAND_IMM16Z :
 670       errmsg = insert_normal (cd, fields->f_imm16u, 0, 0, 15, 16, 32, total_length, buffer);
 671       break;
 672     case MT_OPERAND_INCAMT :
 673       errmsg = insert_normal (cd, fields->f_incamt, 0, 0, 19, 8, 32, total_length, buffer);
 674       break;
 675     case MT_OPERAND_INCR :
 676       errmsg = insert_normal (cd, fields->f_incr, 0, 0, 17, 6, 32, total_length, buffer);
 677       break;
 678     case MT_OPERAND_LENGTH :
 679       errmsg = insert_normal (cd, fields->f_length, 0, 0, 15, 3, 32, total_length, buffer);
 680       break;
 681     case MT_OPERAND_LOOPSIZE :
 682       {
 683         long value = fields->f_loopo;
 684         value = ((USI) (value) >> (2));
 685         errmsg = insert_normal (cd, value, 0, 0, 7, 8, 32, total_length, buffer);
 686       }
 687       break;
 688     case MT_OPERAND_MASK :
 689       errmsg = insert_normal (cd, fields->f_mask, 0, 0, 25, 16, 32, total_length, buffer);
 690       break;
 691     case MT_OPERAND_MASK1 :
 692       errmsg = insert_normal (cd, fields->f_mask1, 0, 0, 22, 3, 32, total_length, buffer);
 693       break;
 694     case MT_OPERAND_MODE :
 695       errmsg = insert_normal (cd, fields->f_mode, 0, 0, 25, 2, 32, total_length, buffer);
 696       break;
 697     case MT_OPERAND_PERM :
 698       errmsg = insert_normal (cd, fields->f_perm, 0, 0, 25, 2, 32, total_length, buffer);
 699       break;
 700     case MT_OPERAND_RBBC :
 701       errmsg = insert_normal (cd, fields->f_rbbc, 0, 0, 25, 2, 32, total_length, buffer);
 702       break;
 703     case MT_OPERAND_RC :
 704       errmsg = insert_normal (cd, fields->f_rc, 0, 0, 15, 1, 32, total_length, buffer);
 705       break;
 706     case MT_OPERAND_RC1 :
 707       errmsg = insert_normal (cd, fields->f_rc1, 0, 0, 11, 1, 32, total_length, buffer);
 708       break;
 709     case MT_OPERAND_RC2 :
 710       errmsg = insert_normal (cd, fields->f_rc2, 0, 0, 6, 1, 32, total_length, buffer);
 711       break;
 712     case MT_OPERAND_RC3 :
 713       errmsg = insert_normal (cd, fields->f_rc3, 0, 0, 7, 1, 32, total_length, buffer);
 714       break;
 715     case MT_OPERAND_RCNUM :
 716       errmsg = insert_normal (cd, fields->f_rcnum, 0, 0, 14, 3, 32, total_length, buffer);
 717       break;
 718     case MT_OPERAND_RDA :
 719       errmsg = insert_normal (cd, fields->f_rda, 0, 0, 25, 1, 32, total_length, buffer);
 720       break;
 721     case MT_OPERAND_ROWNUM :
 722       errmsg = insert_normal (cd, fields->f_rownum, 0, 0, 14, 3, 32, total_length, buffer);
 723       break;
 724     case MT_OPERAND_ROWNUM1 :
 725       errmsg = insert_normal (cd, fields->f_rownum1, 0, 0, 12, 3, 32, total_length, buffer);
 726       break;
 727     case MT_OPERAND_ROWNUM2 :
 728       errmsg = insert_normal (cd, fields->f_rownum2, 0, 0, 9, 3, 32, total_length, buffer);
 729       break;
 730     case MT_OPERAND_SIZE :
 731       errmsg = insert_normal (cd, fields->f_size, 0, 0, 13, 14, 32, total_length, buffer);
 732       break;
 733     case MT_OPERAND_TYPE :
 734       errmsg = insert_normal (cd, fields->f_type, 0, 0, 21, 2, 32, total_length, buffer);
 735       break;
 736     case MT_OPERAND_WR :
 737       errmsg = insert_normal (cd, fields->f_wr, 0, 0, 24, 1, 32, total_length, buffer);
 738       break;
 739     case MT_OPERAND_XMODE :
 740       errmsg = insert_normal (cd, fields->f_xmode, 0, 0, 23, 1, 32, total_length, buffer);
 741       break;
 742
 743     default :
 744       /* xgettext:c-format */
 745       fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
 746                opindex);
 747       abort ();
 748   }
 749
 750   return errmsg;
 751 }
 752
 753 int mt_cgen_extract_operand
 754   (CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
 755
 756 /* Main entry point for operand extraction.
 757    The result is <= 0 for error, >0 for success.
 758    ??? Actual values aren't well defined right now.
 759
 760    This function is basically just a big switch statement.  Earlier versions
 761    used tables to look up the function to use, but
 762    - if the table contains both assembler and disassembler functions then
 763      the disassembler contains much of the assembler and vice-versa,
 764    - there's a lot of inlining possibilities as things grow,
 765    - using a switch statement avoids the function call overhead.
 766
 767    This function could be moved into `print_insn_normal', but keeping it
 768    separate makes clear the interface between `print_insn_normal' and each of
 769    the handlers.  */
 770
 771 int
 772 mt_cgen_extract_operand (CGEN_CPU_DESC cd,
 773                              int opindex,
 774                              CGEN_EXTRACT_INFO *ex_info,
 775                              CGEN_INSN_INT insn_value,
 776                              CGEN_FIELDS * fields,
 777                              bfd_vma pc)
 778 {
 779   /* Assume success (for those operands that are nops).  */
 780   int length = 1;
 781   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 782
 783   switch (opindex)
 784     {
 785     case MT_OPERAND_A23 :
 786       length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 1, 32, total_length, pc, & fields->f_a23);
 787       break;
 788     case MT_OPERAND_BALL :
 789       length = extract_normal (cd, ex_info, insn_value, 0, 0, 19, 1, 32, total_length, pc, & fields->f_ball);
 790       break;
 791     case MT_OPERAND_BALL2 :
 792       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_ball2);
 793       break;
 794     case MT_OPERAND_BANKADDR :
 795       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 13, 32, total_length, pc, & fields->f_bankaddr);
 796       break;
 797     case MT_OPERAND_BRC :
 798       length = extract_normal (cd, ex_info, insn_value, 0, 0, 18, 3, 32, total_length, pc, & fields->f_brc);
 799       break;
 800     case MT_OPERAND_BRC2 :
 801       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_brc2);
 802       break;
 803     case MT_OPERAND_CB1INCR :
 804       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 19, 6, 32, total_length, pc, & fields->f_cb1incr);
 805       break;
 806     case MT_OPERAND_CB1SEL :
 807       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 3, 32, total_length, pc, & fields->f_cb1sel);
 808       break;
 809     case MT_OPERAND_CB2INCR :
 810       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 13, 6, 32, total_length, pc, & fields->f_cb2incr);
 811       break;
 812     case MT_OPERAND_CB2SEL :
 813       length = extract_normal (cd, ex_info, insn_value, 0, 0, 22, 3, 32, total_length, pc, & fields->f_cb2sel);
 814       break;
 815     case MT_OPERAND_CBRB :
 816       length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 1, 32, total_length, pc, & fields->f_cbrb);
 817       break;
 818     case MT_OPERAND_CBS :
 819       length = extract_normal (cd, ex_info, insn_value, 0, 0, 19, 2, 32, total_length, pc, & fields->f_cbs);
 820       break;
 821     case MT_OPERAND_CBX :
 822       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_cbx);
 823       break;
 824     case MT_OPERAND_CCB :
 825       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 1, 32, total_length, pc, & fields->f_ccb);
 826       break;
 827     case MT_OPERAND_CDB :
 828       length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 1, 32, total_length, pc, & fields->f_cdb);
 829       break;
 830     case MT_OPERAND_CELL :
 831       length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 3, 32, total_length, pc, & fields->f_cell);
 832       break;
 833     case MT_OPERAND_COLNUM :
 834       length = extract_normal (cd, ex_info, insn_value, 0, 0, 18, 3, 32, total_length, pc, & fields->f_colnum);
 835       break;
 836     case MT_OPERAND_CONTNUM :
 837       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 9, 32, total_length, pc, & fields->f_contnum);
 838       break;
 839     case MT_OPERAND_CR :
 840       length = extract_normal (cd, ex_info, insn_value, 0, 0, 22, 3, 32, total_length, pc, & fields->f_cr);
 841       break;
 842     case MT_OPERAND_CTXDISP :
 843       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_ctxdisp);
 844       break;
 845     case MT_OPERAND_DUP :
 846       length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 1, 32, total_length, pc, & fields->f_dup);
 847       break;
 848     case MT_OPERAND_FBDISP :
 849       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 6, 32, total_length, pc, & fields->f_fbdisp);
 850       break;
 851     case MT_OPERAND_FBINCR :
 852       length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 4, 32, total_length, pc, & fields->f_fbincr);
 853       break;
 854     case MT_OPERAND_FRDR :
 855       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 19, 4, 32, total_length, pc, & fields->f_dr);
 856       break;
 857     case MT_OPERAND_FRDRRR :
 858       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 15, 4, 32, total_length, pc, & fields->f_drrr);
 859       break;
 860     case MT_OPERAND_FRSR1 :
 861       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 23, 4, 32, total_length, pc, & fields->f_sr1);
 862       break;
 863     case MT_OPERAND_FRSR2 :
 864       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 19, 4, 32, total_length, pc, & fields->f_sr2);
 865       break;
 866     case MT_OPERAND_ID :
 867       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 1, 32, total_length, pc, & fields->f_id);
 868       break;
 869     case MT_OPERAND_IMM16 :
 870       {
 871         long value;
 872         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & value);
 873         value = ((value) + (0));
 874         fields->f_imm16s = value;
 875       }
 876       break;
 877     case MT_OPERAND_IMM16L :
 878       length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 16, 32, total_length, pc, & fields->f_imm16l);
 879       break;
 880     case MT_OPERAND_IMM16O :
 881       {
 882         long value;
 883         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & value);
 884         value = ((value) + (0));
 885         fields->f_imm16s = value;
 886       }
 887       break;
 888     case MT_OPERAND_IMM16Z :
 889       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_imm16u);
 890       break;
 891     case MT_OPERAND_INCAMT :
 892       length = extract_normal (cd, ex_info, insn_value, 0, 0, 19, 8, 32, total_length, pc, & fields->f_incamt);
 893       break;
 894     case MT_OPERAND_INCR :
 895       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_incr);
 896       break;
 897     case MT_OPERAND_LENGTH :
 898       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 3, 32, total_length, pc, & fields->f_length);
 899       break;
 900     case MT_OPERAND_LOOPSIZE :
 901       {
 902         long value;
 903         length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 32, total_length, pc, & value);
 904         value = ((((value) << (2))) + (8));
 905         fields->f_loopo = value;
 906       }
 907       break;
 908     case MT_OPERAND_MASK :
 909       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 16, 32, total_length, pc, & fields->f_mask);
 910       break;
 911     case MT_OPERAND_MASK1 :
 912       length = extract_normal (cd, ex_info, insn_value, 0, 0, 22, 3, 32, total_length, pc, & fields->f_mask1);
 913       break;
 914     case MT_OPERAND_MODE :
 915       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 2, 32, total_length, pc, & fields->f_mode);
 916       break;
 917     case MT_OPERAND_PERM :
 918       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 2, 32, total_length, pc, & fields->f_perm);
 919       break;
 920     case MT_OPERAND_RBBC :
 921       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 2, 32, total_length, pc, & fields->f_rbbc);
 922       break;
 923     case MT_OPERAND_RC :
 924       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_rc);
 925       break;
 926     case MT_OPERAND_RC1 :
 927       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 1, 32, total_length, pc, & fields->f_rc1);
 928       break;
 929     case MT_OPERAND_RC2 :
 930       length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 1, 32, total_length, pc, & fields->f_rc2);
 931       break;
 932     case MT_OPERAND_RC3 :
 933       length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 1, 32, total_length, pc, & fields->f_rc3);
 934       break;
 935     case MT_OPERAND_RCNUM :
 936       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_rcnum);
 937       break;
 938     case MT_OPERAND_RDA :
 939       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_rda);
 940       break;
 941     case MT_OPERAND_ROWNUM :
 942       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_rownum);
 943       break;
 944     case MT_OPERAND_ROWNUM1 :
 945       length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 3, 32, total_length, pc, & fields->f_rownum1);
 946       break;
 947     case MT_OPERAND_ROWNUM2 :
 948       length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 3, 32, total_length, pc, & fields->f_rownum2);
 949       break;
 950     case MT_OPERAND_SIZE :
 951       length = extract_normal (cd, ex_info, insn_value, 0, 0, 13, 14, 32, total_length, pc, & fields->f_size);
 952       break;
 953     case MT_OPERAND_TYPE :
 954       length = extract_normal (cd, ex_info, insn_value, 0, 0, 21, 2, 32, total_length, pc, & fields->f_type);
 955       break;
 956     case MT_OPERAND_WR :
 957       length = extract_normal (cd, ex_info, insn_value, 0, 0, 24, 1, 32, total_length, pc, & fields->f_wr);
 958       break;
 959     case MT_OPERAND_XMODE :
 960       length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 1, 32, total_length, pc, & fields->f_xmode);
 961       break;
 962
 963     default :
 964       /* xgettext:c-format */
 965       fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
 966                opindex);
 967       abort ();
 968     }
 969
 970   return length;
 971 }
 972
 973 cgen_insert_fn * const mt_cgen_insert_handlers[] =
 974 {
 975   insert_insn_normal,
 976 };
 977
 978 cgen_extract_fn * const mt_cgen_extract_handlers[] =
 979 {
 980   extract_insn_normal,
 981 };
 982
 983 int mt_cgen_get_int_operand     (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
 984 bfd_vma mt_cgen_get_vma_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
 985
 986 /* Getting values from cgen_fields is handled by a collection of functions.
 987    They are distinguished by the type of the VALUE argument they return.
 988    TODO: floating point, inlining support, remove cases where result type
 989    not appropriate.  */
 990
 991 int
 992 mt_cgen_get_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 993                              int opindex,
 994                              const CGEN_FIELDS * fields)
 995 {
 996   int value;
 997
 998   switch (opindex)
 999     {
1000     case MT_OPERAND_A23 :
1001       value = fields->f_a23;
1002       break;
1003     case MT_OPERAND_BALL :
1004       value = fields->f_ball;
1005       break;
1006     case MT_OPERAND_BALL2 :
1007       value = fields->f_ball2;
1008       break;
1009     case MT_OPERAND_BANKADDR :
1010       value = fields->f_bankaddr;
1011       break;
1012     case MT_OPERAND_BRC :
1013       value = fields->f_brc;
1014       break;
1015     case MT_OPERAND_BRC2 :
1016       value = fields->f_brc2;
1017       break;
1018     case MT_OPERAND_CB1INCR :
1019       value = fields->f_cb1incr;
1020       break;
1021     case MT_OPERAND_CB1SEL :
1022       value = fields->f_cb1sel;
1023       break;
1024     case MT_OPERAND_CB2INCR :
1025       value = fields->f_cb2incr;
1026       break;
1027     case MT_OPERAND_CB2SEL :
1028       value = fields->f_cb2sel;
1029       break;
1030     case MT_OPERAND_CBRB :
1031       value = fields->f_cbrb;
1032       break;
1033     case MT_OPERAND_CBS :
1034       value = fields->f_cbs;
1035       break;
1036     case MT_OPERAND_CBX :
1037       value = fields->f_cbx;
1038       break;
1039     case MT_OPERAND_CCB :
1040       value = fields->f_ccb;
1041       break;
1042     case MT_OPERAND_CDB :
1043       value = fields->f_cdb;
1044       break;
1045     case MT_OPERAND_CELL :
1046       value = fields->f_cell;
1047       break;
1048     case MT_OPERAND_COLNUM :
1049       value = fields->f_colnum;
1050       break;
1051     case MT_OPERAND_CONTNUM :
1052       value = fields->f_contnum;
1053       break;
1054     case MT_OPERAND_CR :
1055       value = fields->f_cr;
1056       break;
1057     case MT_OPERAND_CTXDISP :
1058       value = fields->f_ctxdisp;
1059       break;
1060     case MT_OPERAND_DUP :
1061       value = fields->f_dup;
1062       break;
1063     case MT_OPERAND_FBDISP :
1064       value = fields->f_fbdisp;
1065       break;
1066     case MT_OPERAND_FBINCR :
1067       value = fields->f_fbincr;
1068       break;
1069     case MT_OPERAND_FRDR :
1070       value = fields->f_dr;
1071       break;
1072     case MT_OPERAND_FRDRRR :
1073       value = fields->f_drrr;
1074       break;
1075     case MT_OPERAND_FRSR1 :
1076       value = fields->f_sr1;
1077       break;
1078     case MT_OPERAND_FRSR2 :
1079       value = fields->f_sr2;
1080       break;
1081     case MT_OPERAND_ID :
1082       value = fields->f_id;
1083       break;
1084     case MT_OPERAND_IMM16 :
1085       value = fields->f_imm16s;
1086       break;
1087     case MT_OPERAND_IMM16L :
1088       value = fields->f_imm16l;
1089       break;
1090     case MT_OPERAND_IMM16O :
1091       value = fields->f_imm16s;
1092       break;
1093     case MT_OPERAND_IMM16Z :
1094       value = fields->f_imm16u;
1095       break;
1096     case MT_OPERAND_INCAMT :
1097       value = fields->f_incamt;
1098       break;
1099     case MT_OPERAND_INCR :
1100       value = fields->f_incr;
1101       break;
1102     case MT_OPERAND_LENGTH :
1103       value = fields->f_length;
1104       break;
1105     case MT_OPERAND_LOOPSIZE :
1106       value = fields->f_loopo;
1107       break;
1108     case MT_OPERAND_MASK :
1109       value = fields->f_mask;
1110       break;
1111     case MT_OPERAND_MASK1 :
1112       value = fields->f_mask1;
1113       break;
1114     case MT_OPERAND_MODE :
1115       value = fields->f_mode;
1116       break;
1117     case MT_OPERAND_PERM :
1118       value = fields->f_perm;
1119       break;
1120     case MT_OPERAND_RBBC :
1121       value = fields->f_rbbc;
1122       break;
1123     case MT_OPERAND_RC :
1124       value = fields->f_rc;
1125       break;
1126     case MT_OPERAND_RC1 :
1127       value = fields->f_rc1;
1128       break;
1129     case MT_OPERAND_RC2 :
1130       value = fields->f_rc2;
1131       break;
1132     case MT_OPERAND_RC3 :
1133       value = fields->f_rc3;
1134       break;
1135     case MT_OPERAND_RCNUM :
1136       value = fields->f_rcnum;
1137       break;
1138     case MT_OPERAND_RDA :
1139       value = fields->f_rda;
1140       break;
1141     case MT_OPERAND_ROWNUM :
1142       value = fields->f_rownum;
1143       break;
1144     case MT_OPERAND_ROWNUM1 :
1145       value = fields->f_rownum1;
1146       break;
1147     case MT_OPERAND_ROWNUM2 :
1148       value = fields->f_rownum2;
1149       break;
1150     case MT_OPERAND_SIZE :
1151       value = fields->f_size;
1152       break;
1153     case MT_OPERAND_TYPE :
1154       value = fields->f_type;
1155       break;
1156     case MT_OPERAND_WR :
1157       value = fields->f_wr;
1158       break;
1159     case MT_OPERAND_XMODE :
1160       value = fields->f_xmode;
1161       break;
1162
1163     default :
1164       /* xgettext:c-format */
1165       fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
1166                        opindex);
1167       abort ();
1168   }
1169
1170   return value;
1171 }
1172
1173 bfd_vma
1174 mt_cgen_get_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1175                              int opindex,
1176                              const CGEN_FIELDS * fields)
1177 {
1178   bfd_vma value;
1179
1180   switch (opindex)
1181     {
1182     case MT_OPERAND_A23 :
1183       value = fields->f_a23;
1184       break;
1185     case MT_OPERAND_BALL :
1186       value = fields->f_ball;
1187       break;
1188     case MT_OPERAND_BALL2 :
1189       value = fields->f_ball2;
1190       break;
1191     case MT_OPERAND_BANKADDR :
1192       value = fields->f_bankaddr;
1193       break;
1194     case MT_OPERAND_BRC :
1195       value = fields->f_brc;
1196       break;
1197     case MT_OPERAND_BRC2 :
1198       value = fields->f_brc2;
1199       break;
1200     case MT_OPERAND_CB1INCR :
1201       value = fields->f_cb1incr;
1202       break;
1203     case MT_OPERAND_CB1SEL :
1204       value = fields->f_cb1sel;
1205       break;
1206     case MT_OPERAND_CB2INCR :
1207       value = fields->f_cb2incr;
1208       break;
1209     case MT_OPERAND_CB2SEL :
1210       value = fields->f_cb2sel;
1211       break;
1212     case MT_OPERAND_CBRB :
1213       value = fields->f_cbrb;
1214       break;
1215     case MT_OPERAND_CBS :
1216       value = fields->f_cbs;
1217       break;
1218     case MT_OPERAND_CBX :
1219       value = fields->f_cbx;
1220       break;
1221     case MT_OPERAND_CCB :
1222       value = fields->f_ccb;
1223       break;
1224     case MT_OPERAND_CDB :
1225       value = fields->f_cdb;
1226       break;
1227     case MT_OPERAND_CELL :
1228       value = fields->f_cell;
1229       break;
1230     case MT_OPERAND_COLNUM :
1231       value = fields->f_colnum;
1232       break;
1233     case MT_OPERAND_CONTNUM :
1234       value = fields->f_contnum;
1235       break;
1236     case MT_OPERAND_CR :
1237       value = fields->f_cr;
1238       break;
1239     case MT_OPERAND_CTXDISP :
1240       value = fields->f_ctxdisp;
1241       break;
1242     case MT_OPERAND_DUP :
1243       value = fields->f_dup;
1244       break;
1245     case MT_OPERAND_FBDISP :
1246       value = fields->f_fbdisp;
1247       break;
1248     case MT_OPERAND_FBINCR :
1249       value = fields->f_fbincr;
1250       break;
1251     case MT_OPERAND_FRDR :
1252       value = fields->f_dr;
1253       break;
1254     case MT_OPERAND_FRDRRR :
1255       value = fields->f_drrr;
1256       break;
1257     case MT_OPERAND_FRSR1 :
1258       value = fields->f_sr1;
1259       break;
1260     case MT_OPERAND_FRSR2 :
1261       value = fields->f_sr2;
1262       break;
1263     case MT_OPERAND_ID :
1264       value = fields->f_id;
1265       break;
1266     case MT_OPERAND_IMM16 :
1267       value = fields->f_imm16s;
1268       break;
1269     case MT_OPERAND_IMM16L :
1270       value = fields->f_imm16l;
1271       break;
1272     case MT_OPERAND_IMM16O :
1273       value = fields->f_imm16s;
1274       break;
1275     case MT_OPERAND_IMM16Z :
1276       value = fields->f_imm16u;
1277       break;
1278     case MT_OPERAND_INCAMT :
1279       value = fields->f_incamt;
1280       break;
1281     case MT_OPERAND_INCR :
1282       value = fields->f_incr;
1283       break;
1284     case MT_OPERAND_LENGTH :
1285       value = fields->f_length;
1286       break;
1287     case MT_OPERAND_LOOPSIZE :
1288       value = fields->f_loopo;
1289       break;
1290     case MT_OPERAND_MASK :
1291       value = fields->f_mask;
1292       break;
1293     case MT_OPERAND_MASK1 :
1294       value = fields->f_mask1;
1295       break;
1296     case MT_OPERAND_MODE :
1297       value = fields->f_mode;
1298       break;
1299     case MT_OPERAND_PERM :
1300       value = fields->f_perm;
1301       break;
1302     case MT_OPERAND_RBBC :
1303       value = fields->f_rbbc;
1304       break;
1305     case MT_OPERAND_RC :
1306       value = fields->f_rc;
1307       break;
1308     case MT_OPERAND_RC1 :
1309       value = fields->f_rc1;
1310       break;
1311     case MT_OPERAND_RC2 :
1312       value = fields->f_rc2;
1313       break;
1314     case MT_OPERAND_RC3 :
1315       value = fields->f_rc3;
1316       break;
1317     case MT_OPERAND_RCNUM :
1318       value = fields->f_rcnum;
1319       break;
1320     case MT_OPERAND_RDA :
1321       value = fields->f_rda;
1322       break;
1323     case MT_OPERAND_ROWNUM :
1324       value = fields->f_rownum;
1325       break;
1326     case MT_OPERAND_ROWNUM1 :
1327       value = fields->f_rownum1;
1328       break;
1329     case MT_OPERAND_ROWNUM2 :
1330       value = fields->f_rownum2;
1331       break;
1332     case MT_OPERAND_SIZE :
1333       value = fields->f_size;
1334       break;
1335     case MT_OPERAND_TYPE :
1336       value = fields->f_type;
1337       break;
1338     case MT_OPERAND_WR :
1339       value = fields->f_wr;
1340       break;
1341     case MT_OPERAND_XMODE :
1342       value = fields->f_xmode;
1343       break;
1344
1345     default :
1346       /* xgettext:c-format */
1347       fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
1348                        opindex);
1349       abort ();
1350   }
1351
1352   return value;
1353 }
1354
1355 void mt_cgen_set_int_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, int);
1356 void mt_cgen_set_vma_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma);
1357
1358 /* Stuffing values in cgen_fields is handled by a collection of functions.
1359    They are distinguished by the type of the VALUE argument they accept.
1360    TODO: floating point, inlining support, remove cases where argument type
1361    not appropriate.  */
1362
1363 void
1364 mt_cgen_set_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1365                              int opindex,
1366                              CGEN_FIELDS * fields,
1367                              int value)
1368 {
1369   switch (opindex)
1370     {
1371     case MT_OPERAND_A23 :
1372       fields->f_a23 = value;
1373       break;
1374     case MT_OPERAND_BALL :
1375       fields->f_ball = value;
1376       break;
1377     case MT_OPERAND_BALL2 :
1378       fields->f_ball2 = value;
1379       break;
1380     case MT_OPERAND_BANKADDR :
1381       fields->f_bankaddr = value;
1382       break;
1383     case MT_OPERAND_BRC :
1384       fields->f_brc = value;
1385       break;
1386     case MT_OPERAND_BRC2 :
1387       fields->f_brc2 = value;
1388       break;
1389     case MT_OPERAND_CB1INCR :
1390       fields->f_cb1incr = value;
1391       break;
1392     case MT_OPERAND_CB1SEL :
1393       fields->f_cb1sel = value;
1394       break;
1395     case MT_OPERAND_CB2INCR :
1396       fields->f_cb2incr = value;
1397       break;
1398     case MT_OPERAND_CB2SEL :
1399       fields->f_cb2sel = value;
1400       break;
1401     case MT_OPERAND_CBRB :
1402       fields->f_cbrb = value;
1403       break;
1404     case MT_OPERAND_CBS :
1405       fields->f_cbs = value;
1406       break;
1407     case MT_OPERAND_CBX :
1408       fields->f_cbx = value;
1409       break;
1410     case MT_OPERAND_CCB :
1411       fields->f_ccb = value;
1412       break;
1413     case MT_OPERAND_CDB :
1414       fields->f_cdb = value;
1415       break;
1416     case MT_OPERAND_CELL :
1417       fields->f_cell = value;
1418       break;
1419     case MT_OPERAND_COLNUM :
1420       fields->f_colnum = value;
1421       break;
1422     case MT_OPERAND_CONTNUM :
1423       fields->f_contnum = value;
1424       break;
1425     case MT_OPERAND_CR :
1426       fields->f_cr = value;
1427       break;
1428     case MT_OPERAND_CTXDISP :
1429       fields->f_ctxdisp = value;
1430       break;
1431     case MT_OPERAND_DUP :
1432       fields->f_dup = value;
1433       break;
1434     case MT_OPERAND_FBDISP :
1435       fields->f_fbdisp = value;
1436       break;
1437     case MT_OPERAND_FBINCR :
1438       fields->f_fbincr = value;
1439       break;
1440     case MT_OPERAND_FRDR :
1441       fields->f_dr = value;
1442       break;
1443     case MT_OPERAND_FRDRRR :
1444       fields->f_drrr = value;
1445       break;
1446     case MT_OPERAND_FRSR1 :
1447       fields->f_sr1 = value;
1448       break;
1449     case MT_OPERAND_FRSR2 :
1450       fields->f_sr2 = value;
1451       break;
1452     case MT_OPERAND_ID :
1453       fields->f_id = value;
1454       break;
1455     case MT_OPERAND_IMM16 :
1456       fields->f_imm16s = value;
1457       break;
1458     case MT_OPERAND_IMM16L :
1459       fields->f_imm16l = value;
1460       break;
1461     case MT_OPERAND_IMM16O :
1462       fields->f_imm16s = value;
1463       break;
1464     case MT_OPERAND_IMM16Z :
1465       fields->f_imm16u = value;
1466       break;
1467     case MT_OPERAND_INCAMT :
1468       fields->f_incamt = value;
1469       break;
1470     case MT_OPERAND_INCR :
1471       fields->f_incr = value;
1472       break;
1473     case MT_OPERAND_LENGTH :
1474       fields->f_length = value;
1475       break;
1476     case MT_OPERAND_LOOPSIZE :
1477       fields->f_loopo = value;
1478       break;
1479     case MT_OPERAND_MASK :
1480       fields->f_mask = value;
1481       break;
1482     case MT_OPERAND_MASK1 :
1483       fields->f_mask1 = value;
1484       break;
1485     case MT_OPERAND_MODE :
1486       fields->f_mode = value;
1487       break;
1488     case MT_OPERAND_PERM :
1489       fields->f_perm = value;
1490       break;
1491     case MT_OPERAND_RBBC :
1492       fields->f_rbbc = value;
1493       break;
1494     case MT_OPERAND_RC :
1495       fields->f_rc = value;
1496       break;
1497     case MT_OPERAND_RC1 :
1498       fields->f_rc1 = value;
1499       break;
1500     case MT_OPERAND_RC2 :
1501       fields->f_rc2 = value;
1502       break;
1503     case MT_OPERAND_RC3 :
1504       fields->f_rc3 = value;
1505       break;
1506     case MT_OPERAND_RCNUM :
1507       fields->f_rcnum = value;
1508       break;
1509     case MT_OPERAND_RDA :
1510       fields->f_rda = value;
1511       break;
1512     case MT_OPERAND_ROWNUM :
1513       fields->f_rownum = value;
1514       break;
1515     case MT_OPERAND_ROWNUM1 :
1516       fields->f_rownum1 = value;
1517       break;
1518     case MT_OPERAND_ROWNUM2 :
1519       fields->f_rownum2 = value;
1520       break;
1521     case MT_OPERAND_SIZE :
1522       fields->f_size = value;
1523       break;
1524     case MT_OPERAND_TYPE :
1525       fields->f_type = value;
1526       break;
1527     case MT_OPERAND_WR :
1528       fields->f_wr = value;
1529       break;
1530     case MT_OPERAND_XMODE :
1531       fields->f_xmode = value;
1532       break;
1533
1534     default :
1535       /* xgettext:c-format */
1536       fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
1537                        opindex);
1538       abort ();
1539   }
1540 }
1541
1542 void
1543 mt_cgen_set_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1544                              int opindex,
1545                              CGEN_FIELDS * fields,
1546                              bfd_vma value)
1547 {
1548   switch (opindex)
1549     {
1550     case MT_OPERAND_A23 :
1551       fields->f_a23 = value;
1552       break;
1553     case MT_OPERAND_BALL :
1554       fields->f_ball = value;
1555       break;
1556     case MT_OPERAND_BALL2 :
1557       fields->f_ball2 = value;
1558       break;
1559     case MT_OPERAND_BANKADDR :
1560       fields->f_bankaddr = value;
1561       break;
1562     case MT_OPERAND_BRC :
1563       fields->f_brc = value;
1564       break;
1565     case MT_OPERAND_BRC2 :
1566       fields->f_brc2 = value;
1567       break;
1568     case MT_OPERAND_CB1INCR :
1569       fields->f_cb1incr = value;
1570       break;
1571     case MT_OPERAND_CB1SEL :
1572       fields->f_cb1sel = value;
1573       break;
1574     case MT_OPERAND_CB2INCR :
1575       fields->f_cb2incr = value;
1576       break;
1577     case MT_OPERAND_CB2SEL :
1578       fields->f_cb2sel = value;
1579       break;
1580     case MT_OPERAND_CBRB :
1581       fields->f_cbrb = value;
1582       break;
1583     case MT_OPERAND_CBS :
1584       fields->f_cbs = value;
1585       break;
1586     case MT_OPERAND_CBX :
1587       fields->f_cbx = value;
1588       break;
1589     case MT_OPERAND_CCB :
1590       fields->f_ccb = value;
1591       break;
1592     case MT_OPERAND_CDB :
1593       fields->f_cdb = value;
1594       break;
1595     case MT_OPERAND_CELL :
1596       fields->f_cell = value;
1597       break;
1598     case MT_OPERAND_COLNUM :
1599       fields->f_colnum = value;
1600       break;
1601     case MT_OPERAND_CONTNUM :
1602       fields->f_contnum = value;
1603       break;
1604     case MT_OPERAND_CR :
1605       fields->f_cr = value;
1606       break;
1607     case MT_OPERAND_CTXDISP :
1608       fields->f_ctxdisp = value;
1609       break;
1610     case MT_OPERAND_DUP :
1611       fields->f_dup = value;
1612       break;
1613     case MT_OPERAND_FBDISP :
1614       fields->f_fbdisp = value;
1615       break;
1616     case MT_OPERAND_FBINCR :
1617       fields->f_fbincr = value;
1618       break;
1619     case MT_OPERAND_FRDR :
1620       fields->f_dr = value;
1621       break;
1622     case MT_OPERAND_FRDRRR :
1623       fields->f_drrr = value;
1624       break;
1625     case MT_OPERAND_FRSR1 :
1626       fields->f_sr1 = value;
1627       break;
1628     case MT_OPERAND_FRSR2 :
1629       fields->f_sr2 = value;
1630       break;
1631     case MT_OPERAND_ID :
1632       fields->f_id = value;
1633       break;
1634     case MT_OPERAND_IMM16 :
1635       fields->f_imm16s = value;
1636       break;
1637     case MT_OPERAND_IMM16L :
1638       fields->f_imm16l = value;
1639       break;
1640     case MT_OPERAND_IMM16O :
1641       fields->f_imm16s = value;
1642       break;
1643     case MT_OPERAND_IMM16Z :
1644       fields->f_imm16u = value;
1645       break;
1646     case MT_OPERAND_INCAMT :
1647       fields->f_incamt = value;
1648       break;
1649     case MT_OPERAND_INCR :
1650       fields->f_incr = value;
1651       break;
1652     case MT_OPERAND_LENGTH :
1653       fields->f_length = value;
1654       break;
1655     case MT_OPERAND_LOOPSIZE :
1656       fields->f_loopo = value;
1657       break;
1658     case MT_OPERAND_MASK :
1659       fields->f_mask = value;
1660       break;
1661     case MT_OPERAND_MASK1 :
1662       fields->f_mask1 = value;
1663       break;
1664     case MT_OPERAND_MODE :
1665       fields->f_mode = value;
1666       break;
1667     case MT_OPERAND_PERM :
1668       fields->f_perm = value;
1669       break;
1670     case MT_OPERAND_RBBC :
1671       fields->f_rbbc = value;
1672       break;
1673     case MT_OPERAND_RC :
1674       fields->f_rc = value;
1675       break;
1676     case MT_OPERAND_RC1 :
1677       fields->f_rc1 = value;
1678       break;
1679     case MT_OPERAND_RC2 :
1680       fields->f_rc2 = value;
1681       break;
1682     case MT_OPERAND_RC3 :
1683       fields->f_rc3 = value;
1684       break;
1685     case MT_OPERAND_RCNUM :
1686       fields->f_rcnum = value;
1687       break;
1688     case MT_OPERAND_RDA :
1689       fields->f_rda = value;
1690       break;
1691     case MT_OPERAND_ROWNUM :
1692       fields->f_rownum = value;
1693       break;
1694     case MT_OPERAND_ROWNUM1 :
1695       fields->f_rownum1 = value;
1696       break;
1697     case MT_OPERAND_ROWNUM2 :
1698       fields->f_rownum2 = value;
1699       break;
1700     case MT_OPERAND_SIZE :
1701       fields->f_size = value;
1702       break;
1703     case MT_OPERAND_TYPE :
1704       fields->f_type = value;
1705       break;
1706     case MT_OPERAND_WR :
1707       fields->f_wr = value;
1708       break;
1709     case MT_OPERAND_XMODE :
1710       fields->f_xmode = value;
1711       break;
1712
1713     default :
1714       /* xgettext:c-format */
1715       fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
1716                        opindex);
1717       abort ();
1718   }
1719 }
1720
1721 /* Function to call before using the instruction builder tables.  */
1722
1723 void
1724 mt_cgen_init_ibld_table (CGEN_CPU_DESC cd)
1725 {
1726   cd->insert_handlers = & mt_cgen_insert_handlers[0];
1727   cd->extract_handlers = & mt_cgen_extract_handlers[0];
1728
1729   cd->insert_operand = mt_cgen_insert_operand;
1730   cd->extract_operand = mt_cgen_extract_operand;
1731
1732   cd->get_int_operand = mt_cgen_get_int_operand;
1733   cd->set_int_operand = mt_cgen_set_int_operand;
1734   cd->get_vma_operand = mt_cgen_get_vma_operand;
1735   cd->set_vma_operand = mt_cgen_set_vma_operand;
1736 }