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

Subversion Repositories openrisc_me

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

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.