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