merge from gcc
[binutils.git] / opcodes / ip2k-ibld.c
blobe0c53090517f3310e1377f1cfcf6e7ab058ee5ed
1 /* Instruction building/extraction support for ip2k. -*- C -*-
3 THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
4 - the resultant file is machine generated, cgen-ibld.in isn't
6 Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
8 This file is part of the GNU Binutils and GDB, the GNU debugger.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
13 any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software Foundation, Inc.,
22 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
25 Keep that in mind. */
27 #include "sysdep.h"
28 #include <stdio.h>
29 #include "ansidecl.h"
30 #include "dis-asm.h"
31 #include "bfd.h"
32 #include "symcat.h"
33 #include "ip2k-desc.h"
34 #include "ip2k-opc.h"
35 #include "opintl.h"
36 #include "safe-ctype.h"
38 #undef min
39 #define min(a,b) ((a) < (b) ? (a) : (b))
40 #undef max
41 #define max(a,b) ((a) > (b) ? (a) : (b))
43 /* Used by the ifield rtx function. */
44 #define FLD(f) (fields->f)
46 static const char * insert_normal
47 (CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int,
48 unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR);
49 static const char * insert_insn_normal
50 (CGEN_CPU_DESC, const CGEN_INSN *,
51 CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
52 static int extract_normal
53 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
54 unsigned int, unsigned int, unsigned int, unsigned int,
55 unsigned int, unsigned int, bfd_vma, long *);
56 static int extract_insn_normal
57 (CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
58 CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
59 #if CGEN_INT_INSN_P
60 static void put_insn_int_value
61 (CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT);
62 #endif
63 #if ! CGEN_INT_INSN_P
64 static CGEN_INLINE void insert_1
65 (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *);
66 static CGEN_INLINE int fill_cache
67 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, bfd_vma);
68 static CGEN_INLINE long extract_1
69 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma);
70 #endif
72 /* Operand insertion. */
74 #if ! CGEN_INT_INSN_P
76 /* Subroutine of insert_normal. */
78 static CGEN_INLINE void
79 insert_1 (CGEN_CPU_DESC cd,
80 unsigned long value,
81 int start,
82 int length,
83 int word_length,
84 unsigned char *bufp)
86 unsigned long x,mask;
87 int shift;
89 x = cgen_get_insn_value (cd, bufp, word_length);
91 /* Written this way to avoid undefined behaviour. */
92 mask = (((1L << (length - 1)) - 1) << 1) | 1;
93 if (CGEN_INSN_LSB0_P)
94 shift = (start + 1) - length;
95 else
96 shift = (word_length - (start + length));
97 x = (x & ~(mask << shift)) | ((value & mask) << shift);
99 cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x);
102 #endif /* ! CGEN_INT_INSN_P */
104 /* Default insertion routine.
106 ATTRS is a mask of the boolean attributes.
107 WORD_OFFSET is the offset in bits from the start of the insn of the value.
108 WORD_LENGTH is the length of the word in bits in which the value resides.
109 START is the starting bit number in the word, architecture origin.
110 LENGTH is the length of VALUE in bits.
111 TOTAL_LENGTH is the total length of the insn in bits.
113 The result is an error message or NULL if success. */
115 /* ??? This duplicates functionality with bfd's howto table and
116 bfd_install_relocation. */
117 /* ??? This doesn't handle bfd_vma's. Create another function when
118 necessary. */
120 static const char *
121 insert_normal (CGEN_CPU_DESC cd,
122 long value,
123 unsigned int attrs,
124 unsigned int word_offset,
125 unsigned int start,
126 unsigned int length,
127 unsigned int word_length,
128 unsigned int total_length,
129 CGEN_INSN_BYTES_PTR buffer)
131 static char errbuf[100];
132 /* Written this way to avoid undefined behaviour. */
133 unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
135 /* If LENGTH is zero, this operand doesn't contribute to the value. */
136 if (length == 0)
137 return NULL;
139 #if 0
140 if (CGEN_INT_INSN_P
141 && word_offset != 0)
142 abort ();
143 #endif
145 if (word_length > 32)
146 abort ();
148 /* For architectures with insns smaller than the base-insn-bitsize,
149 word_length may be too big. */
150 if (cd->min_insn_bitsize < cd->base_insn_bitsize)
152 if (word_offset == 0
153 && word_length > total_length)
154 word_length = total_length;
157 /* Ensure VALUE will fit. */
158 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
160 long minval = - (1L << (length - 1));
161 unsigned long maxval = mask;
163 if ((value > 0 && (unsigned long) value > maxval)
164 || value < minval)
166 /* xgettext:c-format */
167 sprintf (errbuf,
168 _("operand out of range (%ld not between %ld and %lu)"),
169 value, minval, maxval);
170 return errbuf;
173 else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
175 unsigned long maxval = mask;
177 if ((unsigned long) value > maxval)
179 /* xgettext:c-format */
180 sprintf (errbuf,
181 _("operand out of range (%lu not between 0 and %lu)"),
182 value, maxval);
183 return errbuf;
186 else
188 if (! cgen_signed_overflow_ok_p (cd))
190 long minval = - (1L << (length - 1));
191 long maxval = (1L << (length - 1)) - 1;
193 if (value < minval || value > maxval)
195 sprintf
196 /* xgettext:c-format */
197 (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
198 value, minval, maxval);
199 return errbuf;
204 #if CGEN_INT_INSN_P
207 int shift;
209 if (CGEN_INSN_LSB0_P)
210 shift = (word_offset + start + 1) - length;
211 else
212 shift = total_length - (word_offset + start + length);
213 *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
216 #else /* ! CGEN_INT_INSN_P */
219 unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
221 insert_1 (cd, value, start, length, word_length, bufp);
224 #endif /* ! CGEN_INT_INSN_P */
226 return NULL;
229 /* Default insn builder (insert handler).
230 The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
231 that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
232 recorded in host byte order, otherwise BUFFER is an array of bytes
233 and the value is recorded in target byte order).
234 The result is an error message or NULL if success. */
236 static const char *
237 insert_insn_normal (CGEN_CPU_DESC cd,
238 const CGEN_INSN * insn,
239 CGEN_FIELDS * fields,
240 CGEN_INSN_BYTES_PTR buffer,
241 bfd_vma pc)
243 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
244 unsigned long value;
245 const CGEN_SYNTAX_CHAR_TYPE * syn;
247 CGEN_INIT_INSERT (cd);
248 value = CGEN_INSN_BASE_VALUE (insn);
250 /* If we're recording insns as numbers (rather than a string of bytes),
251 target byte order handling is deferred until later. */
253 #if CGEN_INT_INSN_P
255 put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
256 CGEN_FIELDS_BITSIZE (fields), value);
258 #else
260 cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
261 (unsigned) CGEN_FIELDS_BITSIZE (fields)),
262 value);
264 #endif /* ! CGEN_INT_INSN_P */
266 /* ??? It would be better to scan the format's fields.
267 Still need to be able to insert a value based on the operand though;
268 e.g. storing a branch displacement that got resolved later.
269 Needs more thought first. */
271 for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
273 const char *errmsg;
275 if (CGEN_SYNTAX_CHAR_P (* syn))
276 continue;
278 errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
279 fields, buffer, pc);
280 if (errmsg)
281 return errmsg;
284 return NULL;
287 #if CGEN_INT_INSN_P
288 /* Cover function to store an insn value into an integral insn. Must go here
289 because it needs <prefix>-desc.h for CGEN_INT_INSN_P. */
291 static void
292 put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
293 CGEN_INSN_BYTES_PTR buf,
294 int length,
295 int insn_length,
296 CGEN_INSN_INT value)
298 /* For architectures with insns smaller than the base-insn-bitsize,
299 length may be too big. */
300 if (length > insn_length)
301 *buf = value;
302 else
304 int shift = insn_length - length;
305 /* Written this way to avoid undefined behaviour. */
306 CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
307 *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
310 #endif
312 /* Operand extraction. */
314 #if ! CGEN_INT_INSN_P
316 /* Subroutine of extract_normal.
317 Ensure sufficient bytes are cached in EX_INFO.
318 OFFSET is the offset in bytes from the start of the insn of the value.
319 BYTES is the length of the needed value.
320 Returns 1 for success, 0 for failure. */
322 static CGEN_INLINE int
323 fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
324 CGEN_EXTRACT_INFO *ex_info,
325 int offset,
326 int bytes,
327 bfd_vma pc)
329 /* It's doubtful that the middle part has already been fetched so
330 we don't optimize that case. kiss. */
331 unsigned int mask;
332 disassemble_info *info = (disassemble_info *) ex_info->dis_info;
334 /* First do a quick check. */
335 mask = (1 << bytes) - 1;
336 if (((ex_info->valid >> offset) & mask) == mask)
337 return 1;
339 /* Search for the first byte we need to read. */
340 for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
341 if (! (mask & ex_info->valid))
342 break;
344 if (bytes)
346 int status;
348 pc += offset;
349 status = (*info->read_memory_func)
350 (pc, ex_info->insn_bytes + offset, bytes, info);
352 if (status != 0)
354 (*info->memory_error_func) (status, pc, info);
355 return 0;
358 ex_info->valid |= ((1 << bytes) - 1) << offset;
361 return 1;
364 /* Subroutine of extract_normal. */
366 static CGEN_INLINE long
367 extract_1 (CGEN_CPU_DESC cd,
368 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
369 int start,
370 int length,
371 int word_length,
372 unsigned char *bufp,
373 bfd_vma pc ATTRIBUTE_UNUSED)
375 unsigned long x;
376 int shift;
377 #if 0
378 int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
379 #endif
380 x = cgen_get_insn_value (cd, bufp, word_length);
382 if (CGEN_INSN_LSB0_P)
383 shift = (start + 1) - length;
384 else
385 shift = (word_length - (start + length));
386 return x >> shift;
389 #endif /* ! CGEN_INT_INSN_P */
391 /* Default extraction routine.
393 INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
394 or sometimes less for cases like the m32r where the base insn size is 32
395 but some insns are 16 bits.
396 ATTRS is a mask of the boolean attributes. We only need `SIGNED',
397 but for generality we take a bitmask of all of them.
398 WORD_OFFSET is the offset in bits from the start of the insn of the value.
399 WORD_LENGTH is the length of the word in bits in which the value resides.
400 START is the starting bit number in the word, architecture origin.
401 LENGTH is the length of VALUE in bits.
402 TOTAL_LENGTH is the total length of the insn in bits.
404 Returns 1 for success, 0 for failure. */
406 /* ??? The return code isn't properly used. wip. */
408 /* ??? This doesn't handle bfd_vma's. Create another function when
409 necessary. */
411 static int
412 extract_normal (CGEN_CPU_DESC cd,
413 #if ! CGEN_INT_INSN_P
414 CGEN_EXTRACT_INFO *ex_info,
415 #else
416 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
417 #endif
418 CGEN_INSN_INT insn_value,
419 unsigned int attrs,
420 unsigned int word_offset,
421 unsigned int start,
422 unsigned int length,
423 unsigned int word_length,
424 unsigned int total_length,
425 #if ! CGEN_INT_INSN_P
426 bfd_vma pc,
427 #else
428 bfd_vma pc ATTRIBUTE_UNUSED,
429 #endif
430 long *valuep)
432 long value, mask;
434 /* If LENGTH is zero, this operand doesn't contribute to the value
435 so give it a standard value of zero. */
436 if (length == 0)
438 *valuep = 0;
439 return 1;
442 #if 0
443 if (CGEN_INT_INSN_P
444 && word_offset != 0)
445 abort ();
446 #endif
448 if (word_length > 32)
449 abort ();
451 /* For architectures with insns smaller than the insn-base-bitsize,
452 word_length may be too big. */
453 if (cd->min_insn_bitsize < cd->base_insn_bitsize)
455 if (word_offset == 0
456 && word_length > total_length)
457 word_length = total_length;
460 /* Does the value reside in INSN_VALUE, and at the right alignment? */
462 if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
464 if (CGEN_INSN_LSB0_P)
465 value = insn_value >> ((word_offset + start + 1) - length);
466 else
467 value = insn_value >> (total_length - ( word_offset + start + length));
470 #if ! CGEN_INT_INSN_P
472 else
474 unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
476 if (word_length > 32)
477 abort ();
479 if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
480 return 0;
482 value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
485 #endif /* ! CGEN_INT_INSN_P */
487 /* Written this way to avoid undefined behaviour. */
488 mask = (((1L << (length - 1)) - 1) << 1) | 1;
490 value &= mask;
491 /* sign extend? */
492 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
493 && (value & (1L << (length - 1))))
494 value |= ~mask;
496 *valuep = value;
498 return 1;
501 /* Default insn extractor.
503 INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
504 The extracted fields are stored in FIELDS.
505 EX_INFO is used to handle reading variable length insns.
506 Return the length of the insn in bits, or 0 if no match,
507 or -1 if an error occurs fetching data (memory_error_func will have
508 been called). */
510 static int
511 extract_insn_normal (CGEN_CPU_DESC cd,
512 const CGEN_INSN *insn,
513 CGEN_EXTRACT_INFO *ex_info,
514 CGEN_INSN_INT insn_value,
515 CGEN_FIELDS *fields,
516 bfd_vma pc)
518 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
519 const CGEN_SYNTAX_CHAR_TYPE *syn;
521 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
523 CGEN_INIT_EXTRACT (cd);
525 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
527 int length;
529 if (CGEN_SYNTAX_CHAR_P (*syn))
530 continue;
532 length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
533 ex_info, insn_value, fields, pc);
534 if (length <= 0)
535 return length;
538 /* We recognized and successfully extracted this insn. */
539 return CGEN_INSN_BITSIZE (insn);
542 /* machine generated code added here */
544 const char * ip2k_cgen_insert_operand
545 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
547 /* Main entry point for operand insertion.
549 This function is basically just a big switch statement. Earlier versions
550 used tables to look up the function to use, but
551 - if the table contains both assembler and disassembler functions then
552 the disassembler contains much of the assembler and vice-versa,
553 - there's a lot of inlining possibilities as things grow,
554 - using a switch statement avoids the function call overhead.
556 This function could be moved into `parse_insn_normal', but keeping it
557 separate makes clear the interface between `parse_insn_normal' and each of
558 the handlers. It's also needed by GAS to insert operands that couldn't be
559 resolved during parsing. */
561 const char *
562 ip2k_cgen_insert_operand (cd, opindex, fields, buffer, pc)
563 CGEN_CPU_DESC cd;
564 int opindex;
565 CGEN_FIELDS * fields;
566 CGEN_INSN_BYTES_PTR buffer;
567 bfd_vma pc ATTRIBUTE_UNUSED;
569 const char * errmsg = NULL;
570 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
572 switch (opindex)
574 case IP2K_OPERAND_ADDR16CJP :
575 errmsg = insert_normal (cd, fields->f_addr16cjp, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 12, 13, 16, total_length, buffer);
576 break;
577 case IP2K_OPERAND_ADDR16H :
578 errmsg = insert_normal (cd, fields->f_imm8, 0, 0, 7, 8, 16, total_length, buffer);
579 break;
580 case IP2K_OPERAND_ADDR16L :
581 errmsg = insert_normal (cd, fields->f_imm8, 0, 0, 7, 8, 16, total_length, buffer);
582 break;
583 case IP2K_OPERAND_ADDR16P :
584 errmsg = insert_normal (cd, fields->f_page3, 0, 0, 2, 3, 16, total_length, buffer);
585 break;
586 case IP2K_OPERAND_BITNO :
587 errmsg = insert_normal (cd, fields->f_bitno, 0, 0, 11, 3, 16, total_length, buffer);
588 break;
589 case IP2K_OPERAND_CBIT :
590 break;
591 case IP2K_OPERAND_DCBIT :
592 break;
593 case IP2K_OPERAND_FR :
594 errmsg = insert_normal (cd, fields->f_reg, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 8, 9, 16, total_length, buffer);
595 break;
596 case IP2K_OPERAND_LIT8 :
597 errmsg = insert_normal (cd, fields->f_imm8, 0, 0, 7, 8, 16, total_length, buffer);
598 break;
599 case IP2K_OPERAND_PABITS :
600 break;
601 case IP2K_OPERAND_RETI3 :
602 errmsg = insert_normal (cd, fields->f_reti3, 0, 0, 2, 3, 16, total_length, buffer);
603 break;
604 case IP2K_OPERAND_ZBIT :
605 break;
607 default :
608 /* xgettext:c-format */
609 fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
610 opindex);
611 abort ();
614 return errmsg;
617 int ip2k_cgen_extract_operand
618 PARAMS ((CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
619 CGEN_FIELDS *, bfd_vma));
621 /* Main entry point for operand extraction.
622 The result is <= 0 for error, >0 for success.
623 ??? Actual values aren't well defined right now.
625 This function is basically just a big switch statement. Earlier versions
626 used tables to look up the function to use, but
627 - if the table contains both assembler and disassembler functions then
628 the disassembler contains much of the assembler and vice-versa,
629 - there's a lot of inlining possibilities as things grow,
630 - using a switch statement avoids the function call overhead.
632 This function could be moved into `print_insn_normal', but keeping it
633 separate makes clear the interface between `print_insn_normal' and each of
634 the handlers. */
637 ip2k_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
638 CGEN_CPU_DESC cd;
639 int opindex;
640 CGEN_EXTRACT_INFO *ex_info;
641 CGEN_INSN_INT insn_value;
642 CGEN_FIELDS * fields;
643 bfd_vma pc;
645 /* Assume success (for those operands that are nops). */
646 int length = 1;
647 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
649 switch (opindex)
651 case IP2K_OPERAND_ADDR16CJP :
652 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 12, 13, 16, total_length, pc, & fields->f_addr16cjp);
653 break;
654 case IP2K_OPERAND_ADDR16H :
655 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 16, total_length, pc, & fields->f_imm8);
656 break;
657 case IP2K_OPERAND_ADDR16L :
658 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 16, total_length, pc, & fields->f_imm8);
659 break;
660 case IP2K_OPERAND_ADDR16P :
661 length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 16, total_length, pc, & fields->f_page3);
662 break;
663 case IP2K_OPERAND_BITNO :
664 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 3, 16, total_length, pc, & fields->f_bitno);
665 break;
666 case IP2K_OPERAND_CBIT :
667 break;
668 case IP2K_OPERAND_DCBIT :
669 break;
670 case IP2K_OPERAND_FR :
671 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 8, 9, 16, total_length, pc, & fields->f_reg);
672 break;
673 case IP2K_OPERAND_LIT8 :
674 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 16, total_length, pc, & fields->f_imm8);
675 break;
676 case IP2K_OPERAND_PABITS :
677 break;
678 case IP2K_OPERAND_RETI3 :
679 length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 16, total_length, pc, & fields->f_reti3);
680 break;
681 case IP2K_OPERAND_ZBIT :
682 break;
684 default :
685 /* xgettext:c-format */
686 fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
687 opindex);
688 abort ();
691 return length;
694 cgen_insert_fn * const ip2k_cgen_insert_handlers[] =
696 insert_insn_normal,
699 cgen_extract_fn * const ip2k_cgen_extract_handlers[] =
701 extract_insn_normal,
704 int ip2k_cgen_get_int_operand
705 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
706 bfd_vma ip2k_cgen_get_vma_operand
707 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
709 /* Getting values from cgen_fields is handled by a collection of functions.
710 They are distinguished by the type of the VALUE argument they return.
711 TODO: floating point, inlining support, remove cases where result type
712 not appropriate. */
715 ip2k_cgen_get_int_operand (cd, opindex, fields)
716 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
717 int opindex;
718 const CGEN_FIELDS * fields;
720 int value;
722 switch (opindex)
724 case IP2K_OPERAND_ADDR16CJP :
725 value = fields->f_addr16cjp;
726 break;
727 case IP2K_OPERAND_ADDR16H :
728 value = fields->f_imm8;
729 break;
730 case IP2K_OPERAND_ADDR16L :
731 value = fields->f_imm8;
732 break;
733 case IP2K_OPERAND_ADDR16P :
734 value = fields->f_page3;
735 break;
736 case IP2K_OPERAND_BITNO :
737 value = fields->f_bitno;
738 break;
739 case IP2K_OPERAND_CBIT :
740 value = 0;
741 break;
742 case IP2K_OPERAND_DCBIT :
743 value = 0;
744 break;
745 case IP2K_OPERAND_FR :
746 value = fields->f_reg;
747 break;
748 case IP2K_OPERAND_LIT8 :
749 value = fields->f_imm8;
750 break;
751 case IP2K_OPERAND_PABITS :
752 value = 0;
753 break;
754 case IP2K_OPERAND_RETI3 :
755 value = fields->f_reti3;
756 break;
757 case IP2K_OPERAND_ZBIT :
758 value = 0;
759 break;
761 default :
762 /* xgettext:c-format */
763 fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
764 opindex);
765 abort ();
768 return value;
771 bfd_vma
772 ip2k_cgen_get_vma_operand (cd, opindex, fields)
773 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
774 int opindex;
775 const CGEN_FIELDS * fields;
777 bfd_vma value;
779 switch (opindex)
781 case IP2K_OPERAND_ADDR16CJP :
782 value = fields->f_addr16cjp;
783 break;
784 case IP2K_OPERAND_ADDR16H :
785 value = fields->f_imm8;
786 break;
787 case IP2K_OPERAND_ADDR16L :
788 value = fields->f_imm8;
789 break;
790 case IP2K_OPERAND_ADDR16P :
791 value = fields->f_page3;
792 break;
793 case IP2K_OPERAND_BITNO :
794 value = fields->f_bitno;
795 break;
796 case IP2K_OPERAND_CBIT :
797 value = 0;
798 break;
799 case IP2K_OPERAND_DCBIT :
800 value = 0;
801 break;
802 case IP2K_OPERAND_FR :
803 value = fields->f_reg;
804 break;
805 case IP2K_OPERAND_LIT8 :
806 value = fields->f_imm8;
807 break;
808 case IP2K_OPERAND_PABITS :
809 value = 0;
810 break;
811 case IP2K_OPERAND_RETI3 :
812 value = fields->f_reti3;
813 break;
814 case IP2K_OPERAND_ZBIT :
815 value = 0;
816 break;
818 default :
819 /* xgettext:c-format */
820 fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
821 opindex);
822 abort ();
825 return value;
828 void ip2k_cgen_set_int_operand
829 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int));
830 void ip2k_cgen_set_vma_operand
831 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma));
833 /* Stuffing values in cgen_fields is handled by a collection of functions.
834 They are distinguished by the type of the VALUE argument they accept.
835 TODO: floating point, inlining support, remove cases where argument type
836 not appropriate. */
838 void
839 ip2k_cgen_set_int_operand (cd, opindex, fields, value)
840 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
841 int opindex;
842 CGEN_FIELDS * fields;
843 int value;
845 switch (opindex)
847 case IP2K_OPERAND_ADDR16CJP :
848 fields->f_addr16cjp = value;
849 break;
850 case IP2K_OPERAND_ADDR16H :
851 fields->f_imm8 = value;
852 break;
853 case IP2K_OPERAND_ADDR16L :
854 fields->f_imm8 = value;
855 break;
856 case IP2K_OPERAND_ADDR16P :
857 fields->f_page3 = value;
858 break;
859 case IP2K_OPERAND_BITNO :
860 fields->f_bitno = value;
861 break;
862 case IP2K_OPERAND_CBIT :
863 break;
864 case IP2K_OPERAND_DCBIT :
865 break;
866 case IP2K_OPERAND_FR :
867 fields->f_reg = value;
868 break;
869 case IP2K_OPERAND_LIT8 :
870 fields->f_imm8 = value;
871 break;
872 case IP2K_OPERAND_PABITS :
873 break;
874 case IP2K_OPERAND_RETI3 :
875 fields->f_reti3 = value;
876 break;
877 case IP2K_OPERAND_ZBIT :
878 break;
880 default :
881 /* xgettext:c-format */
882 fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
883 opindex);
884 abort ();
888 void
889 ip2k_cgen_set_vma_operand (cd, opindex, fields, value)
890 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
891 int opindex;
892 CGEN_FIELDS * fields;
893 bfd_vma value;
895 switch (opindex)
897 case IP2K_OPERAND_ADDR16CJP :
898 fields->f_addr16cjp = value;
899 break;
900 case IP2K_OPERAND_ADDR16H :
901 fields->f_imm8 = value;
902 break;
903 case IP2K_OPERAND_ADDR16L :
904 fields->f_imm8 = value;
905 break;
906 case IP2K_OPERAND_ADDR16P :
907 fields->f_page3 = value;
908 break;
909 case IP2K_OPERAND_BITNO :
910 fields->f_bitno = value;
911 break;
912 case IP2K_OPERAND_CBIT :
913 break;
914 case IP2K_OPERAND_DCBIT :
915 break;
916 case IP2K_OPERAND_FR :
917 fields->f_reg = value;
918 break;
919 case IP2K_OPERAND_LIT8 :
920 fields->f_imm8 = value;
921 break;
922 case IP2K_OPERAND_PABITS :
923 break;
924 case IP2K_OPERAND_RETI3 :
925 fields->f_reti3 = value;
926 break;
927 case IP2K_OPERAND_ZBIT :
928 break;
930 default :
931 /* xgettext:c-format */
932 fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
933 opindex);
934 abort ();
938 /* Function to call before using the instruction builder tables. */
940 void
941 ip2k_cgen_init_ibld_table (cd)
942 CGEN_CPU_DESC cd;
944 cd->insert_handlers = & ip2k_cgen_insert_handlers[0];
945 cd->extract_handlers = & ip2k_cgen_extract_handlers[0];
947 cd->insert_operand = ip2k_cgen_insert_operand;
948 cd->extract_operand = ip2k_cgen_extract_operand;
950 cd->get_int_operand = ip2k_cgen_get_int_operand;
951 cd->set_int_operand = ip2k_cgen_set_int_operand;
952 cd->get_vma_operand = ip2k_cgen_get_vma_operand;
953 cd->set_vma_operand = ip2k_cgen_set_vma_operand;