OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [opcodes/] [mt-ibld.c] - Blame information for rev 851

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius 
/* 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 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2006, 2007
7 
   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 "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 
 
73 
/* Operand insertion.  */
74 
 
75 
#if ! CGEN_INT_INSN_P
76 
 
77 
/* Subroutine of insert_normal.  */
78 
 
79 
static CGEN_INLINE void
80 
insert_1 (CGEN_CPU_DESC cd,
81 
          unsigned long value,
82 
          int start,
83 
          int length,
84 
          int word_length,
85 
          unsigned char *bufp)
86 
{
87 
  unsigned long x,mask;
88 
  int shift;
89 
 
90 
  x = cgen_get_insn_value (cd, bufp, word_length);
91 
 
92 
  /* Written this way to avoid undefined behaviour.  */
93 
  mask = (((1L << (length - 1)) - 1) << 1) | 1;
94 
  if (CGEN_INSN_LSB0_P)
95 
    shift = (start + 1) - length;
96 
  else
97 
    shift = (word_length - (start + length));
98 
  x = (x & ~(mask << shift)) | ((value & mask) << shift);
99 
 
100 
  cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x);
101 
}
102 
 
103 
#endif /* ! CGEN_INT_INSN_P */
104 
 
105 
/* Default insertion routine.
106 
 
107 
   ATTRS is a mask of the boolean attributes.
108 
   WORD_OFFSET is the offset in bits from the start of the insn of the value.
109 
   WORD_LENGTH is the length of the word in bits in which the value resides.
110 
   START is the starting bit number in the word, architecture origin.
111 
   LENGTH is the length of VALUE in bits.
112 
   TOTAL_LENGTH is the total length of the insn in bits.
113 
 
114 
   The result is an error message or NULL if success.  */
115 
 
116 
/* ??? This duplicates functionality with bfd's howto table and
117 
   bfd_install_relocation.  */
118 
/* ??? This doesn't handle bfd_vma's.  Create another function when
119 
   necessary.  */
120 
 
121 
static const char *
122 
insert_normal (CGEN_CPU_DESC cd,
123 
               long value,
124 
               unsigned int attrs,
125 
               unsigned int word_offset,
126 
               unsigned int start,
127 
               unsigned int length,
128 
               unsigned int word_length,
129 
               unsigned int total_length,
130 
               CGEN_INSN_BYTES_PTR buffer)
131 
{
132 
  static char errbuf[100];
133 
  /* Written this way to avoid undefined behaviour.  */
134 
  unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
135 
 
136 
  /* If LENGTH is zero, this operand doesn't contribute to the value.  */
137 
  if (length == 0)
138 
    return NULL;
139 
 
140 
  if (word_length > 32)
141 
    abort ();
142 
 
143 
  /* For architectures with insns smaller than the base-insn-bitsize,
144 
     word_length may be too big.  */
145 
  if (cd->min_insn_bitsize < cd->base_insn_bitsize)
146 
    {
147 
      if (word_offset == 0
148 
          && word_length > total_length)
149 
        word_length = total_length;
150 
    }
151 
 
152 
  /* Ensure VALUE will fit.  */
153 
  if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
154 
    {
155 
      long minval = - (1L << (length - 1));
156 
      unsigned long maxval = mask;
157 
 
158 
      if ((value > 0 && (unsigned long) value > maxval)
159 
          || value < minval)
160 
        {
161 
          /* xgettext:c-format */
162 
          sprintf (errbuf,
163 
                   _("operand out of range (%ld not between %ld and %lu)"),
164 
                   value, minval, maxval);
165 
          return errbuf;
166 
        }
167 
    }
168 
  else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
169 
    {
170 
      unsigned long maxval = mask;
171 
      unsigned long val = (unsigned long) value;
172 
 
173 
      /* For hosts with a word size > 32 check to see if value has been sign
174 
         extended beyond 32 bits.  If so then ignore these higher sign bits
175 
         as the user is attempting to store a 32-bit signed value into an
176 
         unsigned 32-bit field which is allowed.  */
177 
      if (sizeof (unsigned long) > 4 && ((value >> 32) == -1))
178 
        val &= 0xFFFFFFFF;
179 
 
180 
      if (val > maxval)
181 
        {
182 
          /* xgettext:c-format */
183 
          sprintf (errbuf,
184 
                   _("operand out of range (0x%lx not between 0 and 0x%lx)"),
185 
                   val, maxval);
186 
          return errbuf;
187 
        }
188 
    }
189 
  else
190 
    {
191 
      if (! cgen_signed_overflow_ok_p (cd))
192 
        {
193 
          long minval = - (1L << (length - 1));
194 
          long maxval =   (1L << (length - 1)) - 1;
195 
 
196 
          if (value < minval || value > maxval)
197 
            {
198 
              sprintf
199 
                /* xgettext:c-format */
200 
                (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
201 
                 value, minval, maxval);
202 
              return errbuf;
203 
            }
204 
        }
205 
    }
206 
 
207 
#if CGEN_INT_INSN_P
208 
 
209 
  {
210 
    int shift;
211 
 
212 
    if (CGEN_INSN_LSB0_P)
213 
      shift = (word_offset + start + 1) - length;
214 
    else
215 
      shift = total_length - (word_offset + start + length);
216 
    *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
217 
  }
218 
 
219 
#else /* ! CGEN_INT_INSN_P */
220 
 
221 
  {
222 
    unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
223 
 
224 
    insert_1 (cd, value, start, length, word_length, bufp);
225 
  }
226 
 
227 
#endif /* ! CGEN_INT_INSN_P */
228 
 
229 
  return NULL;
230 
}
231 
 
232 
/* Default insn builder (insert handler).
233 
   The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
234 
   that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
235 
   recorded in host byte order, otherwise BUFFER is an array of bytes
236 
   and the value is recorded in target byte order).
237 
   The result is an error message or NULL if success.  */
238 
 
239 
static const char *
240 
insert_insn_normal (CGEN_CPU_DESC cd,
241 
                    const CGEN_INSN * insn,
242 
                    CGEN_FIELDS * fields,
243 
                    CGEN_INSN_BYTES_PTR buffer,
244 
                    bfd_vma pc)
245 
{
246 
  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
247 
  unsigned long value;
248 
  const CGEN_SYNTAX_CHAR_TYPE * syn;
249 
 
250 
  CGEN_INIT_INSERT (cd);
251 
  value = CGEN_INSN_BASE_VALUE (insn);
252 
 
253 
  /* If we're recording insns as numbers (rather than a string of bytes),
254 
     target byte order handling is deferred until later.  */
255 
 
256 
#if CGEN_INT_INSN_P
257 
 
258 
  put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
259 
                      CGEN_FIELDS_BITSIZE (fields), value);
260 
 
261 
#else
262 
 
263 
  cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
264 
                                        (unsigned) CGEN_FIELDS_BITSIZE (fields)),
265 
                       value);
266 
 
267 
#endif /* ! CGEN_INT_INSN_P */
268 
 
269 
  /* ??? It would be better to scan the format's fields.
270 
     Still need to be able to insert a value based on the operand though;
271 
     e.g. storing a branch displacement that got resolved later.
272 
     Needs more thought first.  */
273 
 
274 
  for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
275 
    {
276 
      const char *errmsg;
277 
 
278 
      if (CGEN_SYNTAX_CHAR_P (* syn))
279 
        continue;
280 
 
281 
      errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
282 
                                       fields, buffer, pc);
283 
      if (errmsg)
284 
        return errmsg;
285 
    }
286 
 
287 
  return NULL;
288 
}
289 
 
290 
#if CGEN_INT_INSN_P
291 
/* Cover function to store an insn value into an integral insn.  Must go here
292 
   because it needs <prefix>-desc.h for CGEN_INT_INSN_P.  */
293 
 
294 
static void
295 
put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
296 
                    CGEN_INSN_BYTES_PTR buf,
297 
                    int length,
298 
                    int insn_length,
299 
                    CGEN_INSN_INT value)
300 
{
301 
  /* For architectures with insns smaller than the base-insn-bitsize,
302 
     length may be too big.  */
303 
  if (length > insn_length)
304 
    *buf = value;
305 
  else
306 
    {
307 
      int shift = insn_length - length;
308 
      /* Written this way to avoid undefined behaviour.  */
309 
      CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
310 
 
311 
      *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
312 
    }
313 
}
314 
#endif
315 
 
316 
/* Operand extraction.  */
317 
 
318 
#if ! CGEN_INT_INSN_P
319 
 
320 
/* Subroutine of extract_normal.
321 
   Ensure sufficient bytes are cached in EX_INFO.
322 
   OFFSET is the offset in bytes from the start of the insn of the value.
323 
   BYTES is the length of the needed value.
324 
   Returns 1 for success, 0 for failure.  */
325 
 
326 
static CGEN_INLINE int
327 
fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
328 
            CGEN_EXTRACT_INFO *ex_info,
329 
            int offset,
330 
            int bytes,
331 
            bfd_vma pc)
332 
{
333 
  /* It's doubtful that the middle part has already been fetched so
334 
     we don't optimize that case.  kiss.  */
335 
  unsigned int mask;
336 
  disassemble_info *info = (disassemble_info *) ex_info->dis_info;
337 
 
338 
  /* First do a quick check.  */
339 
  mask = (1 << bytes) - 1;
340 
  if (((ex_info->valid >> offset) & mask) == mask)
341 
    return 1;
342 
 
343 
  /* Search for the first byte we need to read.  */
344 
  for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
345 
    if (! (mask & ex_info->valid))
346 
      break;
347 
 
348 
  if (bytes)
349 
    {
350 
      int status;
351 
 
352 
      pc += offset;
353 
      status = (*info->read_memory_func)
354 
        (pc, ex_info->insn_bytes + offset, bytes, info);
355 
 
356 
      if (status != 0)
357 
        {
358 
          (*info->memory_error_func) (status, pc, info);
359 
          return 0;
360 
        }
361 
 
362 
      ex_info->valid |= ((1 << bytes) - 1) << offset;
363 
    }
364 
 
365 
  return 1;
366 
}
367 
 
368 
/* Subroutine of extract_normal.  */
369 
 
370 
static CGEN_INLINE long
371 
extract_1 (CGEN_CPU_DESC cd,
372 
           CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
373 
           int start,
374 
           int length,
375 
           int word_length,
376 
           unsigned char *bufp,
377 
           bfd_vma pc ATTRIBUTE_UNUSED)
378 
{
379 
  unsigned long x;
380 
  int shift;
381 
 
382 
  x = cgen_get_insn_value (cd, bufp, word_length);
383 
 
384 
  if (CGEN_INSN_LSB0_P)
385 
    shift = (start + 1) - length;
386 
  else
387 
    shift = (word_length - (start + length));
388 
  return x >> shift;
389 
}
390 
 
391 
#endif /* ! CGEN_INT_INSN_P */
392 
 
393 
/* Default extraction routine.
394 
 
395 
   INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
396 
   or sometimes less for cases like the m32r where the base insn size is 32
397 
   but some insns are 16 bits.
398 
   ATTRS is a mask of the boolean attributes.  We only need `SIGNED',
399 
   but for generality we take a bitmask of all of them.
400 
   WORD_OFFSET is the offset in bits from the start of the insn of the value.
401 
   WORD_LENGTH is the length of the word in bits in which the value resides.
402 
   START is the starting bit number in the word, architecture origin.
403 
   LENGTH is the length of VALUE in bits.
404 
   TOTAL_LENGTH is the total length of the insn in bits.
405 
 
406 
   Returns 1 for success, 0 for failure.  */
407 
 
408 
/* ??? The return code isn't properly used.  wip.  */
409 
 
410 
/* ??? This doesn't handle bfd_vma's.  Create another function when
411 
   necessary.  */
412 
 
413 
static int
414 
extract_normal (CGEN_CPU_DESC cd,
415 
#if ! CGEN_INT_INSN_P
416 
                CGEN_EXTRACT_INFO *ex_info,
417 
#else
418 
                CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
419 
#endif
420 
                CGEN_INSN_INT insn_value,
421 
                unsigned int attrs,
422 
                unsigned int word_offset,
423 
                unsigned int start,
424 
                unsigned int length,
425 
                unsigned int word_length,
426 
                unsigned int total_length,
427 
#if ! CGEN_INT_INSN_P
428 
                bfd_vma pc,
429 
#else
430 
                bfd_vma pc ATTRIBUTE_UNUSED,
431 
#endif
432 
                long *valuep)
433 
{
434 
  long value, mask;
435 
 
436 
  /* If LENGTH is zero, this operand doesn't contribute to the value
437 
     so give it a standard value of zero.  */
438 
  if (length == 0)
439 
    {
440 
      *valuep = 0;
441 
      return 1;
442 
    }
443 
 
444 
  if (word_length > 32)
445 
    abort ();
446 
 
447 
  /* For architectures with insns smaller than the insn-base-bitsize,
448 
     word_length may be too big.  */
449 
  if (cd->min_insn_bitsize < cd->base_insn_bitsize)
450 
    {
451 
      if (word_offset + word_length > total_length)
452 
        word_length = total_length - word_offset;
453 
    }
454 
 
455 
  /* Does the value reside in INSN_VALUE, and at the right alignment?  */
456 
 
457 
  if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
458 
    {
459 
      if (CGEN_INSN_LSB0_P)
460 
        value = insn_value >> ((word_offset + start + 1) - length);
461 
      else
462 
        value = insn_value >> (total_length - ( word_offset + start + length));
463 
    }
464 
 
465 
#if ! CGEN_INT_INSN_P
466 
 
467 
  else
468 
    {
469 
      unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
470 
 
471 
      if (word_length > 32)
472 
        abort ();
473 
 
474 
      if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
475 
        return 0;
476 
 
477 
      value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
478 
    }
479 
 
480 
#endif /* ! CGEN_INT_INSN_P */
481 
 
482 
  /* Written this way to avoid undefined behaviour.  */
483 
  mask = (((1L << (length - 1)) - 1) << 1) | 1;
484 
 
485 
  value &= mask;
486 
  /* sign extend? */
487 
  if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
488 
      && (value & (1L << (length - 1))))
489 
    value |= ~mask;
490 
 
491 
  *valuep = value;
492 
 
493 
  return 1;
494 
}
495 
 
496 
/* Default insn extractor.
497 
 
498 
   INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
499 
   The extracted fields are stored in FIELDS.
500 
   EX_INFO is used to handle reading variable length insns.
501 
   Return the length of the insn in bits, or 0 if no match,
502 
   or -1 if an error occurs fetching data (memory_error_func will have
503 
   been called).  */
504 
 
505 
static int
506 
extract_insn_normal (CGEN_CPU_DESC cd,
507 
                     const CGEN_INSN *insn,
508 
                     CGEN_EXTRACT_INFO *ex_info,
509 
                     CGEN_INSN_INT insn_value,
510 
                     CGEN_FIELDS *fields,
511 
                     bfd_vma pc)
512 
{
513 
  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
514 
  const CGEN_SYNTAX_CHAR_TYPE *syn;
515 
 
516 
  CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
517 
 
518 
  CGEN_INIT_EXTRACT (cd);
519 
 
520 
  for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
521 
    {
522 
      int length;
523 
 
524 
      if (CGEN_SYNTAX_CHAR_P (*syn))
525 
        continue;
526 
 
527 
      length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
528 
                                        ex_info, insn_value, fields, pc);
529 
      if (length <= 0)
530 
        return length;
531 
    }
532 
 
533 
  /* We recognized and successfully extracted this insn.  */
534 
  return CGEN_INSN_BITSIZE (insn);
535 
}
536 
 
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 = ((unsigned int) (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 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.