source: trunk/src/binutils/opcodes/frv-ibld.c@ 2013

Last change on this file since 2013 was 607, checked in by bird, 22 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 60.9 KB
Line 
1/* Instruction building/extraction support for frv. -*- C -*-
2
3THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
4- the resultant file is machine generated, cgen-ibld.in isn't
5
6Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
7
8This file is part of the GNU Binutils and GDB, the GNU debugger.
9
10This program is free software; you can redistribute it and/or modify
11it under the terms of the GNU General Public License as published by
12the Free Software Foundation; either version 2, or (at your option)
13any later version.
14
15This program is distributed in the hope that it will be useful,
16but WITHOUT ANY WARRANTY; without even the implied warranty of
17MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18GNU General Public License for more details.
19
20You should have received a copy of the GNU General Public License
21along with this program; if not, write to the Free Software Foundation, Inc.,
2259 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23
24/* ??? Eventually more and more of this stuff can go to cpu-independent files.
25 Keep that in mind. */
26
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 "frv-desc.h"
34#include "frv-opc.h"
35#include "opintl.h"
36#include "safe-ctype.h"
37
38#undef min
39#define min(a,b) ((a) < (b) ? (a) : (b))
40#undef max
41#define max(a,b) ((a) > (b) ? (a) : (b))
42
43/* Used by the ifield rtx function. */
44#define FLD(f) (fields->f)
45
46static const char * insert_normal
47 PARAMS ((CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int,
48 unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR));
49static const char * insert_insn_normal
50 PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *,
51 CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
52static int extract_normal
53 PARAMS ((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 *));
56static int extract_insn_normal
57 PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
58 CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma));
59#if CGEN_INT_INSN_P
60static void put_insn_int_value
61 PARAMS ((CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT));
62#endif
63#if ! CGEN_INT_INSN_P
64static CGEN_INLINE void insert_1
65 PARAMS ((CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *));
66static CGEN_INLINE int fill_cache
67 PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, bfd_vma));
68static CGEN_INLINE long extract_1
69 PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int,
70 unsigned char *, bfd_vma));
71#endif
72
73
74/* Operand insertion. */
75
76#if ! CGEN_INT_INSN_P
77
78/* Subroutine of insert_normal. */
79
80static CGEN_INLINE void
81insert_1 (cd, value, start, length, word_length, bufp)
82 CGEN_CPU_DESC cd;
83 unsigned long value;
84 int start,length,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
121static const char *
122insert_normal (cd, value, attrs, word_offset, start, length, word_length,
123 total_length, buffer)
124 CGEN_CPU_DESC cd;
125 long value;
126 unsigned int attrs;
127 unsigned int word_offset, start, length, word_length, total_length;
128 CGEN_INSN_BYTES_PTR buffer;
129{
130 static char errbuf[100];
131 /* Written this way to avoid undefined behaviour. */
132 unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
133
134 /* If LENGTH is zero, this operand doesn't contribute to the value. */
135 if (length == 0)
136 return NULL;
137
138#if 0
139 if (CGEN_INT_INSN_P
140 && word_offset != 0)
141 abort ();
142#endif
143
144 if (word_length > 32)
145 abort ();
146
147 /* For architectures with insns smaller than the base-insn-bitsize,
148 word_length may be too big. */
149 if (cd->min_insn_bitsize < cd->base_insn_bitsize)
150 {
151 if (word_offset == 0
152 && word_length > total_length)
153 word_length = total_length;
154 }
155
156 /* Ensure VALUE will fit. */
157 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
158 {
159 long minval = - (1L << (length - 1));
160 unsigned long maxval = mask;
161
162 if ((value > 0 && (unsigned long) value > maxval)
163 || value < minval)
164 {
165 /* xgettext:c-format */
166 sprintf (errbuf,
167 _("operand out of range (%ld not between %ld and %lu)"),
168 value, minval, maxval);
169 return errbuf;
170 }
171 }
172 else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
173 {
174 unsigned long maxval = mask;
175
176 if ((unsigned long) value > maxval)
177 {
178 /* xgettext:c-format */
179 sprintf (errbuf,
180 _("operand out of range (%lu not between 0 and %lu)"),
181 value, maxval);
182 return errbuf;
183 }
184 }
185 else
186 {
187 if (! cgen_signed_overflow_ok_p (cd))
188 {
189 long minval = - (1L << (length - 1));
190 long maxval = (1L << (length - 1)) - 1;
191
192 if (value < minval || value > maxval)
193 {
194 sprintf
195 /* xgettext:c-format */
196 (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
197 value, minval, maxval);
198 return errbuf;
199 }
200 }
201 }
202
203#if CGEN_INT_INSN_P
204
205 {
206 int shift;
207
208 if (CGEN_INSN_LSB0_P)
209 shift = (word_offset + start + 1) - length;
210 else
211 shift = total_length - (word_offset + start + length);
212 *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
213 }
214
215#else /* ! CGEN_INT_INSN_P */
216
217 {
218 unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
219
220 insert_1 (cd, value, start, length, word_length, bufp);
221 }
222
223#endif /* ! CGEN_INT_INSN_P */
224
225 return NULL;
226}
227
228/* Default insn builder (insert handler).
229 The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
230 that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
231 recorded in host byte order, otherwise BUFFER is an array of bytes
232 and the value is recorded in target byte order).
233 The result is an error message or NULL if success. */
234
235static const char *
236insert_insn_normal (cd, insn, fields, buffer, pc)
237 CGEN_CPU_DESC cd;
238 const CGEN_INSN * insn;
239 CGEN_FIELDS * fields;
240 CGEN_INSN_BYTES_PTR buffer;
241 bfd_vma pc;
242{
243 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
244 unsigned long value;
245 const CGEN_SYNTAX_CHAR_TYPE * syn;
246
247 CGEN_INIT_INSERT (cd);
248 value = CGEN_INSN_BASE_VALUE (insn);
249
250 /* If we're recording insns as numbers (rather than a string of bytes),
251 target byte order handling is deferred until later. */
252
253#if CGEN_INT_INSN_P
254
255 put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
256 CGEN_FIELDS_BITSIZE (fields), value);
257
258#else
259
260 cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
261 (unsigned) CGEN_FIELDS_BITSIZE (fields)),
262 value);
263
264#endif /* ! CGEN_INT_INSN_P */
265
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. */
270
271 for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
272 {
273 const char *errmsg;
274
275 if (CGEN_SYNTAX_CHAR_P (* syn))
276 continue;
277
278 errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
279 fields, buffer, pc);
280 if (errmsg)
281 return errmsg;
282 }
283
284 return NULL;
285}
286
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. */
290
291static void
292put_insn_int_value (cd, buf, length, insn_length, value)
293 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
294 CGEN_INSN_BYTES_PTR buf;
295 int length;
296 int insn_length;
297 CGEN_INSN_INT value;
298{
299 /* For architectures with insns smaller than the base-insn-bitsize,
300 length may be too big. */
301 if (length > insn_length)
302 *buf = value;
303 else
304 {
305 int shift = insn_length - length;
306 /* Written this way to avoid undefined behaviour. */
307 CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
308 *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
309 }
310}
311#endif
312
313
314/* Operand extraction. */
315
316#if ! CGEN_INT_INSN_P
317
318/* Subroutine of extract_normal.
319 Ensure sufficient bytes are cached in EX_INFO.
320 OFFSET is the offset in bytes from the start of the insn of the value.
321 BYTES is the length of the needed value.
322 Returns 1 for success, 0 for failure. */
323
324static CGEN_INLINE int
325fill_cache (cd, ex_info, offset, bytes, pc)
326 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
327 CGEN_EXTRACT_INFO *ex_info;
328 int offset, bytes;
329 bfd_vma pc;
330{
331 /* It's doubtful that the middle part has already been fetched so
332 we don't optimize that case. kiss. */
333 unsigned int mask;
334 disassemble_info *info = (disassemble_info *) ex_info->dis_info;
335
336 /* First do a quick check. */
337 mask = (1 << bytes) - 1;
338 if (((ex_info->valid >> offset) & mask) == mask)
339 return 1;
340
341 /* Search for the first byte we need to read. */
342 for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
343 if (! (mask & ex_info->valid))
344 break;
345
346 if (bytes)
347 {
348 int status;
349
350 pc += offset;
351 status = (*info->read_memory_func)
352 (pc, ex_info->insn_bytes + offset, bytes, info);
353
354 if (status != 0)
355 {
356 (*info->memory_error_func) (status, pc, info);
357 return 0;
358 }
359
360 ex_info->valid |= ((1 << bytes) - 1) << offset;
361 }
362
363 return 1;
364}
365
366/* Subroutine of extract_normal. */
367
368static CGEN_INLINE long
369extract_1 (cd, ex_info, start, length, word_length, bufp, pc)
370 CGEN_CPU_DESC cd;
371 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED;
372 int start,length,word_length;
373 unsigned char *bufp;
374 bfd_vma pc ATTRIBUTE_UNUSED;
375{
376 unsigned long x;
377 int shift;
378#if 0
379 int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
380#endif
381 x = cgen_get_insn_value (cd, bufp, word_length);
382
383 if (CGEN_INSN_LSB0_P)
384 shift = (start + 1) - length;
385 else
386 shift = (word_length - (start + length));
387 return x >> shift;
388}
389
390#endif /* ! CGEN_INT_INSN_P */
391
392/* Default extraction routine.
393
394 INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
395 or sometimes less for cases like the m32r where the base insn size is 32
396 but some insns are 16 bits.
397 ATTRS is a mask of the boolean attributes. We only need `SIGNED',
398 but for generality we take a bitmask of all of them.
399 WORD_OFFSET is the offset in bits from the start of the insn of the value.
400 WORD_LENGTH is the length of the word in bits in which the value resides.
401 START is the starting bit number in the word, architecture origin.
402 LENGTH is the length of VALUE in bits.
403 TOTAL_LENGTH is the total length of the insn in bits.
404
405 Returns 1 for success, 0 for failure. */
406
407/* ??? The return code isn't properly used. wip. */
408
409/* ??? This doesn't handle bfd_vma's. Create another function when
410 necessary. */
411
412static int
413extract_normal (cd, ex_info, insn_value, attrs, word_offset, start, length,
414 word_length, total_length, pc, valuep)
415 CGEN_CPU_DESC cd;
416#if ! CGEN_INT_INSN_P
417 CGEN_EXTRACT_INFO *ex_info;
418#else
419 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED;
420#endif
421 CGEN_INSN_INT insn_value;
422 unsigned int attrs;
423 unsigned int word_offset, start, length, word_length, total_length;
424#if ! CGEN_INT_INSN_P
425 bfd_vma pc;
426#else
427 bfd_vma pc ATTRIBUTE_UNUSED;
428#endif
429 long *valuep;
430{
431 long value, mask;
432
433 /* If LENGTH is zero, this operand doesn't contribute to the value
434 so give it a standard value of zero. */
435 if (length == 0)
436 {
437 *valuep = 0;
438 return 1;
439 }
440
441#if 0
442 if (CGEN_INT_INSN_P
443 && word_offset != 0)
444 abort ();
445#endif
446
447 if (word_length > 32)
448 abort ();
449
450 /* For architectures with insns smaller than the insn-base-bitsize,
451 word_length may be too big. */
452 if (cd->min_insn_bitsize < cd->base_insn_bitsize)
453 {
454 if (word_offset == 0
455 && word_length > total_length)
456 word_length = total_length;
457 }
458
459 /* Does the value reside in INSN_VALUE, and at the right alignment? */
460
461 if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
462 {
463 if (CGEN_INSN_LSB0_P)
464 value = insn_value >> ((word_offset + start + 1) - length);
465 else
466 value = insn_value >> (total_length - ( word_offset + start + length));
467 }
468
469#if ! CGEN_INT_INSN_P
470
471 else
472 {
473 unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
474
475 if (word_length > 32)
476 abort ();
477
478 if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
479 return 0;
480
481 value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
482 }
483
484#endif /* ! CGEN_INT_INSN_P */
485
486 /* Written this way to avoid undefined behaviour. */
487 mask = (((1L << (length - 1)) - 1) << 1) | 1;
488
489 value &= mask;
490 /* sign extend? */
491 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
492 && (value & (1L << (length - 1))))
493 value |= ~mask;
494
495 *valuep = value;
496
497 return 1;
498}
499
500/* Default insn extractor.
501
502 INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
503 The extracted fields are stored in FIELDS.
504 EX_INFO is used to handle reading variable length insns.
505 Return the length of the insn in bits, or 0 if no match,
506 or -1 if an error occurs fetching data (memory_error_func will have
507 been called). */
508
509static int
510extract_insn_normal (cd, insn, ex_info, insn_value, fields, pc)
511 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;
517{
518 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
519 const CGEN_SYNTAX_CHAR_TYPE *syn;
520
521 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
522
523 CGEN_INIT_EXTRACT (cd);
524
525 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
526 {
527 int length;
528
529 if (CGEN_SYNTAX_CHAR_P (*syn))
530 continue;
531
532 length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
533 ex_info, insn_value, fields, pc);
534 if (length <= 0)
535 return length;
536 }
537
538 /* We recognized and successfully extracted this insn. */
539 return CGEN_INSN_BITSIZE (insn);
540}
541
542
543/* machine generated code added here */
544
545const char * frv_cgen_insert_operand
546 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
547
548/* Main entry point for operand insertion.
549
550 This function is basically just a big switch statement. Earlier versions
551 used tables to look up the function to use, but
552 - if the table contains both assembler and disassembler functions then
553 the disassembler contains much of the assembler and vice-versa,
554 - there's a lot of inlining possibilities as things grow,
555 - using a switch statement avoids the function call overhead.
556
557 This function could be moved into `parse_insn_normal', but keeping it
558 separate makes clear the interface between `parse_insn_normal' and each of
559 the handlers. It's also needed by GAS to insert operands that couldn't be
560 resolved during parsing. */
561
562const char *
563frv_cgen_insert_operand (cd, opindex, fields, buffer, pc)
564 CGEN_CPU_DESC cd;
565 int opindex;
566 CGEN_FIELDS * fields;
567 CGEN_INSN_BYTES_PTR buffer;
568 bfd_vma pc ATTRIBUTE_UNUSED;
569{
570 const char * errmsg = NULL;
571 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
572
573 switch (opindex)
574 {
575 case FRV_OPERAND_A :
576 errmsg = insert_normal (cd, fields->f_A, 0, 0, 17, 1, 32, total_length, buffer);
577 break;
578 case FRV_OPERAND_ACC40SI :
579 errmsg = insert_normal (cd, fields->f_ACC40Si, 0, 0, 17, 6, 32, total_length, buffer);
580 break;
581 case FRV_OPERAND_ACC40SK :
582 errmsg = insert_normal (cd, fields->f_ACC40Sk, 0, 0, 30, 6, 32, total_length, buffer);
583 break;
584 case FRV_OPERAND_ACC40UI :
585 errmsg = insert_normal (cd, fields->f_ACC40Ui, 0, 0, 17, 6, 32, total_length, buffer);
586 break;
587 case FRV_OPERAND_ACC40UK :
588 errmsg = insert_normal (cd, fields->f_ACC40Uk, 0, 0, 30, 6, 32, total_length, buffer);
589 break;
590 case FRV_OPERAND_ACCGI :
591 errmsg = insert_normal (cd, fields->f_ACCGi, 0, 0, 17, 6, 32, total_length, buffer);
592 break;
593 case FRV_OPERAND_ACCGK :
594 errmsg = insert_normal (cd, fields->f_ACCGk, 0, 0, 30, 6, 32, total_length, buffer);
595 break;
596 case FRV_OPERAND_CCI :
597 errmsg = insert_normal (cd, fields->f_CCi, 0, 0, 11, 3, 32, total_length, buffer);
598 break;
599 case FRV_OPERAND_CPRDOUBLEK :
600 errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
601 break;
602 case FRV_OPERAND_CPRI :
603 errmsg = insert_normal (cd, fields->f_CPRi, 0, 0, 17, 6, 32, total_length, buffer);
604 break;
605 case FRV_OPERAND_CPRJ :
606 errmsg = insert_normal (cd, fields->f_CPRj, 0, 0, 5, 6, 32, total_length, buffer);
607 break;
608 case FRV_OPERAND_CPRK :
609 errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
610 break;
611 case FRV_OPERAND_CRI :
612 errmsg = insert_normal (cd, fields->f_CRi, 0, 0, 14, 3, 32, total_length, buffer);
613 break;
614 case FRV_OPERAND_CRJ :
615 errmsg = insert_normal (cd, fields->f_CRj, 0, 0, 2, 3, 32, total_length, buffer);
616 break;
617 case FRV_OPERAND_CRJ_FLOAT :
618 errmsg = insert_normal (cd, fields->f_CRj_float, 0, 0, 26, 2, 32, total_length, buffer);
619 break;
620 case FRV_OPERAND_CRJ_INT :
621 {
622 long value = fields->f_CRj_int;
623 value = ((value) - (4));
624 errmsg = insert_normal (cd, value, 0, 0, 26, 2, 32, total_length, buffer);
625 }
626 break;
627 case FRV_OPERAND_CRK :
628 errmsg = insert_normal (cd, fields->f_CRk, 0, 0, 27, 3, 32, total_length, buffer);
629 break;
630 case FRV_OPERAND_FCCI_1 :
631 errmsg = insert_normal (cd, fields->f_FCCi_1, 0, 0, 11, 2, 32, total_length, buffer);
632 break;
633 case FRV_OPERAND_FCCI_2 :
634 errmsg = insert_normal (cd, fields->f_FCCi_2, 0, 0, 26, 2, 32, total_length, buffer);
635 break;
636 case FRV_OPERAND_FCCI_3 :
637 errmsg = insert_normal (cd, fields->f_FCCi_3, 0, 0, 1, 2, 32, total_length, buffer);
638 break;
639 case FRV_OPERAND_FCCK :
640 errmsg = insert_normal (cd, fields->f_FCCk, 0, 0, 26, 2, 32, total_length, buffer);
641 break;
642 case FRV_OPERAND_FRDOUBLEI :
643 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
644 break;
645 case FRV_OPERAND_FRDOUBLEJ :
646 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
647 break;
648 case FRV_OPERAND_FRDOUBLEK :
649 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
650 break;
651 case FRV_OPERAND_FRI :
652 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
653 break;
654 case FRV_OPERAND_FRINTI :
655 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
656 break;
657 case FRV_OPERAND_FRINTJ :
658 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
659 break;
660 case FRV_OPERAND_FRINTK :
661 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
662 break;
663 case FRV_OPERAND_FRJ :
664 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
665 break;
666 case FRV_OPERAND_FRK :
667 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
668 break;
669 case FRV_OPERAND_FRKHI :
670 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
671 break;
672 case FRV_OPERAND_FRKLO :
673 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
674 break;
675 case FRV_OPERAND_GRDOUBLEK :
676 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
677 break;
678 case FRV_OPERAND_GRI :
679 errmsg = insert_normal (cd, fields->f_GRi, 0, 0, 17, 6, 32, total_length, buffer);
680 break;
681 case FRV_OPERAND_GRJ :
682 errmsg = insert_normal (cd, fields->f_GRj, 0, 0, 5, 6, 32, total_length, buffer);
683 break;
684 case FRV_OPERAND_GRK :
685 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
686 break;
687 case FRV_OPERAND_GRKHI :
688 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
689 break;
690 case FRV_OPERAND_GRKLO :
691 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
692 break;
693 case FRV_OPERAND_ICCI_1 :
694 errmsg = insert_normal (cd, fields->f_ICCi_1, 0, 0, 11, 2, 32, total_length, buffer);
695 break;
696 case FRV_OPERAND_ICCI_2 :
697 errmsg = insert_normal (cd, fields->f_ICCi_2, 0, 0, 26, 2, 32, total_length, buffer);
698 break;
699 case FRV_OPERAND_ICCI_3 :
700 errmsg = insert_normal (cd, fields->f_ICCi_3, 0, 0, 1, 2, 32, total_length, buffer);
701 break;
702 case FRV_OPERAND_LI :
703 errmsg = insert_normal (cd, fields->f_LI, 0, 0, 25, 1, 32, total_length, buffer);
704 break;
705 case FRV_OPERAND_AE :
706 errmsg = insert_normal (cd, fields->f_ae, 0, 0, 25, 1, 32, total_length, buffer);
707 break;
708 case FRV_OPERAND_CCOND :
709 errmsg = insert_normal (cd, fields->f_ccond, 0, 0, 12, 1, 32, total_length, buffer);
710 break;
711 case FRV_OPERAND_COND :
712 errmsg = insert_normal (cd, fields->f_cond, 0, 0, 8, 1, 32, total_length, buffer);
713 break;
714 case FRV_OPERAND_D12 :
715 errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
716 break;
717 case FRV_OPERAND_DEBUG :
718 errmsg = insert_normal (cd, fields->f_debug, 0, 0, 25, 1, 32, total_length, buffer);
719 break;
720 case FRV_OPERAND_EIR :
721 errmsg = insert_normal (cd, fields->f_eir, 0, 0, 17, 6, 32, total_length, buffer);
722 break;
723 case FRV_OPERAND_HINT :
724 errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
725 break;
726 case FRV_OPERAND_HINT_NOT_TAKEN :
727 errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
728 break;
729 case FRV_OPERAND_HINT_TAKEN :
730 errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
731 break;
732 case FRV_OPERAND_LABEL16 :
733 {
734 long value = fields->f_label16;
735 value = ((int) (((value) - (pc))) >> (2));
736 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, buffer);
737 }
738 break;
739 case FRV_OPERAND_LABEL24 :
740 {
741{
742 FLD (f_labelH6) = ((int) (((FLD (f_label24)) - (pc))) >> (20));
743 FLD (f_labelL18) = ((((unsigned int) (((FLD (f_label24)) - (pc))) >> (2))) & (262143));
744}
745 errmsg = insert_normal (cd, fields->f_labelH6, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, buffer);
746 if (errmsg)
747 break;
748 errmsg = insert_normal (cd, fields->f_labelL18, 0, 0, 17, 18, 32, total_length, buffer);
749 if (errmsg)
750 break;
751 }
752 break;
753 case FRV_OPERAND_LOCK :
754 errmsg = insert_normal (cd, fields->f_lock, 0, 0, 25, 1, 32, total_length, buffer);
755 break;
756 case FRV_OPERAND_PACK :
757 errmsg = insert_normal (cd, fields->f_pack, 0, 0, 31, 1, 32, total_length, buffer);
758 break;
759 case FRV_OPERAND_S10 :
760 errmsg = insert_normal (cd, fields->f_s10, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, buffer);
761 break;
762 case FRV_OPERAND_S12 :
763 errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
764 break;
765 case FRV_OPERAND_S16 :
766 errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
767 break;
768 case FRV_OPERAND_S5 :
769 errmsg = insert_normal (cd, fields->f_s5, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, buffer);
770 break;
771 case FRV_OPERAND_S6 :
772 errmsg = insert_normal (cd, fields->f_s6, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, buffer);
773 break;
774 case FRV_OPERAND_S6_1 :
775 errmsg = insert_normal (cd, fields->f_s6_1, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, buffer);
776 break;
777 case FRV_OPERAND_SLO16 :
778 errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
779 break;
780 case FRV_OPERAND_SPR :
781 {
782{
783 FLD (f_spr_h) = ((unsigned int) (FLD (f_spr)) >> (6));
784 FLD (f_spr_l) = ((FLD (f_spr)) & (63));
785}
786 errmsg = insert_normal (cd, fields->f_spr_h, 0, 0, 30, 6, 32, total_length, buffer);
787 if (errmsg)
788 break;
789 errmsg = insert_normal (cd, fields->f_spr_l, 0, 0, 17, 6, 32, total_length, buffer);
790 if (errmsg)
791 break;
792 }
793 break;
794 case FRV_OPERAND_U12 :
795 {
796{
797 FLD (f_u12_h) = ((int) (FLD (f_u12)) >> (6));
798 FLD (f_u12_l) = ((FLD (f_u12)) & (63));
799}
800 errmsg = insert_normal (cd, fields->f_u12_h, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, buffer);
801 if (errmsg)
802 break;
803 errmsg = insert_normal (cd, fields->f_u12_l, 0, 0, 5, 6, 32, total_length, buffer);
804 if (errmsg)
805 break;
806 }
807 break;
808 case FRV_OPERAND_U16 :
809 errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
810 break;
811 case FRV_OPERAND_U6 :
812 errmsg = insert_normal (cd, fields->f_u6, 0, 0, 5, 6, 32, total_length, buffer);
813 break;
814 case FRV_OPERAND_UHI16 :
815 errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
816 break;
817 case FRV_OPERAND_ULO16 :
818 errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
819 break;
820
821 default :
822 /* xgettext:c-format */
823 fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
824 opindex);
825 abort ();
826 }
827
828 return errmsg;
829}
830
831int frv_cgen_extract_operand
832 PARAMS ((CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
833 CGEN_FIELDS *, bfd_vma));
834
835/* Main entry point for operand extraction.
836 The result is <= 0 for error, >0 for success.
837 ??? Actual values aren't well defined right now.
838
839 This function is basically just a big switch statement. Earlier versions
840 used tables to look up the function to use, but
841 - if the table contains both assembler and disassembler functions then
842 the disassembler contains much of the assembler and vice-versa,
843 - there's a lot of inlining possibilities as things grow,
844 - using a switch statement avoids the function call overhead.
845
846 This function could be moved into `print_insn_normal', but keeping it
847 separate makes clear the interface between `print_insn_normal' and each of
848 the handlers. */
849
850int
851frv_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
852 CGEN_CPU_DESC cd;
853 int opindex;
854 CGEN_EXTRACT_INFO *ex_info;
855 CGEN_INSN_INT insn_value;
856 CGEN_FIELDS * fields;
857 bfd_vma pc;
858{
859 /* Assume success (for those operands that are nops). */
860 int length = 1;
861 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
862
863 switch (opindex)
864 {
865 case FRV_OPERAND_A :
866 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 1, 32, total_length, pc, & fields->f_A);
867 break;
868 case FRV_OPERAND_ACC40SI :
869 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Si);
870 break;
871 case FRV_OPERAND_ACC40SK :
872 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Sk);
873 break;
874 case FRV_OPERAND_ACC40UI :
875 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Ui);
876 break;
877 case FRV_OPERAND_ACC40UK :
878 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Uk);
879 break;
880 case FRV_OPERAND_ACCGI :
881 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACCGi);
882 break;
883 case FRV_OPERAND_ACCGK :
884 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACCGk);
885 break;
886 case FRV_OPERAND_CCI :
887 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 3, 32, total_length, pc, & fields->f_CCi);
888 break;
889 case FRV_OPERAND_CPRDOUBLEK :
890 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
891 break;
892 case FRV_OPERAND_CPRI :
893 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_CPRi);
894 break;
895 case FRV_OPERAND_CPRJ :
896 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_CPRj);
897 break;
898 case FRV_OPERAND_CPRK :
899 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
900 break;
901 case FRV_OPERAND_CRI :
902 length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_CRi);
903 break;
904 case FRV_OPERAND_CRJ :
905 length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 32, total_length, pc, & fields->f_CRj);
906 break;
907 case FRV_OPERAND_CRJ_FLOAT :
908 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_CRj_float);
909 break;
910 case FRV_OPERAND_CRJ_INT :
911 {
912 long value;
913 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & value);
914 value = ((value) + (4));
915 fields->f_CRj_int = value;
916 }
917 break;
918 case FRV_OPERAND_CRK :
919 length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 3, 32, total_length, pc, & fields->f_CRk);
920 break;
921 case FRV_OPERAND_FCCI_1 :
922 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_FCCi_1);
923 break;
924 case FRV_OPERAND_FCCI_2 :
925 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCi_2);
926 break;
927 case FRV_OPERAND_FCCI_3 :
928 length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_FCCi_3);
929 break;
930 case FRV_OPERAND_FCCK :
931 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCk);
932 break;
933 case FRV_OPERAND_FRDOUBLEI :
934 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
935 break;
936 case FRV_OPERAND_FRDOUBLEJ :
937 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
938 break;
939 case FRV_OPERAND_FRDOUBLEK :
940 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
941 break;
942 case FRV_OPERAND_FRI :
943 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
944 break;
945 case FRV_OPERAND_FRINTI :
946 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
947 break;
948 case FRV_OPERAND_FRINTJ :
949 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
950 break;
951 case FRV_OPERAND_FRINTK :
952 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
953 break;
954 case FRV_OPERAND_FRJ :
955 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
956 break;
957 case FRV_OPERAND_FRK :
958 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
959 break;
960 case FRV_OPERAND_FRKHI :
961 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
962 break;
963 case FRV_OPERAND_FRKLO :
964 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
965 break;
966 case FRV_OPERAND_GRDOUBLEK :
967 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
968 break;
969 case FRV_OPERAND_GRI :
970 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_GRi);
971 break;
972 case FRV_OPERAND_GRJ :
973 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_GRj);
974 break;
975 case FRV_OPERAND_GRK :
976 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
977 break;
978 case FRV_OPERAND_GRKHI :
979 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
980 break;
981 case FRV_OPERAND_GRKLO :
982 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
983 break;
984 case FRV_OPERAND_ICCI_1 :
985 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_ICCi_1);
986 break;
987 case FRV_OPERAND_ICCI_2 :
988 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_ICCi_2);
989 break;
990 case FRV_OPERAND_ICCI_3 :
991 length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_ICCi_3);
992 break;
993 case FRV_OPERAND_LI :
994 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_LI);
995 break;
996 case FRV_OPERAND_AE :
997 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_ae);
998 break;
999 case FRV_OPERAND_CCOND :
1000 length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 1, 32, total_length, pc, & fields->f_ccond);
1001 break;
1002 case FRV_OPERAND_COND :
1003 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 1, 32, total_length, pc, & fields->f_cond);
1004 break;
1005 case FRV_OPERAND_D12 :
1006 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
1007 break;
1008 case FRV_OPERAND_DEBUG :
1009 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_debug);
1010 break;
1011 case FRV_OPERAND_EIR :
1012 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_eir);
1013 break;
1014 case FRV_OPERAND_HINT :
1015 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1016 break;
1017 case FRV_OPERAND_HINT_NOT_TAKEN :
1018 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1019 break;
1020 case FRV_OPERAND_HINT_TAKEN :
1021 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1022 break;
1023 case FRV_OPERAND_LABEL16 :
1024 {
1025 long value;
1026 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, pc, & value);
1027 value = ((((value) << (2))) + (pc));
1028 fields->f_label16 = value;
1029 }
1030 break;
1031 case FRV_OPERAND_LABEL24 :
1032 {
1033 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, pc, & fields->f_labelH6);
1034 if (length <= 0) break;
1035 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 18, 32, total_length, pc, & fields->f_labelL18);
1036 if (length <= 0) break;
1037{
1038 FLD (f_label24) = ((((((((FLD (f_labelH6)) << (18))) | (FLD (f_labelL18)))) << (2))) + (pc));
1039}
1040 }
1041 break;
1042 case FRV_OPERAND_LOCK :
1043 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_lock);
1044 break;
1045 case FRV_OPERAND_PACK :
1046 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 1, 32, total_length, pc, & fields->f_pack);
1047 break;
1048 case FRV_OPERAND_S10 :
1049 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, pc, & fields->f_s10);
1050 break;
1051 case FRV_OPERAND_S12 :
1052 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
1053 break;
1054 case FRV_OPERAND_S16 :
1055 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
1056 break;
1057 case FRV_OPERAND_S5 :
1058 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, pc, & fields->f_s5);
1059 break;
1060 case FRV_OPERAND_S6 :
1061 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, pc, & fields->f_s6);
1062 break;
1063 case FRV_OPERAND_S6_1 :
1064 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, pc, & fields->f_s6_1);
1065 break;
1066 case FRV_OPERAND_SLO16 :
1067 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
1068 break;
1069 case FRV_OPERAND_SPR :
1070 {
1071 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_spr_h);
1072 if (length <= 0) break;
1073 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_spr_l);
1074 if (length <= 0) break;
1075{
1076 FLD (f_spr) = ((((FLD (f_spr_h)) << (6))) | (FLD (f_spr_l)));
1077}
1078 }
1079 break;
1080 case FRV_OPERAND_U12 :
1081 {
1082 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, pc, & fields->f_u12_h);
1083 if (length <= 0) break;
1084 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u12_l);
1085 if (length <= 0) break;
1086{
1087 FLD (f_u12) = ((((FLD (f_u12_h)) << (6))) | (FLD (f_u12_l)));
1088}
1089 }
1090 break;
1091 case FRV_OPERAND_U16 :
1092 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1093 break;
1094 case FRV_OPERAND_U6 :
1095 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u6);
1096 break;
1097 case FRV_OPERAND_UHI16 :
1098 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1099 break;
1100 case FRV_OPERAND_ULO16 :
1101 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1102 break;
1103
1104 default :
1105 /* xgettext:c-format */
1106 fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
1107 opindex);
1108 abort ();
1109 }
1110
1111 return length;
1112}
1113
1114cgen_insert_fn * const frv_cgen_insert_handlers[] =
1115{
1116 insert_insn_normal,
1117};
1118
1119cgen_extract_fn * const frv_cgen_extract_handlers[] =
1120{
1121 extract_insn_normal,
1122};
1123
1124int frv_cgen_get_int_operand
1125 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
1126bfd_vma frv_cgen_get_vma_operand
1127 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
1128
1129/* Getting values from cgen_fields is handled by a collection of functions.
1130 They are distinguished by the type of the VALUE argument they return.
1131 TODO: floating point, inlining support, remove cases where result type
1132 not appropriate. */
1133
1134int
1135frv_cgen_get_int_operand (cd, opindex, fields)
1136 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1137 int opindex;
1138 const CGEN_FIELDS * fields;
1139{
1140 int value;
1141
1142 switch (opindex)
1143 {
1144 case FRV_OPERAND_A :
1145 value = fields->f_A;
1146 break;
1147 case FRV_OPERAND_ACC40SI :
1148 value = fields->f_ACC40Si;
1149 break;
1150 case FRV_OPERAND_ACC40SK :
1151 value = fields->f_ACC40Sk;
1152 break;
1153 case FRV_OPERAND_ACC40UI :
1154 value = fields->f_ACC40Ui;
1155 break;
1156 case FRV_OPERAND_ACC40UK :
1157 value = fields->f_ACC40Uk;
1158 break;
1159 case FRV_OPERAND_ACCGI :
1160 value = fields->f_ACCGi;
1161 break;
1162 case FRV_OPERAND_ACCGK :
1163 value = fields->f_ACCGk;
1164 break;
1165 case FRV_OPERAND_CCI :
1166 value = fields->f_CCi;
1167 break;
1168 case FRV_OPERAND_CPRDOUBLEK :
1169 value = fields->f_CPRk;
1170 break;
1171 case FRV_OPERAND_CPRI :
1172 value = fields->f_CPRi;
1173 break;
1174 case FRV_OPERAND_CPRJ :
1175 value = fields->f_CPRj;
1176 break;
1177 case FRV_OPERAND_CPRK :
1178 value = fields->f_CPRk;
1179 break;
1180 case FRV_OPERAND_CRI :
1181 value = fields->f_CRi;
1182 break;
1183 case FRV_OPERAND_CRJ :
1184 value = fields->f_CRj;
1185 break;
1186 case FRV_OPERAND_CRJ_FLOAT :
1187 value = fields->f_CRj_float;
1188 break;
1189 case FRV_OPERAND_CRJ_INT :
1190 value = fields->f_CRj_int;
1191 break;
1192 case FRV_OPERAND_CRK :
1193 value = fields->f_CRk;
1194 break;
1195 case FRV_OPERAND_FCCI_1 :
1196 value = fields->f_FCCi_1;
1197 break;
1198 case FRV_OPERAND_FCCI_2 :
1199 value = fields->f_FCCi_2;
1200 break;
1201 case FRV_OPERAND_FCCI_3 :
1202 value = fields->f_FCCi_3;
1203 break;
1204 case FRV_OPERAND_FCCK :
1205 value = fields->f_FCCk;
1206 break;
1207 case FRV_OPERAND_FRDOUBLEI :
1208 value = fields->f_FRi;
1209 break;
1210 case FRV_OPERAND_FRDOUBLEJ :
1211 value = fields->f_FRj;
1212 break;
1213 case FRV_OPERAND_FRDOUBLEK :
1214 value = fields->f_FRk;
1215 break;
1216 case FRV_OPERAND_FRI :
1217 value = fields->f_FRi;
1218 break;
1219 case FRV_OPERAND_FRINTI :
1220 value = fields->f_FRi;
1221 break;
1222 case FRV_OPERAND_FRINTJ :
1223 value = fields->f_FRj;
1224 break;
1225 case FRV_OPERAND_FRINTK :
1226 value = fields->f_FRk;
1227 break;
1228 case FRV_OPERAND_FRJ :
1229 value = fields->f_FRj;
1230 break;
1231 case FRV_OPERAND_FRK :
1232 value = fields->f_FRk;
1233 break;
1234 case FRV_OPERAND_FRKHI :
1235 value = fields->f_FRk;
1236 break;
1237 case FRV_OPERAND_FRKLO :
1238 value = fields->f_FRk;
1239 break;
1240 case FRV_OPERAND_GRDOUBLEK :
1241 value = fields->f_GRk;
1242 break;
1243 case FRV_OPERAND_GRI :
1244 value = fields->f_GRi;
1245 break;
1246 case FRV_OPERAND_GRJ :
1247 value = fields->f_GRj;
1248 break;
1249 case FRV_OPERAND_GRK :
1250 value = fields->f_GRk;
1251 break;
1252 case FRV_OPERAND_GRKHI :
1253 value = fields->f_GRk;
1254 break;
1255 case FRV_OPERAND_GRKLO :
1256 value = fields->f_GRk;
1257 break;
1258 case FRV_OPERAND_ICCI_1 :
1259 value = fields->f_ICCi_1;
1260 break;
1261 case FRV_OPERAND_ICCI_2 :
1262 value = fields->f_ICCi_2;
1263 break;
1264 case FRV_OPERAND_ICCI_3 :
1265 value = fields->f_ICCi_3;
1266 break;
1267 case FRV_OPERAND_LI :
1268 value = fields->f_LI;
1269 break;
1270 case FRV_OPERAND_AE :
1271 value = fields->f_ae;
1272 break;
1273 case FRV_OPERAND_CCOND :
1274 value = fields->f_ccond;
1275 break;
1276 case FRV_OPERAND_COND :
1277 value = fields->f_cond;
1278 break;
1279 case FRV_OPERAND_D12 :
1280 value = fields->f_d12;
1281 break;
1282 case FRV_OPERAND_DEBUG :
1283 value = fields->f_debug;
1284 break;
1285 case FRV_OPERAND_EIR :
1286 value = fields->f_eir;
1287 break;
1288 case FRV_OPERAND_HINT :
1289 value = fields->f_hint;
1290 break;
1291 case FRV_OPERAND_HINT_NOT_TAKEN :
1292 value = fields->f_hint;
1293 break;
1294 case FRV_OPERAND_HINT_TAKEN :
1295 value = fields->f_hint;
1296 break;
1297 case FRV_OPERAND_LABEL16 :
1298 value = fields->f_label16;
1299 break;
1300 case FRV_OPERAND_LABEL24 :
1301 value = fields->f_label24;
1302 break;
1303 case FRV_OPERAND_LOCK :
1304 value = fields->f_lock;
1305 break;
1306 case FRV_OPERAND_PACK :
1307 value = fields->f_pack;
1308 break;
1309 case FRV_OPERAND_S10 :
1310 value = fields->f_s10;
1311 break;
1312 case FRV_OPERAND_S12 :
1313 value = fields->f_d12;
1314 break;
1315 case FRV_OPERAND_S16 :
1316 value = fields->f_s16;
1317 break;
1318 case FRV_OPERAND_S5 :
1319 value = fields->f_s5;
1320 break;
1321 case FRV_OPERAND_S6 :
1322 value = fields->f_s6;
1323 break;
1324 case FRV_OPERAND_S6_1 :
1325 value = fields->f_s6_1;
1326 break;
1327 case FRV_OPERAND_SLO16 :
1328 value = fields->f_s16;
1329 break;
1330 case FRV_OPERAND_SPR :
1331 value = fields->f_spr;
1332 break;
1333 case FRV_OPERAND_U12 :
1334 value = fields->f_u12;
1335 break;
1336 case FRV_OPERAND_U16 :
1337 value = fields->f_u16;
1338 break;
1339 case FRV_OPERAND_U6 :
1340 value = fields->f_u6;
1341 break;
1342 case FRV_OPERAND_UHI16 :
1343 value = fields->f_u16;
1344 break;
1345 case FRV_OPERAND_ULO16 :
1346 value = fields->f_u16;
1347 break;
1348
1349 default :
1350 /* xgettext:c-format */
1351 fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
1352 opindex);
1353 abort ();
1354 }
1355
1356 return value;
1357}
1358
1359bfd_vma
1360frv_cgen_get_vma_operand (cd, opindex, fields)
1361 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1362 int opindex;
1363 const CGEN_FIELDS * fields;
1364{
1365 bfd_vma value;
1366
1367 switch (opindex)
1368 {
1369 case FRV_OPERAND_A :
1370 value = fields->f_A;
1371 break;
1372 case FRV_OPERAND_ACC40SI :
1373 value = fields->f_ACC40Si;
1374 break;
1375 case FRV_OPERAND_ACC40SK :
1376 value = fields->f_ACC40Sk;
1377 break;
1378 case FRV_OPERAND_ACC40UI :
1379 value = fields->f_ACC40Ui;
1380 break;
1381 case FRV_OPERAND_ACC40UK :
1382 value = fields->f_ACC40Uk;
1383 break;
1384 case FRV_OPERAND_ACCGI :
1385 value = fields->f_ACCGi;
1386 break;
1387 case FRV_OPERAND_ACCGK :
1388 value = fields->f_ACCGk;
1389 break;
1390 case FRV_OPERAND_CCI :
1391 value = fields->f_CCi;
1392 break;
1393 case FRV_OPERAND_CPRDOUBLEK :
1394 value = fields->f_CPRk;
1395 break;
1396 case FRV_OPERAND_CPRI :
1397 value = fields->f_CPRi;
1398 break;
1399 case FRV_OPERAND_CPRJ :
1400 value = fields->f_CPRj;
1401 break;
1402 case FRV_OPERAND_CPRK :
1403 value = fields->f_CPRk;
1404 break;
1405 case FRV_OPERAND_CRI :
1406 value = fields->f_CRi;
1407 break;
1408 case FRV_OPERAND_CRJ :
1409 value = fields->f_CRj;
1410 break;
1411 case FRV_OPERAND_CRJ_FLOAT :
1412 value = fields->f_CRj_float;
1413 break;
1414 case FRV_OPERAND_CRJ_INT :
1415 value = fields->f_CRj_int;
1416 break;
1417 case FRV_OPERAND_CRK :
1418 value = fields->f_CRk;
1419 break;
1420 case FRV_OPERAND_FCCI_1 :
1421 value = fields->f_FCCi_1;
1422 break;
1423 case FRV_OPERAND_FCCI_2 :
1424 value = fields->f_FCCi_2;
1425 break;
1426 case FRV_OPERAND_FCCI_3 :
1427 value = fields->f_FCCi_3;
1428 break;
1429 case FRV_OPERAND_FCCK :
1430 value = fields->f_FCCk;
1431 break;
1432 case FRV_OPERAND_FRDOUBLEI :
1433 value = fields->f_FRi;
1434 break;
1435 case FRV_OPERAND_FRDOUBLEJ :
1436 value = fields->f_FRj;
1437 break;
1438 case FRV_OPERAND_FRDOUBLEK :
1439 value = fields->f_FRk;
1440 break;
1441 case FRV_OPERAND_FRI :
1442 value = fields->f_FRi;
1443 break;
1444 case FRV_OPERAND_FRINTI :
1445 value = fields->f_FRi;
1446 break;
1447 case FRV_OPERAND_FRINTJ :
1448 value = fields->f_FRj;
1449 break;
1450 case FRV_OPERAND_FRINTK :
1451 value = fields->f_FRk;
1452 break;
1453 case FRV_OPERAND_FRJ :
1454 value = fields->f_FRj;
1455 break;
1456 case FRV_OPERAND_FRK :
1457 value = fields->f_FRk;
1458 break;
1459 case FRV_OPERAND_FRKHI :
1460 value = fields->f_FRk;
1461 break;
1462 case FRV_OPERAND_FRKLO :
1463 value = fields->f_FRk;
1464 break;
1465 case FRV_OPERAND_GRDOUBLEK :
1466 value = fields->f_GRk;
1467 break;
1468 case FRV_OPERAND_GRI :
1469 value = fields->f_GRi;
1470 break;
1471 case FRV_OPERAND_GRJ :
1472 value = fields->f_GRj;
1473 break;
1474 case FRV_OPERAND_GRK :
1475 value = fields->f_GRk;
1476 break;
1477 case FRV_OPERAND_GRKHI :
1478 value = fields->f_GRk;
1479 break;
1480 case FRV_OPERAND_GRKLO :
1481 value = fields->f_GRk;
1482 break;
1483 case FRV_OPERAND_ICCI_1 :
1484 value = fields->f_ICCi_1;
1485 break;
1486 case FRV_OPERAND_ICCI_2 :
1487 value = fields->f_ICCi_2;
1488 break;
1489 case FRV_OPERAND_ICCI_3 :
1490 value = fields->f_ICCi_3;
1491 break;
1492 case FRV_OPERAND_LI :
1493 value = fields->f_LI;
1494 break;
1495 case FRV_OPERAND_AE :
1496 value = fields->f_ae;
1497 break;
1498 case FRV_OPERAND_CCOND :
1499 value = fields->f_ccond;
1500 break;
1501 case FRV_OPERAND_COND :
1502 value = fields->f_cond;
1503 break;
1504 case FRV_OPERAND_D12 :
1505 value = fields->f_d12;
1506 break;
1507 case FRV_OPERAND_DEBUG :
1508 value = fields->f_debug;
1509 break;
1510 case FRV_OPERAND_EIR :
1511 value = fields->f_eir;
1512 break;
1513 case FRV_OPERAND_HINT :
1514 value = fields->f_hint;
1515 break;
1516 case FRV_OPERAND_HINT_NOT_TAKEN :
1517 value = fields->f_hint;
1518 break;
1519 case FRV_OPERAND_HINT_TAKEN :
1520 value = fields->f_hint;
1521 break;
1522 case FRV_OPERAND_LABEL16 :
1523 value = fields->f_label16;
1524 break;
1525 case FRV_OPERAND_LABEL24 :
1526 value = fields->f_label24;
1527 break;
1528 case FRV_OPERAND_LOCK :
1529 value = fields->f_lock;
1530 break;
1531 case FRV_OPERAND_PACK :
1532 value = fields->f_pack;
1533 break;
1534 case FRV_OPERAND_S10 :
1535 value = fields->f_s10;
1536 break;
1537 case FRV_OPERAND_S12 :
1538 value = fields->f_d12;
1539 break;
1540 case FRV_OPERAND_S16 :
1541 value = fields->f_s16;
1542 break;
1543 case FRV_OPERAND_S5 :
1544 value = fields->f_s5;
1545 break;
1546 case FRV_OPERAND_S6 :
1547 value = fields->f_s6;
1548 break;
1549 case FRV_OPERAND_S6_1 :
1550 value = fields->f_s6_1;
1551 break;
1552 case FRV_OPERAND_SLO16 :
1553 value = fields->f_s16;
1554 break;
1555 case FRV_OPERAND_SPR :
1556 value = fields->f_spr;
1557 break;
1558 case FRV_OPERAND_U12 :
1559 value = fields->f_u12;
1560 break;
1561 case FRV_OPERAND_U16 :
1562 value = fields->f_u16;
1563 break;
1564 case FRV_OPERAND_U6 :
1565 value = fields->f_u6;
1566 break;
1567 case FRV_OPERAND_UHI16 :
1568 value = fields->f_u16;
1569 break;
1570 case FRV_OPERAND_ULO16 :
1571 value = fields->f_u16;
1572 break;
1573
1574 default :
1575 /* xgettext:c-format */
1576 fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
1577 opindex);
1578 abort ();
1579 }
1580
1581 return value;
1582}
1583
1584void frv_cgen_set_int_operand
1585 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int));
1586void frv_cgen_set_vma_operand
1587 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma));
1588
1589/* Stuffing values in cgen_fields is handled by a collection of functions.
1590 They are distinguished by the type of the VALUE argument they accept.
1591 TODO: floating point, inlining support, remove cases where argument type
1592 not appropriate. */
1593
1594void
1595frv_cgen_set_int_operand (cd, opindex, fields, value)
1596 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1597 int opindex;
1598 CGEN_FIELDS * fields;
1599 int value;
1600{
1601 switch (opindex)
1602 {
1603 case FRV_OPERAND_A :
1604 fields->f_A = value;
1605 break;
1606 case FRV_OPERAND_ACC40SI :
1607 fields->f_ACC40Si = value;
1608 break;
1609 case FRV_OPERAND_ACC40SK :
1610 fields->f_ACC40Sk = value;
1611 break;
1612 case FRV_OPERAND_ACC40UI :
1613 fields->f_ACC40Ui = value;
1614 break;
1615 case FRV_OPERAND_ACC40UK :
1616 fields->f_ACC40Uk = value;
1617 break;
1618 case FRV_OPERAND_ACCGI :
1619 fields->f_ACCGi = value;
1620 break;
1621 case FRV_OPERAND_ACCGK :
1622 fields->f_ACCGk = value;
1623 break;
1624 case FRV_OPERAND_CCI :
1625 fields->f_CCi = value;
1626 break;
1627 case FRV_OPERAND_CPRDOUBLEK :
1628 fields->f_CPRk = value;
1629 break;
1630 case FRV_OPERAND_CPRI :
1631 fields->f_CPRi = value;
1632 break;
1633 case FRV_OPERAND_CPRJ :
1634 fields->f_CPRj = value;
1635 break;
1636 case FRV_OPERAND_CPRK :
1637 fields->f_CPRk = value;
1638 break;
1639 case FRV_OPERAND_CRI :
1640 fields->f_CRi = value;
1641 break;
1642 case FRV_OPERAND_CRJ :
1643 fields->f_CRj = value;
1644 break;
1645 case FRV_OPERAND_CRJ_FLOAT :
1646 fields->f_CRj_float = value;
1647 break;
1648 case FRV_OPERAND_CRJ_INT :
1649 fields->f_CRj_int = value;
1650 break;
1651 case FRV_OPERAND_CRK :
1652 fields->f_CRk = value;
1653 break;
1654 case FRV_OPERAND_FCCI_1 :
1655 fields->f_FCCi_1 = value;
1656 break;
1657 case FRV_OPERAND_FCCI_2 :
1658 fields->f_FCCi_2 = value;
1659 break;
1660 case FRV_OPERAND_FCCI_3 :
1661 fields->f_FCCi_3 = value;
1662 break;
1663 case FRV_OPERAND_FCCK :
1664 fields->f_FCCk = value;
1665 break;
1666 case FRV_OPERAND_FRDOUBLEI :
1667 fields->f_FRi = value;
1668 break;
1669 case FRV_OPERAND_FRDOUBLEJ :
1670 fields->f_FRj = value;
1671 break;
1672 case FRV_OPERAND_FRDOUBLEK :
1673 fields->f_FRk = value;
1674 break;
1675 case FRV_OPERAND_FRI :
1676 fields->f_FRi = value;
1677 break;
1678 case FRV_OPERAND_FRINTI :
1679 fields->f_FRi = value;
1680 break;
1681 case FRV_OPERAND_FRINTJ :
1682 fields->f_FRj = value;
1683 break;
1684 case FRV_OPERAND_FRINTK :
1685 fields->f_FRk = value;
1686 break;
1687 case FRV_OPERAND_FRJ :
1688 fields->f_FRj = value;
1689 break;
1690 case FRV_OPERAND_FRK :
1691 fields->f_FRk = value;
1692 break;
1693 case FRV_OPERAND_FRKHI :
1694 fields->f_FRk = value;
1695 break;
1696 case FRV_OPERAND_FRKLO :
1697 fields->f_FRk = value;
1698 break;
1699 case FRV_OPERAND_GRDOUBLEK :
1700 fields->f_GRk = value;
1701 break;
1702 case FRV_OPERAND_GRI :
1703 fields->f_GRi = value;
1704 break;
1705 case FRV_OPERAND_GRJ :
1706 fields->f_GRj = value;
1707 break;
1708 case FRV_OPERAND_GRK :
1709 fields->f_GRk = value;
1710 break;
1711 case FRV_OPERAND_GRKHI :
1712 fields->f_GRk = value;
1713 break;
1714 case FRV_OPERAND_GRKLO :
1715 fields->f_GRk = value;
1716 break;
1717 case FRV_OPERAND_ICCI_1 :
1718 fields->f_ICCi_1 = value;
1719 break;
1720 case FRV_OPERAND_ICCI_2 :
1721 fields->f_ICCi_2 = value;
1722 break;
1723 case FRV_OPERAND_ICCI_3 :
1724 fields->f_ICCi_3 = value;
1725 break;
1726 case FRV_OPERAND_LI :
1727 fields->f_LI = value;
1728 break;
1729 case FRV_OPERAND_AE :
1730 fields->f_ae = value;
1731 break;
1732 case FRV_OPERAND_CCOND :
1733 fields->f_ccond = value;
1734 break;
1735 case FRV_OPERAND_COND :
1736 fields->f_cond = value;
1737 break;
1738 case FRV_OPERAND_D12 :
1739 fields->f_d12 = value;
1740 break;
1741 case FRV_OPERAND_DEBUG :
1742 fields->f_debug = value;
1743 break;
1744 case FRV_OPERAND_EIR :
1745 fields->f_eir = value;
1746 break;
1747 case FRV_OPERAND_HINT :
1748 fields->f_hint = value;
1749 break;
1750 case FRV_OPERAND_HINT_NOT_TAKEN :
1751 fields->f_hint = value;
1752 break;
1753 case FRV_OPERAND_HINT_TAKEN :
1754 fields->f_hint = value;
1755 break;
1756 case FRV_OPERAND_LABEL16 :
1757 fields->f_label16 = value;
1758 break;
1759 case FRV_OPERAND_LABEL24 :
1760 fields->f_label24 = value;
1761 break;
1762 case FRV_OPERAND_LOCK :
1763 fields->f_lock = value;
1764 break;
1765 case FRV_OPERAND_PACK :
1766 fields->f_pack = value;
1767 break;
1768 case FRV_OPERAND_S10 :
1769 fields->f_s10 = value;
1770 break;
1771 case FRV_OPERAND_S12 :
1772 fields->f_d12 = value;
1773 break;
1774 case FRV_OPERAND_S16 :
1775 fields->f_s16 = value;
1776 break;
1777 case FRV_OPERAND_S5 :
1778 fields->f_s5 = value;
1779 break;
1780 case FRV_OPERAND_S6 :
1781 fields->f_s6 = value;
1782 break;
1783 case FRV_OPERAND_S6_1 :
1784 fields->f_s6_1 = value;
1785 break;
1786 case FRV_OPERAND_SLO16 :
1787 fields->f_s16 = value;
1788 break;
1789 case FRV_OPERAND_SPR :
1790 fields->f_spr = value;
1791 break;
1792 case FRV_OPERAND_U12 :
1793 fields->f_u12 = value;
1794 break;
1795 case FRV_OPERAND_U16 :
1796 fields->f_u16 = value;
1797 break;
1798 case FRV_OPERAND_U6 :
1799 fields->f_u6 = value;
1800 break;
1801 case FRV_OPERAND_UHI16 :
1802 fields->f_u16 = value;
1803 break;
1804 case FRV_OPERAND_ULO16 :
1805 fields->f_u16 = value;
1806 break;
1807
1808 default :
1809 /* xgettext:c-format */
1810 fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
1811 opindex);
1812 abort ();
1813 }
1814}
1815
1816void
1817frv_cgen_set_vma_operand (cd, opindex, fields, value)
1818 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1819 int opindex;
1820 CGEN_FIELDS * fields;
1821 bfd_vma value;
1822{
1823 switch (opindex)
1824 {
1825 case FRV_OPERAND_A :
1826 fields->f_A = value;
1827 break;
1828 case FRV_OPERAND_ACC40SI :
1829 fields->f_ACC40Si = value;
1830 break;
1831 case FRV_OPERAND_ACC40SK :
1832 fields->f_ACC40Sk = value;
1833 break;
1834 case FRV_OPERAND_ACC40UI :
1835 fields->f_ACC40Ui = value;
1836 break;
1837 case FRV_OPERAND_ACC40UK :
1838 fields->f_ACC40Uk = value;
1839 break;
1840 case FRV_OPERAND_ACCGI :
1841 fields->f_ACCGi = value;
1842 break;
1843 case FRV_OPERAND_ACCGK :
1844 fields->f_ACCGk = value;
1845 break;
1846 case FRV_OPERAND_CCI :
1847 fields->f_CCi = value;
1848 break;
1849 case FRV_OPERAND_CPRDOUBLEK :
1850 fields->f_CPRk = value;
1851 break;
1852 case FRV_OPERAND_CPRI :
1853 fields->f_CPRi = value;
1854 break;
1855 case FRV_OPERAND_CPRJ :
1856 fields->f_CPRj = value;
1857 break;
1858 case FRV_OPERAND_CPRK :
1859 fields->f_CPRk = value;
1860 break;
1861 case FRV_OPERAND_CRI :
1862 fields->f_CRi = value;
1863 break;
1864 case FRV_OPERAND_CRJ :
1865 fields->f_CRj = value;
1866 break;
1867 case FRV_OPERAND_CRJ_FLOAT :
1868 fields->f_CRj_float = value;
1869 break;
1870 case FRV_OPERAND_CRJ_INT :
1871 fields->f_CRj_int = value;
1872 break;
1873 case FRV_OPERAND_CRK :
1874 fields->f_CRk = value;
1875 break;
1876 case FRV_OPERAND_FCCI_1 :
1877 fields->f_FCCi_1 = value;
1878 break;
1879 case FRV_OPERAND_FCCI_2 :
1880 fields->f_FCCi_2 = value;
1881 break;
1882 case FRV_OPERAND_FCCI_3 :
1883 fields->f_FCCi_3 = value;
1884 break;
1885 case FRV_OPERAND_FCCK :
1886 fields->f_FCCk = value;
1887 break;
1888 case FRV_OPERAND_FRDOUBLEI :
1889 fields->f_FRi = value;
1890 break;
1891 case FRV_OPERAND_FRDOUBLEJ :
1892 fields->f_FRj = value;
1893 break;
1894 case FRV_OPERAND_FRDOUBLEK :
1895 fields->f_FRk = value;
1896 break;
1897 case FRV_OPERAND_FRI :
1898 fields->f_FRi = value;
1899 break;
1900 case FRV_OPERAND_FRINTI :
1901 fields->f_FRi = value;
1902 break;
1903 case FRV_OPERAND_FRINTJ :
1904 fields->f_FRj = value;
1905 break;
1906 case FRV_OPERAND_FRINTK :
1907 fields->f_FRk = value;
1908 break;
1909 case FRV_OPERAND_FRJ :
1910 fields->f_FRj = value;
1911 break;
1912 case FRV_OPERAND_FRK :
1913 fields->f_FRk = value;
1914 break;
1915 case FRV_OPERAND_FRKHI :
1916 fields->f_FRk = value;
1917 break;
1918 case FRV_OPERAND_FRKLO :
1919 fields->f_FRk = value;
1920 break;
1921 case FRV_OPERAND_GRDOUBLEK :
1922 fields->f_GRk = value;
1923 break;
1924 case FRV_OPERAND_GRI :
1925 fields->f_GRi = value;
1926 break;
1927 case FRV_OPERAND_GRJ :
1928 fields->f_GRj = value;
1929 break;
1930 case FRV_OPERAND_GRK :
1931 fields->f_GRk = value;
1932 break;
1933 case FRV_OPERAND_GRKHI :
1934 fields->f_GRk = value;
1935 break;
1936 case FRV_OPERAND_GRKLO :
1937 fields->f_GRk = value;
1938 break;
1939 case FRV_OPERAND_ICCI_1 :
1940 fields->f_ICCi_1 = value;
1941 break;
1942 case FRV_OPERAND_ICCI_2 :
1943 fields->f_ICCi_2 = value;
1944 break;
1945 case FRV_OPERAND_ICCI_3 :
1946 fields->f_ICCi_3 = value;
1947 break;
1948 case FRV_OPERAND_LI :
1949 fields->f_LI = value;
1950 break;
1951 case FRV_OPERAND_AE :
1952 fields->f_ae = value;
1953 break;
1954 case FRV_OPERAND_CCOND :
1955 fields->f_ccond = value;
1956 break;
1957 case FRV_OPERAND_COND :
1958 fields->f_cond = value;
1959 break;
1960 case FRV_OPERAND_D12 :
1961 fields->f_d12 = value;
1962 break;
1963 case FRV_OPERAND_DEBUG :
1964 fields->f_debug = value;
1965 break;
1966 case FRV_OPERAND_EIR :
1967 fields->f_eir = value;
1968 break;
1969 case FRV_OPERAND_HINT :
1970 fields->f_hint = value;
1971 break;
1972 case FRV_OPERAND_HINT_NOT_TAKEN :
1973 fields->f_hint = value;
1974 break;
1975 case FRV_OPERAND_HINT_TAKEN :
1976 fields->f_hint = value;
1977 break;
1978 case FRV_OPERAND_LABEL16 :
1979 fields->f_label16 = value;
1980 break;
1981 case FRV_OPERAND_LABEL24 :
1982 fields->f_label24 = value;
1983 break;
1984 case FRV_OPERAND_LOCK :
1985 fields->f_lock = value;
1986 break;
1987 case FRV_OPERAND_PACK :
1988 fields->f_pack = value;
1989 break;
1990 case FRV_OPERAND_S10 :
1991 fields->f_s10 = value;
1992 break;
1993 case FRV_OPERAND_S12 :
1994 fields->f_d12 = value;
1995 break;
1996 case FRV_OPERAND_S16 :
1997 fields->f_s16 = value;
1998 break;
1999 case FRV_OPERAND_S5 :
2000 fields->f_s5 = value;
2001 break;
2002 case FRV_OPERAND_S6 :
2003 fields->f_s6 = value;
2004 break;
2005 case FRV_OPERAND_S6_1 :
2006 fields->f_s6_1 = value;
2007 break;
2008 case FRV_OPERAND_SLO16 :
2009 fields->f_s16 = value;
2010 break;
2011 case FRV_OPERAND_SPR :
2012 fields->f_spr = value;
2013 break;
2014 case FRV_OPERAND_U12 :
2015 fields->f_u12 = value;
2016 break;
2017 case FRV_OPERAND_U16 :
2018 fields->f_u16 = value;
2019 break;
2020 case FRV_OPERAND_U6 :
2021 fields->f_u6 = value;
2022 break;
2023 case FRV_OPERAND_UHI16 :
2024 fields->f_u16 = value;
2025 break;
2026 case FRV_OPERAND_ULO16 :
2027 fields->f_u16 = value;
2028 break;
2029
2030 default :
2031 /* xgettext:c-format */
2032 fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
2033 opindex);
2034 abort ();
2035 }
2036}
2037
2038/* Function to call before using the instruction builder tables. */
2039
2040void
2041frv_cgen_init_ibld_table (cd)
2042 CGEN_CPU_DESC cd;
2043{
2044 cd->insert_handlers = & frv_cgen_insert_handlers[0];
2045 cd->extract_handlers = & frv_cgen_extract_handlers[0];
2046
2047 cd->insert_operand = frv_cgen_insert_operand;
2048 cd->extract_operand = frv_cgen_extract_operand;
2049
2050 cd->get_int_operand = frv_cgen_get_int_operand;
2051 cd->set_int_operand = frv_cgen_set_int_operand;
2052 cd->get_vma_operand = frv_cgen_get_vma_operand;
2053 cd->set_vma_operand = frv_cgen_set_vma_operand;
2054}
Note: See TracBrowser for help on using the repository browser.