opcodes/mt-ibld.c

   1 /* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
   2 /* Instruction building/extraction support for mt. -*- C -*-
   3
   4    THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
   5    - the resultant file is machine generated, cgen-ibld.in isn't
   6
   7    Copyright (C) 1996-2023 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 "mt-desc.h"
  35 #include "mt-opc.h"
  36 #include "cgen/basic-modes.h"
  37 #include "opintl.h"
  38 #include "safe-ctype.h"
  39
  40 #undef  min
  41 #define min(a,b) ((a) < (b) ? (a) : (b))
  42 #undef  max
  43 #define max(a,b) ((a) > (b) ? (a) : (b))
  44
  45 /* Used by the ifield rtx function.  */
  46 #define FLD(f) (fields->f)
  47
  48 static const char * insert_normal
  49   (CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int,
  50    unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR);
  51 static const char * insert_insn_normal
  52   (CGEN_CPU_DESC, const CGEN_INSN *,
  53    CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
  54 static int extract_normal
  55   (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
  56    unsigned int, unsigned int, unsigned int, unsigned int,
  57    unsigned int, unsigned int, bfd_vma, long *);
  58 static int extract_insn_normal
  59   (CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
  60    CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
  61 #if CGEN_INT_INSN_P
  62 static void put_insn_int_value
  63   (CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT);
  64 #endif
  65 #if ! CGEN_INT_INSN_P
  66 static CGEN_INLINE void insert_1
  67   (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *);
  68 static CGEN_INLINE int fill_cache
  69   (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *,  int, int, bfd_vma);
  70 static CGEN_INLINE long extract_1
  71   (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma);
  72 #endif
  73 \f
  74 /* Operand insertion.  */
  75
  76 #if ! CGEN_INT_INSN_P
  77
  78 /* Subroutine of insert_normal.  */
  79
  80 static CGEN_INLINE void
  81 insert_1 (CGEN_CPU_DESC cd,
  82           unsigned long value,
  83           int start,
  84           int length,
  85           int word_length,
  86           unsigned char *bufp)
  87 {
  88   unsigned long x, mask;
  89   int shift;
  90
  91   x = cgen_get_insn_value (cd, bufp, word_length, cd->endian);
  92
  93   /* Written this way to avoid undefined behaviour.  */
  94   mask = (1UL << (length - 1) << 1) - 1;
  95   if (CGEN_INSN_LSB0_P)
  96     shift = (start + 1) - length;
  97   else
  98     shift = (word_length - (start + length));
  99   x = (x & ~(mask << shift)) | ((value & mask) << shift);
 100
 101   cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x, cd->endian);
 102 }
 103
 104 #endif /* ! CGEN_INT_INSN_P */
 105
 106 /* Default insertion routine.
 107
 108    ATTRS is a mask of the boolean attributes.
 109    WORD_OFFSET is the offset in bits from the start of the insn of the value.
 110    WORD_LENGTH is the length of the word in bits in which the value resides.
 111    START is the starting bit number in the word, architecture origin.
 112    LENGTH is the length of VALUE in bits.
 113    TOTAL_LENGTH is the total length of the insn in bits.
 114
 115    The result is an error message or NULL if success.  */
 116
 117 /* ??? This duplicates functionality with bfd's howto table and
 118    bfd_install_relocation.  */
 119 /* ??? This doesn't handle bfd_vma's.  Create another function when
 120    necessary.  */
 121
 122 static const char *
 123 insert_normal (CGEN_CPU_DESC cd,
 124                long value,
 125                unsigned int attrs,
 126                unsigned int word_offset,
 127                unsigned int start,
 128                unsigned int length,
 129                unsigned int word_length,
 130                unsigned int total_length,
 131                CGEN_INSN_BYTES_PTR buffer)
 132 {
 133   static char errbuf[100];
 134   unsigned long mask;
 135
 136   /* If LENGTH is zero, this operand doesn't contribute to the value.  */
 137   if (length == 0)
 138     return NULL;
 139
 140   /* Written this way to avoid undefined behaviour.  */
 141   mask = (1UL << (length - 1) << 1) - 1;
 142
 143   if (word_length > 8 * sizeof (CGEN_INSN_INT))
 144     abort ();
 145
 146   /* For architectures with insns smaller than the base-insn-bitsize,
 147      word_length may be too big.  */
 148   if (cd->min_insn_bitsize < cd->base_insn_bitsize)
 149     {
 150       if (word_offset == 0
 151           && word_length > total_length)
 152         word_length = total_length;
 153     }
 154
 155   /* Ensure VALUE will fit.  */
 156   if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
 157     {
 158       long minval = - (1UL << (length - 1));
 159       unsigned long maxval = mask;
 160
 161       if ((value > 0 && (unsigned long) value > maxval)
 162           || value < minval)
 163         {
 164           /* xgettext:c-format */
 165           sprintf (errbuf,
 166                    _("operand out of range (%ld not between %ld and %lu)"),
 167                    value, minval, maxval);
 168           return errbuf;
 169         }
 170     }
 171   else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
 172     {
 173       unsigned long maxval = mask;
 174       unsigned long val = (unsigned long) value;
 175
 176       /* For hosts with a word size > 32 check to see if value has been sign
 177          extended beyond 32 bits.  If so then ignore these higher sign bits
 178          as the user is attempting to store a 32-bit signed value into an
 179          unsigned 32-bit field which is allowed.  */
 180       if (sizeof (unsigned long) > 4 && ((value >> 32) == -1))
 181         val &= 0xFFFFFFFF;
 182
 183       if (val > maxval)
 184         {
 185           /* xgettext:c-format */
 186           sprintf (errbuf,
 187                    _("operand out of range (0x%lx not between 0 and 0x%lx)"),
 188                    val, maxval);
 189           return errbuf;
 190         }
 191     }
 192   else
 193     {
 194       if (! cgen_signed_overflow_ok_p (cd))
 195         {
 196           long minval = - (1UL << (length - 1));
 197           long maxval =   (1UL << (length - 1)) - 1;
 198
 199           if (value < minval || value > maxval)
 200             {
 201               sprintf
 202                 /* xgettext:c-format */
 203                 (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
 204                  value, minval, maxval);
 205               return errbuf;
 206             }
 207         }
 208     }
 209
 210 #if CGEN_INT_INSN_P
 211
 212   {
 213     int shift_within_word, shift_to_word, shift;
 214
 215     /* How to shift the value to BIT0 of the word.  */
 216     shift_to_word = total_length - (word_offset + word_length);
 217
 218     /* How to shift the value to the field within the word.  */
 219     if (CGEN_INSN_LSB0_P)
 220       shift_within_word = start + 1 - length;
 221     else
 222       shift_within_word = word_length - start - length;
 223
 224     /* The total SHIFT, then mask in the value.  */
 225     shift = shift_to_word + shift_within_word;
 226     *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
 227   }
 228
 229 #else /* ! CGEN_INT_INSN_P */
 230
 231   {
 232     unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
 233
 234     insert_1 (cd, value, start, length, word_length, bufp);
 235   }
 236
 237 #endif /* ! CGEN_INT_INSN_P */
 238
 239   return NULL;
 240 }
 241
 242 /* Default insn builder (insert handler).
 243    The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
 244    that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
 245    recorded in host byte order, otherwise BUFFER is an array of bytes
 246    and the value is recorded in target byte order).
 247    The result is an error message or NULL if success.  */
 248
 249 static const char *
 250 insert_insn_normal (CGEN_CPU_DESC cd,
 251                     const CGEN_INSN * insn,
 252                     CGEN_FIELDS * fields,
 253                     CGEN_INSN_BYTES_PTR buffer,
 254                     bfd_vma pc)
 255 {
 256   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
 257   unsigned long value;
 258   const CGEN_SYNTAX_CHAR_TYPE * syn;
 259
 260   CGEN_INIT_INSERT (cd);
 261   value = CGEN_INSN_BASE_VALUE (insn);
 262
 263   /* If we're recording insns as numbers (rather than a string of bytes),
 264      target byte order handling is deferred until later.  */
 265
 266 #if CGEN_INT_INSN_P
 267
 268   put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
 269                       CGEN_FIELDS_BITSIZE (fields), value);
 270
 271 #else
 272
 273   cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
 274                                         (unsigned) CGEN_FIELDS_BITSIZE (fields)),
 275                        value, cd->insn_endian);
 276
 277 #endif /* ! CGEN_INT_INSN_P */
 278
 279   /* ??? It would be better to scan the format's fields.
 280      Still need to be able to insert a value based on the operand though;
 281      e.g. storing a branch displacement that got resolved later.
 282      Needs more thought first.  */
 283
 284   for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
 285     {
 286       const char *errmsg;
 287
 288       if (CGEN_SYNTAX_CHAR_P (* syn))
 289         continue;
 290
 291       errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
 292                                        fields, buffer, pc);
 293       if (errmsg)
 294         return errmsg;
 295     }
 296
 297   return NULL;
 298 }
 299
 300 #if CGEN_INT_INSN_P
 301 /* Cover function to store an insn value into an integral insn.  Must go here
 302    because it needs <prefix>-desc.h for CGEN_INT_INSN_P.  */
 303
 304 static void
 305 put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 306                     CGEN_INSN_BYTES_PTR buf,
 307                     int length,
 308                     int insn_length,
 309                     CGEN_INSN_INT value)
 310 {
 311   /* For architectures with insns smaller than the base-insn-bitsize,
 312      length may be too big.  */
 313   if (length > insn_length)
 314     *buf = value;
 315   else
 316     {
 317       int shift = insn_length - length;
 318       /* Written this way to avoid undefined behaviour.  */
 319       CGEN_INSN_INT mask = length == 0 ? 0 : (1UL << (length - 1) << 1) - 1;
 320
 321       *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
 322     }
 323 }
 324 #endif
 325 \f
 326 /* Operand extraction.  */
 327
 328 #if ! CGEN_INT_INSN_P
 329
 330 /* Subroutine of extract_normal.
 331    Ensure sufficient bytes are cached in EX_INFO.
 332    OFFSET is the offset in bytes from the start of the insn of the value.
 333    BYTES is the length of the needed value.
 334    Returns 1 for success, 0 for failure.  */
 335
 336 static CGEN_INLINE int
 337 fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 338             CGEN_EXTRACT_INFO *ex_info,
 339             int offset,
 340             int bytes,
 341             bfd_vma pc)
 342 {
 343   /* It's doubtful that the middle part has already been fetched so
 344      we don't optimize that case.  kiss.  */
 345   unsigned int mask;
 346   disassemble_info *info = (disassemble_info *) ex_info->dis_info;
 347
 348   /* First do a quick check.  */
 349   mask = (1 << bytes) - 1;
 350   if (((ex_info->valid >> offset) & mask) == mask)
 351     return 1;
 352
 353   /* Search for the first byte we need to read.  */
 354   for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
 355     if (! (mask & ex_info->valid))
 356       break;
 357
 358   if (bytes)
 359     {
 360       int status;
 361
 362       pc += offset;
 363       status = (*info->read_memory_func)
 364         (pc, ex_info->insn_bytes + offset, bytes, info);
 365
 366       if (status != 0)
 367         {
 368           (*info->memory_error_func) (status, pc, info);
 369           return 0;
 370         }
 371
 372       ex_info->valid |= ((1 << bytes) - 1) << offset;
 373     }
 374
 375   return 1;
 376 }
 377
 378 /* Subroutine of extract_normal.  */
 379
 380 static CGEN_INLINE long
 381 extract_1 (CGEN_CPU_DESC cd,
 382            CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
 383            int start,
 384            int length,
 385            int word_length,
 386            unsigned char *bufp,
 387            bfd_vma pc ATTRIBUTE_UNUSED)
 388 {
 389   unsigned long x;
 390   int shift;
 391
 392   x = cgen_get_insn_value (cd, bufp, word_length, cd->endian);
 393
 394   if (CGEN_INSN_LSB0_P)
 395     shift = (start + 1) - length;
 396   else
 397     shift = (word_length - (start + length));
 398   return x >> shift;
 399 }
 400
 401 #endif /* ! CGEN_INT_INSN_P */
 402
 403 /* Default extraction routine.
 404
 405    INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
 406    or sometimes less for cases like the m32r where the base insn size is 32
 407    but some insns are 16 bits.
 408    ATTRS is a mask of the boolean attributes.  We only need `SIGNED',
 409    but for generality we take a bitmask of all of them.
 410    WORD_OFFSET is the offset in bits from the start of the insn of the value.
 411    WORD_LENGTH is the length of the word in bits in which the value resides.
 412    START is the starting bit number in the word, architecture origin.
 413    LENGTH is the length of VALUE in bits.
 414    TOTAL_LENGTH is the total length of the insn in bits.
 415
 416    Returns 1 for success, 0 for failure.  */
 417
 418 /* ??? The return code isn't properly used.  wip.  */
 419
 420 /* ??? This doesn't handle bfd_vma's.  Create another function when
 421    necessary.  */
 422
 423 static int
 424 extract_normal (CGEN_CPU_DESC cd,
 425 #if ! CGEN_INT_INSN_P
 426                 CGEN_EXTRACT_INFO *ex_info,
 427 #else
 428                 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
 429 #endif
 430                 CGEN_INSN_INT insn_value,
 431                 unsigned int attrs,
 432                 unsigned int word_offset,
 433                 unsigned int start,
 434                 unsigned int length,
 435                 unsigned int word_length,
 436                 unsigned int total_length,
 437 #if ! CGEN_INT_INSN_P
 438                 bfd_vma pc,
 439 #else
 440                 bfd_vma pc ATTRIBUTE_UNUSED,
 441 #endif
 442                 long *valuep)
 443 {
 444   long value, mask;
 445
 446   /* If LENGTH is zero, this operand doesn't contribute to the value
 447      so give it a standard value of zero.  */
 448   if (length == 0)
 449     {
 450       *valuep = 0;
 451       return 1;
 452     }
 453
 454   if (word_length > 8 * sizeof (CGEN_INSN_INT))
 455     abort ();
 456
 457   /* For architectures with insns smaller than the insn-base-bitsize,
 458      word_length may be too big.  */
 459   if (cd->min_insn_bitsize < cd->base_insn_bitsize)
 460     {
 461       if (word_offset + word_length > total_length)
 462         word_length = total_length - word_offset;
 463     }
 464
 465   /* Does the value reside in INSN_VALUE, and at the right alignment?  */
 466
 467   if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
 468     {
 469       if (CGEN_INSN_LSB0_P)
 470         value = insn_value >> ((word_offset + start + 1) - length);
 471       else
 472         value = insn_value >> (total_length - ( word_offset + start + length));
 473     }
 474
 475 #if ! CGEN_INT_INSN_P
 476
 477   else
 478     {
 479       unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
 480
 481       if (word_length > 8 * sizeof (CGEN_INSN_INT))
 482         abort ();
 483
 484       if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
 485         {
 486           *valuep = 0;
 487           return 0;
 488         }
 489
 490       value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
 491     }
 492
 493 #endif /* ! CGEN_INT_INSN_P */
 494
 495   /* Written this way to avoid undefined behaviour.  */
 496   mask = (1UL << (length - 1) << 1) - 1;
 497
 498   value &= mask;
 499   /* sign extend? */
 500   if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
 501       && (value & (1UL << (length - 1))))
 502     value |= ~mask;
 503
 504   *valuep = value;
 505
 506   return 1;
 507 }
 508
 509 /* Default insn extractor.
 510
 511    INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
 512    The extracted fields are stored in FIELDS.
 513    EX_INFO is used to handle reading variable length insns.
 514    Return the length of the insn in bits, or 0 if no match,
 515    or -1 if an error occurs fetching data (memory_error_func will have
 516    been called).  */
 517
 518 static int
 519 extract_insn_normal (CGEN_CPU_DESC cd,
 520                      const CGEN_INSN *insn,
 521                      CGEN_EXTRACT_INFO *ex_info,
 522                      CGEN_INSN_INT insn_value,
 523                      CGEN_FIELDS *fields,
 524                      bfd_vma pc)
 525 {
 526   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
 527   const CGEN_SYNTAX_CHAR_TYPE *syn;
 528
 529   CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
 530
 531   CGEN_INIT_EXTRACT (cd);
 532
 533   for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
 534     {
 535       int length;
 536
 537       if (CGEN_SYNTAX_CHAR_P (*syn))
 538         continue;
 539
 540       length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
 541                                         ex_info, insn_value, fields, pc);
 542       if (length <= 0)
 543         return length;
 544     }
 545
 546   /* We recognized and successfully extracted this insn.  */
 547   return CGEN_INSN_BITSIZE (insn);
 548 }
 549 \f
 550 /* Machine generated code added here.  */
 551
 552 const char * mt_cgen_insert_operand
 553   (CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
 554
 555 /* Main entry point for operand insertion.
 556
 557    This function is basically just a big switch statement.  Earlier versions
 558    used tables to look up the function to use, but
 559    - if the table contains both assembler and disassembler functions then
 560      the disassembler contains much of the assembler and vice-versa,
 561    - there's a lot of inlining possibilities as things grow,
 562    - using a switch statement avoids the function call overhead.
 563
 564    This function could be moved into `parse_insn_normal', but keeping it
 565    separate makes clear the interface between `parse_insn_normal' and each of
 566    the handlers.  It's also needed by GAS to insert operands that couldn't be
 567    resolved during parsing.  */
 568
 569 const char *
 570 mt_cgen_insert_operand (CGEN_CPU_DESC cd,
 571                              int opindex,
 572                              CGEN_FIELDS * fields,
 573                              CGEN_INSN_BYTES_PTR buffer,
 574                              bfd_vma pc ATTRIBUTE_UNUSED)
 575 {
 576   const char * errmsg = NULL;
 577   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 578
 579   switch (opindex)
 580     {
 581     case MT_OPERAND_A23 :
 582       errmsg = insert_normal (cd, fields->f_a23, 0, 0, 23, 1, 32, total_length, buffer);
 583       break;
 584     case MT_OPERAND_BALL :
 585       errmsg = insert_normal (cd, fields->f_ball, 0, 0, 19, 1, 32, total_length, buffer);
 586       break;
 587     case MT_OPERAND_BALL2 :
 588       errmsg = insert_normal (cd, fields->f_ball2, 0, 0, 15, 1, 32, total_length, buffer);
 589       break;
 590     case MT_OPERAND_BANKADDR :
 591       errmsg = insert_normal (cd, fields->f_bankaddr, 0, 0, 25, 13, 32, total_length, buffer);
 592       break;
 593     case MT_OPERAND_BRC :
 594       errmsg = insert_normal (cd, fields->f_brc, 0, 0, 18, 3, 32, total_length, buffer);
 595       break;
 596     case MT_OPERAND_BRC2 :
 597       errmsg = insert_normal (cd, fields->f_brc2, 0, 0, 14, 3, 32, total_length, buffer);
 598       break;
 599     case MT_OPERAND_CB1INCR :
 600       errmsg = insert_normal (cd, fields->f_cb1incr, 0|(1<<CGEN_IFLD_SIGNED), 0, 19, 6, 32, total_length, buffer);
 601       break;
 602     case MT_OPERAND_CB1SEL :
 603       errmsg = insert_normal (cd, fields->f_cb1sel, 0, 0, 25, 3, 32, total_length, buffer);
 604       break;
 605     case MT_OPERAND_CB2INCR :
 606       errmsg = insert_normal (cd, fields->f_cb2incr, 0|(1<<CGEN_IFLD_SIGNED), 0, 13, 6, 32, total_length, buffer);
 607       break;
 608     case MT_OPERAND_CB2SEL :
 609       errmsg = insert_normal (cd, fields->f_cb2sel, 0, 0, 22, 3, 32, total_length, buffer);
 610       break;
 611     case MT_OPERAND_CBRB :
 612       errmsg = insert_normal (cd, fields->f_cbrb, 0, 0, 10, 1, 32, total_length, buffer);
 613       break;
 614     case MT_OPERAND_CBS :
 615       errmsg = insert_normal (cd, fields->f_cbs, 0, 0, 19, 2, 32, total_length, buffer);
 616       break;
 617     case MT_OPERAND_CBX :
 618       errmsg = insert_normal (cd, fields->f_cbx, 0, 0, 14, 3, 32, total_length, buffer);
 619       break;
 620     case MT_OPERAND_CCB :
 621       errmsg = insert_normal (cd, fields->f_ccb, 0, 0, 11, 1, 32, total_length, buffer);
 622       break;
 623     case MT_OPERAND_CDB :
 624       errmsg = insert_normal (cd, fields->f_cdb, 0, 0, 10, 1, 32, total_length, buffer);
 625       break;
 626     case MT_OPERAND_CELL :
 627       errmsg = insert_normal (cd, fields->f_cell, 0, 0, 9, 3, 32, total_length, buffer);
 628       break;
 629     case MT_OPERAND_COLNUM :
 630       errmsg = insert_normal (cd, fields->f_colnum, 0, 0, 18, 3, 32, total_length, buffer);
 631       break;
 632     case MT_OPERAND_CONTNUM :
 633       errmsg = insert_normal (cd, fields->f_contnum, 0, 0, 8, 9, 32, total_length, buffer);
 634       break;
 635     case MT_OPERAND_CR :
 636       errmsg = insert_normal (cd, fields->f_cr, 0, 0, 22, 3, 32, total_length, buffer);
 637       break;
 638     case MT_OPERAND_CTXDISP :
 639       errmsg = insert_normal (cd, fields->f_ctxdisp, 0, 0, 5, 6, 32, total_length, buffer);
 640       break;
 641     case MT_OPERAND_DUP :
 642       errmsg = insert_normal (cd, fields->f_dup, 0, 0, 6, 1, 32, total_length, buffer);
 643       break;
 644     case MT_OPERAND_FBDISP :
 645       errmsg = insert_normal (cd, fields->f_fbdisp, 0, 0, 15, 6, 32, total_length, buffer);
 646       break;
 647     case MT_OPERAND_FBINCR :
 648       errmsg = insert_normal (cd, fields->f_fbincr, 0, 0, 23, 4, 32, total_length, buffer);
 649       break;
 650     case MT_OPERAND_FRDR :
 651       errmsg = insert_normal (cd, fields->f_dr, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 19, 4, 32, total_length, buffer);
 652       break;
 653     case MT_OPERAND_FRDRRR :
 654       errmsg = insert_normal (cd, fields->f_drrr, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 15, 4, 32, total_length, buffer);
 655       break;
 656     case MT_OPERAND_FRSR1 :
 657       errmsg = insert_normal (cd, fields->f_sr1, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 23, 4, 32, total_length, buffer);
 658       break;
 659     case MT_OPERAND_FRSR2 :
 660       errmsg = insert_normal (cd, fields->f_sr2, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 19, 4, 32, total_length, buffer);
 661       break;
 662     case MT_OPERAND_ID :
 663       errmsg = insert_normal (cd, fields->f_id, 0, 0, 14, 1, 32, total_length, buffer);
 664       break;
 665     case MT_OPERAND_IMM16 :
 666       {
 667         long value = fields->f_imm16s;
 668         value = ((value) + (0));
 669         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
 670       }
 671       break;
 672     case MT_OPERAND_IMM16L :
 673       errmsg = insert_normal (cd, fields->f_imm16l, 0, 0, 23, 16, 32, total_length, buffer);
 674       break;
 675     case MT_OPERAND_IMM16O :
 676       {
 677         long value = fields->f_imm16s;
 678         value = ((value) + (0));
 679         errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
 680       }
 681       break;
 682     case MT_OPERAND_IMM16Z :
 683       errmsg = insert_normal (cd, fields->f_imm16u, 0, 0, 15, 16, 32, total_length, buffer);
 684       break;
 685     case MT_OPERAND_INCAMT :
 686       errmsg = insert_normal (cd, fields->f_incamt, 0, 0, 19, 8, 32, total_length, buffer);
 687       break;
 688     case MT_OPERAND_INCR :
 689       errmsg = insert_normal (cd, fields->f_incr, 0, 0, 17, 6, 32, total_length, buffer);
 690       break;
 691     case MT_OPERAND_LENGTH :
 692       errmsg = insert_normal (cd, fields->f_length, 0, 0, 15, 3, 32, total_length, buffer);
 693       break;
 694     case MT_OPERAND_LOOPSIZE :
 695       {
 696         long value = fields->f_loopo;
 697         value = ((USI) (value) >> (2));
 698         errmsg = insert_normal (cd, value, 0, 0, 7, 8, 32, total_length, buffer);
 699       }
 700       break;
 701     case MT_OPERAND_MASK :
 702       errmsg = insert_normal (cd, fields->f_mask, 0, 0, 25, 16, 32, total_length, buffer);
 703       break;
 704     case MT_OPERAND_MASK1 :
 705       errmsg = insert_normal (cd, fields->f_mask1, 0, 0, 22, 3, 32, total_length, buffer);
 706       break;
 707     case MT_OPERAND_MODE :
 708       errmsg = insert_normal (cd, fields->f_mode, 0, 0, 25, 2, 32, total_length, buffer);
 709       break;
 710     case MT_OPERAND_PERM :
 711       errmsg = insert_normal (cd, fields->f_perm, 0, 0, 25, 2, 32, total_length, buffer);
 712       break;
 713     case MT_OPERAND_RBBC :
 714       errmsg = insert_normal (cd, fields->f_rbbc, 0, 0, 25, 2, 32, total_length, buffer);
 715       break;
 716     case MT_OPERAND_RC :
 717       errmsg = insert_normal (cd, fields->f_rc, 0, 0, 15, 1, 32, total_length, buffer);
 718       break;
 719     case MT_OPERAND_RC1 :
 720       errmsg = insert_normal (cd, fields->f_rc1, 0, 0, 11, 1, 32, total_length, buffer);
 721       break;
 722     case MT_OPERAND_RC2 :
 723       errmsg = insert_normal (cd, fields->f_rc2, 0, 0, 6, 1, 32, total_length, buffer);
 724       break;
 725     case MT_OPERAND_RC3 :
 726       errmsg = insert_normal (cd, fields->f_rc3, 0, 0, 7, 1, 32, total_length, buffer);
 727       break;
 728     case MT_OPERAND_RCNUM :
 729       errmsg = insert_normal (cd, fields->f_rcnum, 0, 0, 14, 3, 32, total_length, buffer);
 730       break;
 731     case MT_OPERAND_RDA :
 732       errmsg = insert_normal (cd, fields->f_rda, 0, 0, 25, 1, 32, total_length, buffer);
 733       break;
 734     case MT_OPERAND_ROWNUM :
 735       errmsg = insert_normal (cd, fields->f_rownum, 0, 0, 14, 3, 32, total_length, buffer);
 736       break;
 737     case MT_OPERAND_ROWNUM1 :
 738       errmsg = insert_normal (cd, fields->f_rownum1, 0, 0, 12, 3, 32, total_length, buffer);
 739       break;
 740     case MT_OPERAND_ROWNUM2 :
 741       errmsg = insert_normal (cd, fields->f_rownum2, 0, 0, 9, 3, 32, total_length, buffer);
 742       break;
 743     case MT_OPERAND_SIZE :
 744       errmsg = insert_normal (cd, fields->f_size, 0, 0, 13, 14, 32, total_length, buffer);
 745       break;
 746     case MT_OPERAND_TYPE :
 747       errmsg = insert_normal (cd, fields->f_type, 0, 0, 21, 2, 32, total_length, buffer);
 748       break;
 749     case MT_OPERAND_WR :
 750       errmsg = insert_normal (cd, fields->f_wr, 0, 0, 24, 1, 32, total_length, buffer);
 751       break;
 752     case MT_OPERAND_XMODE :
 753       errmsg = insert_normal (cd, fields->f_xmode, 0, 0, 23, 1, 32, total_length, buffer);
 754       break;
 755
 756     default :
 757       /* xgettext:c-format */
 758       opcodes_error_handler
 759         (_("internal error: unrecognized field %d while building insn"),
 760          opindex);
 761       abort ();
 762   }
 763
 764   return errmsg;
 765 }
 766
 767 int mt_cgen_extract_operand
 768   (CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
 769
 770 /* Main entry point for operand extraction.
 771    The result is <= 0 for error, >0 for success.
 772    ??? Actual values aren't well defined right now.
 773
 774    This function is basically just a big switch statement.  Earlier versions
 775    used tables to look up the function to use, but
 776    - if the table contains both assembler and disassembler functions then
 777      the disassembler contains much of the assembler and vice-versa,
 778    - there's a lot of inlining possibilities as things grow,
 779    - using a switch statement avoids the function call overhead.
 780
 781    This function could be moved into `print_insn_normal', but keeping it
 782    separate makes clear the interface between `print_insn_normal' and each of
 783    the handlers.  */
 784
 785 int
 786 mt_cgen_extract_operand (CGEN_CPU_DESC cd,
 787                              int opindex,
 788                              CGEN_EXTRACT_INFO *ex_info,
 789                              CGEN_INSN_INT insn_value,
 790                              CGEN_FIELDS * fields,
 791                              bfd_vma pc)
 792 {
 793   /* Assume success (for those operands that are nops).  */
 794   int length = 1;
 795   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 796
 797   switch (opindex)
 798     {
 799     case MT_OPERAND_A23 :
 800       length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 1, 32, total_length, pc, & fields->f_a23);
 801       break;
 802     case MT_OPERAND_BALL :
 803       length = extract_normal (cd, ex_info, insn_value, 0, 0, 19, 1, 32, total_length, pc, & fields->f_ball);
 804       break;
 805     case MT_OPERAND_BALL2 :
 806       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_ball2);
 807       break;
 808     case MT_OPERAND_BANKADDR :
 809       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 13, 32, total_length, pc, & fields->f_bankaddr);
 810       break;
 811     case MT_OPERAND_BRC :
 812       length = extract_normal (cd, ex_info, insn_value, 0, 0, 18, 3, 32, total_length, pc, & fields->f_brc);
 813       break;
 814     case MT_OPERAND_BRC2 :
 815       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_brc2);
 816       break;
 817     case MT_OPERAND_CB1INCR :
 818       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 19, 6, 32, total_length, pc, & fields->f_cb1incr);
 819       break;
 820     case MT_OPERAND_CB1SEL :
 821       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 3, 32, total_length, pc, & fields->f_cb1sel);
 822       break;
 823     case MT_OPERAND_CB2INCR :
 824       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 13, 6, 32, total_length, pc, & fields->f_cb2incr);
 825       break;
 826     case MT_OPERAND_CB2SEL :
 827       length = extract_normal (cd, ex_info, insn_value, 0, 0, 22, 3, 32, total_length, pc, & fields->f_cb2sel);
 828       break;
 829     case MT_OPERAND_CBRB :
 830       length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 1, 32, total_length, pc, & fields->f_cbrb);
 831       break;
 832     case MT_OPERAND_CBS :
 833       length = extract_normal (cd, ex_info, insn_value, 0, 0, 19, 2, 32, total_length, pc, & fields->f_cbs);
 834       break;
 835     case MT_OPERAND_CBX :
 836       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_cbx);
 837       break;
 838     case MT_OPERAND_CCB :
 839       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 1, 32, total_length, pc, & fields->f_ccb);
 840       break;
 841     case MT_OPERAND_CDB :
 842       length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 1, 32, total_length, pc, & fields->f_cdb);
 843       break;
 844     case MT_OPERAND_CELL :
 845       length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 3, 32, total_length, pc, & fields->f_cell);
 846       break;
 847     case MT_OPERAND_COLNUM :
 848       length = extract_normal (cd, ex_info, insn_value, 0, 0, 18, 3, 32, total_length, pc, & fields->f_colnum);
 849       break;
 850     case MT_OPERAND_CONTNUM :
 851       length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 9, 32, total_length, pc, & fields->f_contnum);
 852       break;
 853     case MT_OPERAND_CR :
 854       length = extract_normal (cd, ex_info, insn_value, 0, 0, 22, 3, 32, total_length, pc, & fields->f_cr);
 855       break;
 856     case MT_OPERAND_CTXDISP :
 857       length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_ctxdisp);
 858       break;
 859     case MT_OPERAND_DUP :
 860       length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 1, 32, total_length, pc, & fields->f_dup);
 861       break;
 862     case MT_OPERAND_FBDISP :
 863       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 6, 32, total_length, pc, & fields->f_fbdisp);
 864       break;
 865     case MT_OPERAND_FBINCR :
 866       length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 4, 32, total_length, pc, & fields->f_fbincr);
 867       break;
 868     case MT_OPERAND_FRDR :
 869       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 19, 4, 32, total_length, pc, & fields->f_dr);
 870       break;
 871     case MT_OPERAND_FRDRRR :
 872       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 15, 4, 32, total_length, pc, & fields->f_drrr);
 873       break;
 874     case MT_OPERAND_FRSR1 :
 875       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 23, 4, 32, total_length, pc, & fields->f_sr1);
 876       break;
 877     case MT_OPERAND_FRSR2 :
 878       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 19, 4, 32, total_length, pc, & fields->f_sr2);
 879       break;
 880     case MT_OPERAND_ID :
 881       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 1, 32, total_length, pc, & fields->f_id);
 882       break;
 883     case MT_OPERAND_IMM16 :
 884       {
 885         long value;
 886         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & value);
 887         value = ((value) + (0));
 888         fields->f_imm16s = value;
 889       }
 890       break;
 891     case MT_OPERAND_IMM16L :
 892       length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 16, 32, total_length, pc, & fields->f_imm16l);
 893       break;
 894     case MT_OPERAND_IMM16O :
 895       {
 896         long value;
 897         length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & value);
 898         value = ((value) + (0));
 899         fields->f_imm16s = value;
 900       }
 901       break;
 902     case MT_OPERAND_IMM16Z :
 903       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_imm16u);
 904       break;
 905     case MT_OPERAND_INCAMT :
 906       length = extract_normal (cd, ex_info, insn_value, 0, 0, 19, 8, 32, total_length, pc, & fields->f_incamt);
 907       break;
 908     case MT_OPERAND_INCR :
 909       length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_incr);
 910       break;
 911     case MT_OPERAND_LENGTH :
 912       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 3, 32, total_length, pc, & fields->f_length);
 913       break;
 914     case MT_OPERAND_LOOPSIZE :
 915       {
 916         long value;
 917         length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 32, total_length, pc, & value);
 918         value = ((((value) << (2))) + (8));
 919         fields->f_loopo = value;
 920       }
 921       break;
 922     case MT_OPERAND_MASK :
 923       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 16, 32, total_length, pc, & fields->f_mask);
 924       break;
 925     case MT_OPERAND_MASK1 :
 926       length = extract_normal (cd, ex_info, insn_value, 0, 0, 22, 3, 32, total_length, pc, & fields->f_mask1);
 927       break;
 928     case MT_OPERAND_MODE :
 929       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 2, 32, total_length, pc, & fields->f_mode);
 930       break;
 931     case MT_OPERAND_PERM :
 932       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 2, 32, total_length, pc, & fields->f_perm);
 933       break;
 934     case MT_OPERAND_RBBC :
 935       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 2, 32, total_length, pc, & fields->f_rbbc);
 936       break;
 937     case MT_OPERAND_RC :
 938       length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_rc);
 939       break;
 940     case MT_OPERAND_RC1 :
 941       length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 1, 32, total_length, pc, & fields->f_rc1);
 942       break;
 943     case MT_OPERAND_RC2 :
 944       length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 1, 32, total_length, pc, & fields->f_rc2);
 945       break;
 946     case MT_OPERAND_RC3 :
 947       length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 1, 32, total_length, pc, & fields->f_rc3);
 948       break;
 949     case MT_OPERAND_RCNUM :
 950       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_rcnum);
 951       break;
 952     case MT_OPERAND_RDA :
 953       length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_rda);
 954       break;
 955     case MT_OPERAND_ROWNUM :
 956       length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_rownum);
 957       break;
 958     case MT_OPERAND_ROWNUM1 :
 959       length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 3, 32, total_length, pc, & fields->f_rownum1);
 960       break;
 961     case MT_OPERAND_ROWNUM2 :
 962       length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 3, 32, total_length, pc, & fields->f_rownum2);
 963       break;
 964     case MT_OPERAND_SIZE :
 965       length = extract_normal (cd, ex_info, insn_value, 0, 0, 13, 14, 32, total_length, pc, & fields->f_size);
 966       break;
 967     case MT_OPERAND_TYPE :
 968       length = extract_normal (cd, ex_info, insn_value, 0, 0, 21, 2, 32, total_length, pc, & fields->f_type);
 969       break;
 970     case MT_OPERAND_WR :
 971       length = extract_normal (cd, ex_info, insn_value, 0, 0, 24, 1, 32, total_length, pc, & fields->f_wr);
 972       break;
 973     case MT_OPERAND_XMODE :
 974       length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 1, 32, total_length, pc, & fields->f_xmode);
 975       break;
 976
 977     default :
 978       /* xgettext:c-format */
 979       opcodes_error_handler
 980         (_("internal error: unrecognized field %d while decoding insn"),
 981          opindex);
 982       abort ();
 983     }
 984
 985   return length;
 986 }
 987
 988 cgen_insert_fn * const mt_cgen_insert_handlers[] =
 989 {
 990   insert_insn_normal,
 991 };
 992
 993 cgen_extract_fn * const mt_cgen_extract_handlers[] =
 994 {
 995   extract_insn_normal,
 996 };
 997
 998 int mt_cgen_get_int_operand     (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
 999 bfd_vma mt_cgen_get_vma_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
1000
1001 /* Getting values from cgen_fields is handled by a collection of functions.
1002    They are distinguished by the type of the VALUE argument they return.
1003    TODO: floating point, inlining support, remove cases where result type
1004    not appropriate.  */
1005
1006 int
1007 mt_cgen_get_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1008                              int opindex,
1009                              const CGEN_FIELDS * fields)
1010 {
1011   int value;
1012
1013   switch (opindex)
1014     {
1015     case MT_OPERAND_A23 :
1016       value = fields->f_a23;
1017       break;
1018     case MT_OPERAND_BALL :
1019       value = fields->f_ball;
1020       break;
1021     case MT_OPERAND_BALL2 :
1022       value = fields->f_ball2;
1023       break;
1024     case MT_OPERAND_BANKADDR :
1025       value = fields->f_bankaddr;
1026       break;
1027     case MT_OPERAND_BRC :
1028       value = fields->f_brc;
1029       break;
1030     case MT_OPERAND_BRC2 :
1031       value = fields->f_brc2;
1032       break;
1033     case MT_OPERAND_CB1INCR :
1034       value = fields->f_cb1incr;
1035       break;
1036     case MT_OPERAND_CB1SEL :
1037       value = fields->f_cb1sel;
1038       break;
1039     case MT_OPERAND_CB2INCR :
1040       value = fields->f_cb2incr;
1041       break;
1042     case MT_OPERAND_CB2SEL :
1043       value = fields->f_cb2sel;
1044       break;
1045     case MT_OPERAND_CBRB :
1046       value = fields->f_cbrb;
1047       break;
1048     case MT_OPERAND_CBS :
1049       value = fields->f_cbs;
1050       break;
1051     case MT_OPERAND_CBX :
1052       value = fields->f_cbx;
1053       break;
1054     case MT_OPERAND_CCB :
1055       value = fields->f_ccb;
1056       break;
1057     case MT_OPERAND_CDB :
1058       value = fields->f_cdb;
1059       break;
1060     case MT_OPERAND_CELL :
1061       value = fields->f_cell;
1062       break;
1063     case MT_OPERAND_COLNUM :
1064       value = fields->f_colnum;
1065       break;
1066     case MT_OPERAND_CONTNUM :
1067       value = fields->f_contnum;
1068       break;
1069     case MT_OPERAND_CR :
1070       value = fields->f_cr;
1071       break;
1072     case MT_OPERAND_CTXDISP :
1073       value = fields->f_ctxdisp;
1074       break;
1075     case MT_OPERAND_DUP :
1076       value = fields->f_dup;
1077       break;
1078     case MT_OPERAND_FBDISP :
1079       value = fields->f_fbdisp;
1080       break;
1081     case MT_OPERAND_FBINCR :
1082       value = fields->f_fbincr;
1083       break;
1084     case MT_OPERAND_FRDR :
1085       value = fields->f_dr;
1086       break;
1087     case MT_OPERAND_FRDRRR :
1088       value = fields->f_drrr;
1089       break;
1090     case MT_OPERAND_FRSR1 :
1091       value = fields->f_sr1;
1092       break;
1093     case MT_OPERAND_FRSR2 :
1094       value = fields->f_sr2;
1095       break;
1096     case MT_OPERAND_ID :
1097       value = fields->f_id;
1098       break;
1099     case MT_OPERAND_IMM16 :
1100       value = fields->f_imm16s;
1101       break;
1102     case MT_OPERAND_IMM16L :
1103       value = fields->f_imm16l;
1104       break;
1105     case MT_OPERAND_IMM16O :
1106       value = fields->f_imm16s;
1107       break;
1108     case MT_OPERAND_IMM16Z :
1109       value = fields->f_imm16u;
1110       break;
1111     case MT_OPERAND_INCAMT :
1112       value = fields->f_incamt;
1113       break;
1114     case MT_OPERAND_INCR :
1115       value = fields->f_incr;
1116       break;
1117     case MT_OPERAND_LENGTH :
1118       value = fields->f_length;
1119       break;
1120     case MT_OPERAND_LOOPSIZE :
1121       value = fields->f_loopo;
1122       break;
1123     case MT_OPERAND_MASK :
1124       value = fields->f_mask;
1125       break;
1126     case MT_OPERAND_MASK1 :
1127       value = fields->f_mask1;
1128       break;
1129     case MT_OPERAND_MODE :
1130       value = fields->f_mode;
1131       break;
1132     case MT_OPERAND_PERM :
1133       value = fields->f_perm;
1134       break;
1135     case MT_OPERAND_RBBC :
1136       value = fields->f_rbbc;
1137       break;
1138     case MT_OPERAND_RC :
1139       value = fields->f_rc;
1140       break;
1141     case MT_OPERAND_RC1 :
1142       value = fields->f_rc1;
1143       break;
1144     case MT_OPERAND_RC2 :
1145       value = fields->f_rc2;
1146       break;
1147     case MT_OPERAND_RC3 :
1148       value = fields->f_rc3;
1149       break;
1150     case MT_OPERAND_RCNUM :
1151       value = fields->f_rcnum;
1152       break;
1153     case MT_OPERAND_RDA :
1154       value = fields->f_rda;
1155       break;
1156     case MT_OPERAND_ROWNUM :
1157       value = fields->f_rownum;
1158       break;
1159     case MT_OPERAND_ROWNUM1 :
1160       value = fields->f_rownum1;
1161       break;
1162     case MT_OPERAND_ROWNUM2 :
1163       value = fields->f_rownum2;
1164       break;
1165     case MT_OPERAND_SIZE :
1166       value = fields->f_size;
1167       break;
1168     case MT_OPERAND_TYPE :
1169       value = fields->f_type;
1170       break;
1171     case MT_OPERAND_WR :
1172       value = fields->f_wr;
1173       break;
1174     case MT_OPERAND_XMODE :
1175       value = fields->f_xmode;
1176       break;
1177
1178     default :
1179       /* xgettext:c-format */
1180       opcodes_error_handler
1181         (_("internal error: unrecognized field %d while getting int operand"),
1182          opindex);
1183       abort ();
1184   }
1185
1186   return value;
1187 }
1188
1189 bfd_vma
1190 mt_cgen_get_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1191                              int opindex,
1192                              const CGEN_FIELDS * fields)
1193 {
1194   bfd_vma value;
1195
1196   switch (opindex)
1197     {
1198     case MT_OPERAND_A23 :
1199       value = fields->f_a23;
1200       break;
1201     case MT_OPERAND_BALL :
1202       value = fields->f_ball;
1203       break;
1204     case MT_OPERAND_BALL2 :
1205       value = fields->f_ball2;
1206       break;
1207     case MT_OPERAND_BANKADDR :
1208       value = fields->f_bankaddr;
1209       break;
1210     case MT_OPERAND_BRC :
1211       value = fields->f_brc;
1212       break;
1213     case MT_OPERAND_BRC2 :
1214       value = fields->f_brc2;
1215       break;
1216     case MT_OPERAND_CB1INCR :
1217       value = fields->f_cb1incr;
1218       break;
1219     case MT_OPERAND_CB1SEL :
1220       value = fields->f_cb1sel;
1221       break;
1222     case MT_OPERAND_CB2INCR :
1223       value = fields->f_cb2incr;
1224       break;
1225     case MT_OPERAND_CB2SEL :
1226       value = fields->f_cb2sel;
1227       break;
1228     case MT_OPERAND_CBRB :
1229       value = fields->f_cbrb;
1230       break;
1231     case MT_OPERAND_CBS :
1232       value = fields->f_cbs;
1233       break;
1234     case MT_OPERAND_CBX :
1235       value = fields->f_cbx;
1236       break;
1237     case MT_OPERAND_CCB :
1238       value = fields->f_ccb;
1239       break;
1240     case MT_OPERAND_CDB :
1241       value = fields->f_cdb;
1242       break;
1243     case MT_OPERAND_CELL :
1244       value = fields->f_cell;
1245       break;
1246     case MT_OPERAND_COLNUM :
1247       value = fields->f_colnum;
1248       break;
1249     case MT_OPERAND_CONTNUM :
1250       value = fields->f_contnum;
1251       break;
1252     case MT_OPERAND_CR :
1253       value = fields->f_cr;
1254       break;
1255     case MT_OPERAND_CTXDISP :
1256       value = fields->f_ctxdisp;
1257       break;
1258     case MT_OPERAND_DUP :
1259       value = fields->f_dup;
1260       break;
1261     case MT_OPERAND_FBDISP :
1262       value = fields->f_fbdisp;
1263       break;
1264     case MT_OPERAND_FBINCR :
1265       value = fields->f_fbincr;
1266       break;
1267     case MT_OPERAND_FRDR :
1268       value = fields->f_dr;
1269       break;
1270     case MT_OPERAND_FRDRRR :
1271       value = fields->f_drrr;
1272       break;
1273     case MT_OPERAND_FRSR1 :
1274       value = fields->f_sr1;
1275       break;
1276     case MT_OPERAND_FRSR2 :
1277       value = fields->f_sr2;
1278       break;
1279     case MT_OPERAND_ID :
1280       value = fields->f_id;
1281       break;
1282     case MT_OPERAND_IMM16 :
1283       value = fields->f_imm16s;
1284       break;
1285     case MT_OPERAND_IMM16L :
1286       value = fields->f_imm16l;
1287       break;
1288     case MT_OPERAND_IMM16O :
1289       value = fields->f_imm16s;
1290       break;
1291     case MT_OPERAND_IMM16Z :
1292       value = fields->f_imm16u;
1293       break;
1294     case MT_OPERAND_INCAMT :
1295       value = fields->f_incamt;
1296       break;
1297     case MT_OPERAND_INCR :
1298       value = fields->f_incr;
1299       break;
1300     case MT_OPERAND_LENGTH :
1301       value = fields->f_length;
1302       break;
1303     case MT_OPERAND_LOOPSIZE :
1304       value = fields->f_loopo;
1305       break;
1306     case MT_OPERAND_MASK :
1307       value = fields->f_mask;
1308       break;
1309     case MT_OPERAND_MASK1 :
1310       value = fields->f_mask1;
1311       break;
1312     case MT_OPERAND_MODE :
1313       value = fields->f_mode;
1314       break;
1315     case MT_OPERAND_PERM :
1316       value = fields->f_perm;
1317       break;
1318     case MT_OPERAND_RBBC :
1319       value = fields->f_rbbc;
1320       break;
1321     case MT_OPERAND_RC :
1322       value = fields->f_rc;
1323       break;
1324     case MT_OPERAND_RC1 :
1325       value = fields->f_rc1;
1326       break;
1327     case MT_OPERAND_RC2 :
1328       value = fields->f_rc2;
1329       break;
1330     case MT_OPERAND_RC3 :
1331       value = fields->f_rc3;
1332       break;
1333     case MT_OPERAND_RCNUM :
1334       value = fields->f_rcnum;
1335       break;
1336     case MT_OPERAND_RDA :
1337       value = fields->f_rda;
1338       break;
1339     case MT_OPERAND_ROWNUM :
1340       value = fields->f_rownum;
1341       break;
1342     case MT_OPERAND_ROWNUM1 :
1343       value = fields->f_rownum1;
1344       break;
1345     case MT_OPERAND_ROWNUM2 :
1346       value = fields->f_rownum2;
1347       break;
1348     case MT_OPERAND_SIZE :
1349       value = fields->f_size;
1350       break;
1351     case MT_OPERAND_TYPE :
1352       value = fields->f_type;
1353       break;
1354     case MT_OPERAND_WR :
1355       value = fields->f_wr;
1356       break;
1357     case MT_OPERAND_XMODE :
1358       value = fields->f_xmode;
1359       break;
1360
1361     default :
1362       /* xgettext:c-format */
1363       opcodes_error_handler
1364         (_("internal error: unrecognized field %d while getting vma operand"),
1365          opindex);
1366       abort ();
1367   }
1368
1369   return value;
1370 }
1371
1372 void mt_cgen_set_int_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, int);
1373 void mt_cgen_set_vma_operand  (CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma);
1374
1375 /* Stuffing values in cgen_fields is handled by a collection of functions.
1376    They are distinguished by the type of the VALUE argument they accept.
1377    TODO: floating point, inlining support, remove cases where argument type
1378    not appropriate.  */
1379
1380 void
1381 mt_cgen_set_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1382                              int opindex,
1383                              CGEN_FIELDS * fields,
1384                              int value)
1385 {
1386   switch (opindex)
1387     {
1388     case MT_OPERAND_A23 :
1389       fields->f_a23 = value;
1390       break;
1391     case MT_OPERAND_BALL :
1392       fields->f_ball = value;
1393       break;
1394     case MT_OPERAND_BALL2 :
1395       fields->f_ball2 = value;
1396       break;
1397     case MT_OPERAND_BANKADDR :
1398       fields->f_bankaddr = value;
1399       break;
1400     case MT_OPERAND_BRC :
1401       fields->f_brc = value;
1402       break;
1403     case MT_OPERAND_BRC2 :
1404       fields->f_brc2 = value;
1405       break;
1406     case MT_OPERAND_CB1INCR :
1407       fields->f_cb1incr = value;
1408       break;
1409     case MT_OPERAND_CB1SEL :
1410       fields->f_cb1sel = value;
1411       break;
1412     case MT_OPERAND_CB2INCR :
1413       fields->f_cb2incr = value;
1414       break;
1415     case MT_OPERAND_CB2SEL :
1416       fields->f_cb2sel = value;
1417       break;
1418     case MT_OPERAND_CBRB :
1419       fields->f_cbrb = value;
1420       break;
1421     case MT_OPERAND_CBS :
1422       fields->f_cbs = value;
1423       break;
1424     case MT_OPERAND_CBX :
1425       fields->f_cbx = value;
1426       break;
1427     case MT_OPERAND_CCB :
1428       fields->f_ccb = value;
1429       break;
1430     case MT_OPERAND_CDB :
1431       fields->f_cdb = value;
1432       break;
1433     case MT_OPERAND_CELL :
1434       fields->f_cell = value;
1435       break;
1436     case MT_OPERAND_COLNUM :
1437       fields->f_colnum = value;
1438       break;
1439     case MT_OPERAND_CONTNUM :
1440       fields->f_contnum = value;
1441       break;
1442     case MT_OPERAND_CR :
1443       fields->f_cr = value;
1444       break;
1445     case MT_OPERAND_CTXDISP :
1446       fields->f_ctxdisp = value;
1447       break;
1448     case MT_OPERAND_DUP :
1449       fields->f_dup = value;
1450       break;
1451     case MT_OPERAND_FBDISP :
1452       fields->f_fbdisp = value;
1453       break;
1454     case MT_OPERAND_FBINCR :
1455       fields->f_fbincr = value;
1456       break;
1457     case MT_OPERAND_FRDR :
1458       fields->f_dr = value;
1459       break;
1460     case MT_OPERAND_FRDRRR :
1461       fields->f_drrr = value;
1462       break;
1463     case MT_OPERAND_FRSR1 :
1464       fields->f_sr1 = value;
1465       break;
1466     case MT_OPERAND_FRSR2 :
1467       fields->f_sr2 = value;
1468       break;
1469     case MT_OPERAND_ID :
1470       fields->f_id = value;
1471       break;
1472     case MT_OPERAND_IMM16 :
1473       fields->f_imm16s = value;
1474       break;
1475     case MT_OPERAND_IMM16L :
1476       fields->f_imm16l = value;
1477       break;
1478     case MT_OPERAND_IMM16O :
1479       fields->f_imm16s = value;
1480       break;
1481     case MT_OPERAND_IMM16Z :
1482       fields->f_imm16u = value;
1483       break;
1484     case MT_OPERAND_INCAMT :
1485       fields->f_incamt = value;
1486       break;
1487     case MT_OPERAND_INCR :
1488       fields->f_incr = value;
1489       break;
1490     case MT_OPERAND_LENGTH :
1491       fields->f_length = value;
1492       break;
1493     case MT_OPERAND_LOOPSIZE :
1494       fields->f_loopo = value;
1495       break;
1496     case MT_OPERAND_MASK :
1497       fields->f_mask = value;
1498       break;
1499     case MT_OPERAND_MASK1 :
1500       fields->f_mask1 = value;
1501       break;
1502     case MT_OPERAND_MODE :
1503       fields->f_mode = value;
1504       break;
1505     case MT_OPERAND_PERM :
1506       fields->f_perm = value;
1507       break;
1508     case MT_OPERAND_RBBC :
1509       fields->f_rbbc = value;
1510       break;
1511     case MT_OPERAND_RC :
1512       fields->f_rc = value;
1513       break;
1514     case MT_OPERAND_RC1 :
1515       fields->f_rc1 = value;
1516       break;
1517     case MT_OPERAND_RC2 :
1518       fields->f_rc2 = value;
1519       break;
1520     case MT_OPERAND_RC3 :
1521       fields->f_rc3 = value;
1522       break;
1523     case MT_OPERAND_RCNUM :
1524       fields->f_rcnum = value;
1525       break;
1526     case MT_OPERAND_RDA :
1527       fields->f_rda = value;
1528       break;
1529     case MT_OPERAND_ROWNUM :
1530       fields->f_rownum = value;
1531       break;
1532     case MT_OPERAND_ROWNUM1 :
1533       fields->f_rownum1 = value;
1534       break;
1535     case MT_OPERAND_ROWNUM2 :
1536       fields->f_rownum2 = value;
1537       break;
1538     case MT_OPERAND_SIZE :
1539       fields->f_size = value;
1540       break;
1541     case MT_OPERAND_TYPE :
1542       fields->f_type = value;
1543       break;
1544     case MT_OPERAND_WR :
1545       fields->f_wr = value;
1546       break;
1547     case MT_OPERAND_XMODE :
1548       fields->f_xmode = value;
1549       break;
1550
1551     default :
1552       /* xgettext:c-format */
1553       opcodes_error_handler
1554         (_("internal error: unrecognized field %d while setting int operand"),
1555          opindex);
1556       abort ();
1557   }
1558 }
1559
1560 void
1561 mt_cgen_set_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1562                              int opindex,
1563                              CGEN_FIELDS * fields,
1564                              bfd_vma value)
1565 {
1566   switch (opindex)
1567     {
1568     case MT_OPERAND_A23 :
1569       fields->f_a23 = value;
1570       break;
1571     case MT_OPERAND_BALL :
1572       fields->f_ball = value;
1573       break;
1574     case MT_OPERAND_BALL2 :
1575       fields->f_ball2 = value;
1576       break;
1577     case MT_OPERAND_BANKADDR :
1578       fields->f_bankaddr = value;
1579       break;
1580     case MT_OPERAND_BRC :
1581       fields->f_brc = value;
1582       break;
1583     case MT_OPERAND_BRC2 :
1584       fields->f_brc2 = value;
1585       break;
1586     case MT_OPERAND_CB1INCR :
1587       fields->f_cb1incr = value;
1588       break;
1589     case MT_OPERAND_CB1SEL :
1590       fields->f_cb1sel = value;
1591       break;
1592     case MT_OPERAND_CB2INCR :
1593       fields->f_cb2incr = value;
1594       break;
1595     case MT_OPERAND_CB2SEL :
1596       fields->f_cb2sel = value;
1597       break;
1598     case MT_OPERAND_CBRB :
1599       fields->f_cbrb = value;
1600       break;
1601     case MT_OPERAND_CBS :
1602       fields->f_cbs = value;
1603       break;
1604     case MT_OPERAND_CBX :
1605       fields->f_cbx = value;
1606       break;
1607     case MT_OPERAND_CCB :
1608       fields->f_ccb = value;
1609       break;
1610     case MT_OPERAND_CDB :
1611       fields->f_cdb = value;
1612       break;
1613     case MT_OPERAND_CELL :
1614       fields->f_cell = value;
1615       break;
1616     case MT_OPERAND_COLNUM :
1617       fields->f_colnum = value;
1618       break;
1619     case MT_OPERAND_CONTNUM :
1620       fields->f_contnum = value;
1621       break;
1622     case MT_OPERAND_CR :
1623       fields->f_cr = value;
1624       break;
1625     case MT_OPERAND_CTXDISP :
1626       fields->f_ctxdisp = value;
1627       break;
1628     case MT_OPERAND_DUP :
1629       fields->f_dup = value;
1630       break;
1631     case MT_OPERAND_FBDISP :
1632       fields->f_fbdisp = value;
1633       break;
1634     case MT_OPERAND_FBINCR :
1635       fields->f_fbincr = value;
1636       break;
1637     case MT_OPERAND_FRDR :
1638       fields->f_dr = value;
1639       break;
1640     case MT_OPERAND_FRDRRR :
1641       fields->f_drrr = value;
1642       break;
1643     case MT_OPERAND_FRSR1 :
1644       fields->f_sr1 = value;
1645       break;
1646     case MT_OPERAND_FRSR2 :
1647       fields->f_sr2 = value;
1648       break;
1649     case MT_OPERAND_ID :
1650       fields->f_id = value;
1651       break;
1652     case MT_OPERAND_IMM16 :
1653       fields->f_imm16s = value;
1654       break;
1655     case MT_OPERAND_IMM16L :
1656       fields->f_imm16l = value;
1657       break;
1658     case MT_OPERAND_IMM16O :
1659       fields->f_imm16s = value;
1660       break;
1661     case MT_OPERAND_IMM16Z :
1662       fields->f_imm16u = value;
1663       break;
1664     case MT_OPERAND_INCAMT :
1665       fields->f_incamt = value;
1666       break;
1667     case MT_OPERAND_INCR :
1668       fields->f_incr = value;
1669       break;
1670     case MT_OPERAND_LENGTH :
1671       fields->f_length = value;
1672       break;
1673     case MT_OPERAND_LOOPSIZE :
1674       fields->f_loopo = value;
1675       break;
1676     case MT_OPERAND_MASK :
1677       fields->f_mask = value;
1678       break;
1679     case MT_OPERAND_MASK1 :
1680       fields->f_mask1 = value;
1681       break;
1682     case MT_OPERAND_MODE :
1683       fields->f_mode = value;
1684       break;
1685     case MT_OPERAND_PERM :
1686       fields->f_perm = value;
1687       break;
1688     case MT_OPERAND_RBBC :
1689       fields->f_rbbc = value;
1690       break;
1691     case MT_OPERAND_RC :
1692       fields->f_rc = value;
1693       break;
1694     case MT_OPERAND_RC1 :
1695       fields->f_rc1 = value;
1696       break;
1697     case MT_OPERAND_RC2 :
1698       fields->f_rc2 = value;
1699       break;
1700     case MT_OPERAND_RC3 :
1701       fields->f_rc3 = value;
1702       break;
1703     case MT_OPERAND_RCNUM :
1704       fields->f_rcnum = value;
1705       break;
1706     case MT_OPERAND_RDA :
1707       fields->f_rda = value;
1708       break;
1709     case MT_OPERAND_ROWNUM :
1710       fields->f_rownum = value;
1711       break;
1712     case MT_OPERAND_ROWNUM1 :
1713       fields->f_rownum1 = value;
1714       break;
1715     case MT_OPERAND_ROWNUM2 :
1716       fields->f_rownum2 = value;
1717       break;
1718     case MT_OPERAND_SIZE :
1719       fields->f_size = value;
1720       break;
1721     case MT_OPERAND_TYPE :
1722       fields->f_type = value;
1723       break;
1724     case MT_OPERAND_WR :
1725       fields->f_wr = value;
1726       break;
1727     case MT_OPERAND_XMODE :
1728       fields->f_xmode = value;
1729       break;
1730
1731     default :
1732       /* xgettext:c-format */
1733       opcodes_error_handler
1734         (_("internal error: unrecognized field %d while setting vma operand"),
1735          opindex);
1736       abort ();
1737   }
1738 }
1739
1740 /* Function to call before using the instruction builder tables.  */
1741
1742 void
1743 mt_cgen_init_ibld_table (CGEN_CPU_DESC cd)
1744 {
1745   cd->insert_handlers = & mt_cgen_insert_handlers[0];
1746   cd->extract_handlers = & mt_cgen_extract_handlers[0];
1747
1748   cd->insert_operand = mt_cgen_insert_operand;
1749   cd->extract_operand = mt_cgen_extract_operand;
1750
1751   cd->get_int_operand = mt_cgen_get_int_operand;
1752   cd->set_int_operand = mt_cgen_set_int_operand;
1753   cd->get_vma_operand = mt_cgen_get_vma_operand;
1754   cd->set_vma_operand = mt_cgen_set_vma_operand;
1755 }