?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed bash/dash/sh issue (Ubuntu)
[zpugcc/jano.git] / toolchain / binutils / opcodes / frv-ibld.c
blob565f4f49a0ed2c2415c341a415eceb304c066dfa
1 /* Instruction building/extraction support for frv. -*- 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 Free Software Foundation, Inc.
7
8 This file is part of the GNU Binutils and GDB, the GNU debugger.
9
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.
14
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.
19
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. */
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
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
71 \f
72 /* Operand insertion. */
73
74 #if ! CGEN_INT_INSN_P
75
76 /* Subroutine of insert_normal. */
77
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)
85 {
86 unsigned long x,mask;
87 int shift;
88
89 x = cgen_get_insn_value (cd, bufp, word_length);
90
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);
98
99 cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x);
100 }
101
102 #endif /* ! CGEN_INT_INSN_P */
103
104 /* Default insertion routine.
105
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.
112
113 The result is an error message or NULL if success. */
114
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. */
119
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)
130 {
131 static char errbuf[100];
132 /* Written this way to avoid undefined behaviour. */
133 unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
134
135 /* If LENGTH is zero, this operand doesn't contribute to the value. */
136 if (length == 0)
137 return NULL;
138
139 #if 0
140 if (CGEN_INT_INSN_P
141 && word_offset != 0)
142 abort ();
143 #endif
144
145 if (word_length > 32)
146 abort ();
147
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)
151 {
152 if (word_offset == 0
153 && word_length > total_length)
154 word_length = total_length;
155 }
156
157 /* Ensure VALUE will fit. */
158 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
159 {
160 long minval = - (1L << (length - 1));
161 unsigned long maxval = mask;
162
163 if ((value > 0 && (unsigned long) value > maxval)
164 || value < minval)
165 {
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;
171 }
172 }
173 else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
174 {
175 unsigned long maxval = mask;
176
177 if ((unsigned long) value > maxval)
178 {
179 /* xgettext:c-format */
180 sprintf (errbuf,
181 _("operand out of range (%lu not between 0 and %lu)"),
182 value, maxval);
183 return errbuf;
184 }
185 }
186 else
187 {
188 if (! cgen_signed_overflow_ok_p (cd))
189 {
190 long minval = - (1L << (length - 1));
191 long maxval = (1L << (length - 1)) - 1;
192
193 if (value < minval || value > maxval)
194 {
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;
200 }
201 }
202 }
203
204 #if CGEN_INT_INSN_P
205
206 {
207 int shift;
208
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);
214 }
215
216 #else /* ! CGEN_INT_INSN_P */
217
218 {
219 unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
220
221 insert_1 (cd, value, start, length, word_length, bufp);
222 }
223
224 #endif /* ! CGEN_INT_INSN_P */
225
226 return NULL;
227 }
228
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. */
235
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)
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
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)
297 {
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
303 {
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);
308 }
309 }
310 #endif
311 \f
312 /* Operand extraction. */
313
314 #if ! CGEN_INT_INSN_P
315
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. */
321
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)
328 {
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;
333
334 /* First do a quick check. */
335 mask = (1 << bytes) - 1;
336 if (((ex_info->valid >> offset) & mask) == mask)
337 return 1;
338
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;
343
344 if (bytes)
345 {
346 int status;
347
348 pc += offset;
349 status = (*info->read_memory_func)
350 (pc, ex_info->insn_bytes + offset, bytes, info);
351
352 if (status != 0)
353 {
354 (*info->memory_error_func) (status, pc, info);
355 return 0;
356 }
357
358 ex_info->valid |= ((1 << bytes) - 1) << offset;
359 }
360
361 return 1;
362 }
363
364 /* Subroutine of extract_normal. */
365
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)
374 {
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);
381
382 if (CGEN_INSN_LSB0_P)
383 shift = (start + 1) - length;
384 else
385 shift = (word_length - (start + length));
386 return x >> shift;
387 }
388
389 #endif /* ! CGEN_INT_INSN_P */
390
391 /* Default extraction routine.
392
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.
403
404 Returns 1 for success, 0 for failure. */
405
406 /* ??? The return code isn't properly used. wip. */
407
408 /* ??? This doesn't handle bfd_vma's. Create another function when
409 necessary. */
410
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)
431 {
432 long value, mask;
433
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)
437 {
438 *valuep = 0;
439 return 1;
440 }
441
442 #if 0
443 if (CGEN_INT_INSN_P
444 && word_offset != 0)
445 abort ();
446 #endif
447
448 if (word_length > 32)
449 abort ();
450
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)
454 {
455 if (word_offset == 0
456 && word_length > total_length)
457 word_length = total_length;
458 }
459
460 /* Does the value reside in INSN_VALUE, and at the right alignment? */
461
462 if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
463 {
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));
468 }
469
470 #if ! CGEN_INT_INSN_P
471
472 else
473 {
474 unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
475
476 if (word_length > 32)
477 abort ();
478
479 if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
480 return 0;
481
482 value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
483 }
484
485 #endif /* ! CGEN_INT_INSN_P */
486
487 /* Written this way to avoid undefined behaviour. */
488 mask = (((1L << (length - 1)) - 1) << 1) | 1;
489
490 value &= mask;
491 /* sign extend? */
492 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
493 && (value & (1L << (length - 1))))
494 value |= ~mask;
495
496 *valuep = value;
497
498 return 1;
499 }
500
501 /* Default insn extractor.
502
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). */
509
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)
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 \f
542 /* machine generated code added here */
543
544 const char * frv_cgen_insert_operand
545 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
546
547 /* Main entry point for operand insertion.
548
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.
555
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. */
560
561 const char *
562 frv_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;
568 {
569 const char * errmsg = NULL;
570 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
571
572 switch (opindex)
573 {
574 case FRV_OPERAND_A0 :
575 errmsg = insert_normal (cd, fields->f_A, 0, 0, 17, 1, 32, total_length, buffer);
576 break;
577 case FRV_OPERAND_A1 :
578 errmsg = insert_normal (cd, fields->f_A, 0, 0, 17, 1, 32, total_length, buffer);
579 break;
580 case FRV_OPERAND_ACC40SI :
581 errmsg = insert_normal (cd, fields->f_ACC40Si, 0, 0, 17, 6, 32, total_length, buffer);
582 break;
583 case FRV_OPERAND_ACC40SK :
584 errmsg = insert_normal (cd, fields->f_ACC40Sk, 0, 0, 30, 6, 32, total_length, buffer);
585 break;
586 case FRV_OPERAND_ACC40UI :
587 errmsg = insert_normal (cd, fields->f_ACC40Ui, 0, 0, 17, 6, 32, total_length, buffer);
588 break;
589 case FRV_OPERAND_ACC40UK :
590 errmsg = insert_normal (cd, fields->f_ACC40Uk, 0, 0, 30, 6, 32, total_length, buffer);
591 break;
592 case FRV_OPERAND_ACCGI :
593 errmsg = insert_normal (cd, fields->f_ACCGi, 0, 0, 17, 6, 32, total_length, buffer);
594 break;
595 case FRV_OPERAND_ACCGK :
596 errmsg = insert_normal (cd, fields->f_ACCGk, 0, 0, 30, 6, 32, total_length, buffer);
597 break;
598 case FRV_OPERAND_CCI :
599 errmsg = insert_normal (cd, fields->f_CCi, 0, 0, 11, 3, 32, total_length, buffer);
600 break;
601 case FRV_OPERAND_CPRDOUBLEK :
602 errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
603 break;
604 case FRV_OPERAND_CPRI :
605 errmsg = insert_normal (cd, fields->f_CPRi, 0, 0, 17, 6, 32, total_length, buffer);
606 break;
607 case FRV_OPERAND_CPRJ :
608 errmsg = insert_normal (cd, fields->f_CPRj, 0, 0, 5, 6, 32, total_length, buffer);
609 break;
610 case FRV_OPERAND_CPRK :
611 errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer);
612 break;
613 case FRV_OPERAND_CRI :
614 errmsg = insert_normal (cd, fields->f_CRi, 0, 0, 14, 3, 32, total_length, buffer);
615 break;
616 case FRV_OPERAND_CRJ :
617 errmsg = insert_normal (cd, fields->f_CRj, 0, 0, 2, 3, 32, total_length, buffer);
618 break;
619 case FRV_OPERAND_CRJ_FLOAT :
620 errmsg = insert_normal (cd, fields->f_CRj_float, 0, 0, 26, 2, 32, total_length, buffer);
621 break;
622 case FRV_OPERAND_CRJ_INT :
623 {
624 long value = fields->f_CRj_int;
625 value = ((value) - (4));
626 errmsg = insert_normal (cd, value, 0, 0, 26, 2, 32, total_length, buffer);
627 }
628 break;
629 case FRV_OPERAND_CRK :
630 errmsg = insert_normal (cd, fields->f_CRk, 0, 0, 27, 3, 32, total_length, buffer);
631 break;
632 case FRV_OPERAND_FCCI_1 :
633 errmsg = insert_normal (cd, fields->f_FCCi_1, 0, 0, 11, 2, 32, total_length, buffer);
634 break;
635 case FRV_OPERAND_FCCI_2 :
636 errmsg = insert_normal (cd, fields->f_FCCi_2, 0, 0, 26, 2, 32, total_length, buffer);
637 break;
638 case FRV_OPERAND_FCCI_3 :
639 errmsg = insert_normal (cd, fields->f_FCCi_3, 0, 0, 1, 2, 32, total_length, buffer);
640 break;
641 case FRV_OPERAND_FCCK :
642 errmsg = insert_normal (cd, fields->f_FCCk, 0, 0, 26, 2, 32, total_length, buffer);
643 break;
644 case FRV_OPERAND_FRDOUBLEI :
645 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
646 break;
647 case FRV_OPERAND_FRDOUBLEJ :
648 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
649 break;
650 case FRV_OPERAND_FRDOUBLEK :
651 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
652 break;
653 case FRV_OPERAND_FRI :
654 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
655 break;
656 case FRV_OPERAND_FRINTI :
657 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
658 break;
659 case FRV_OPERAND_FRINTIEVEN :
660 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer);
661 break;
662 case FRV_OPERAND_FRINTJ :
663 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
664 break;
665 case FRV_OPERAND_FRINTJEVEN :
666 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
667 break;
668 case FRV_OPERAND_FRINTK :
669 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
670 break;
671 case FRV_OPERAND_FRINTKEVEN :
672 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
673 break;
674 case FRV_OPERAND_FRJ :
675 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer);
676 break;
677 case FRV_OPERAND_FRK :
678 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
679 break;
680 case FRV_OPERAND_FRKHI :
681 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
682 break;
683 case FRV_OPERAND_FRKLO :
684 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer);
685 break;
686 case FRV_OPERAND_GRDOUBLEK :
687 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
688 break;
689 case FRV_OPERAND_GRI :
690 errmsg = insert_normal (cd, fields->f_GRi, 0, 0, 17, 6, 32, total_length, buffer);
691 break;
692 case FRV_OPERAND_GRJ :
693 errmsg = insert_normal (cd, fields->f_GRj, 0, 0, 5, 6, 32, total_length, buffer);
694 break;
695 case FRV_OPERAND_GRK :
696 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
697 break;
698 case FRV_OPERAND_GRKHI :
699 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
700 break;
701 case FRV_OPERAND_GRKLO :
702 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer);
703 break;
704 case FRV_OPERAND_ICCI_1 :
705 errmsg = insert_normal (cd, fields->f_ICCi_1, 0, 0, 11, 2, 32, total_length, buffer);
706 break;
707 case FRV_OPERAND_ICCI_2 :
708 errmsg = insert_normal (cd, fields->f_ICCi_2, 0, 0, 26, 2, 32, total_length, buffer);
709 break;
710 case FRV_OPERAND_ICCI_3 :
711 errmsg = insert_normal (cd, fields->f_ICCi_3, 0, 0, 1, 2, 32, total_length, buffer);
712 break;
713 case FRV_OPERAND_LI :
714 errmsg = insert_normal (cd, fields->f_LI, 0, 0, 25, 1, 32, total_length, buffer);
715 break;
716 case FRV_OPERAND_AE :
717 errmsg = insert_normal (cd, fields->f_ae, 0, 0, 25, 1, 32, total_length, buffer);
718 break;
719 case FRV_OPERAND_CCOND :
720 errmsg = insert_normal (cd, fields->f_ccond, 0, 0, 12, 1, 32, total_length, buffer);
721 break;
722 case FRV_OPERAND_COND :
723 errmsg = insert_normal (cd, fields->f_cond, 0, 0, 8, 1, 32, total_length, buffer);
724 break;
725 case FRV_OPERAND_D12 :
726 errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
727 break;
728 case FRV_OPERAND_DEBUG :
729 errmsg = insert_normal (cd, fields->f_debug, 0, 0, 25, 1, 32, total_length, buffer);
730 break;
731 case FRV_OPERAND_EIR :
732 errmsg = insert_normal (cd, fields->f_eir, 0, 0, 17, 6, 32, total_length, buffer);
733 break;
734 case FRV_OPERAND_HINT :
735 errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
736 break;
737 case FRV_OPERAND_HINT_NOT_TAKEN :
738 errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
739 break;
740 case FRV_OPERAND_HINT_TAKEN :
741 errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer);
742 break;
743 case FRV_OPERAND_LABEL16 :
744 {
745 long value = fields->f_label16;
746 value = ((int) (((value) - (pc))) >> (2));
747 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, buffer);
748 }
749 break;
750 case FRV_OPERAND_LABEL24 :
751 {
752 {
753 FLD (f_labelH6) = ((int) (((FLD (f_label24)) - (pc))) >> (20));
754 FLD (f_labelL18) = ((((unsigned int) (((FLD (f_label24)) - (pc))) >> (2))) & (262143));
755 }
756 errmsg = insert_normal (cd, fields->f_labelH6, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, buffer);
757 if (errmsg)
758 break;
759 errmsg = insert_normal (cd, fields->f_labelL18, 0, 0, 17, 18, 32, total_length, buffer);
760 if (errmsg)
761 break;
762 }
763 break;
764 case FRV_OPERAND_LOCK :
765 errmsg = insert_normal (cd, fields->f_lock, 0, 0, 25, 1, 32, total_length, buffer);
766 break;
767 case FRV_OPERAND_PACK :
768 errmsg = insert_normal (cd, fields->f_pack, 0, 0, 31, 1, 32, total_length, buffer);
769 break;
770 case FRV_OPERAND_S10 :
771 errmsg = insert_normal (cd, fields->f_s10, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, buffer);
772 break;
773 case FRV_OPERAND_S12 :
774 errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer);
775 break;
776 case FRV_OPERAND_S16 :
777 errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
778 break;
779 case FRV_OPERAND_S5 :
780 errmsg = insert_normal (cd, fields->f_s5, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, buffer);
781 break;
782 case FRV_OPERAND_S6 :
783 errmsg = insert_normal (cd, fields->f_s6, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, buffer);
784 break;
785 case FRV_OPERAND_S6_1 :
786 errmsg = insert_normal (cd, fields->f_s6_1, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, buffer);
787 break;
788 case FRV_OPERAND_SLO16 :
789 errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer);
790 break;
791 case FRV_OPERAND_SPR :
792 {
793 {
794 FLD (f_spr_h) = ((unsigned int) (FLD (f_spr)) >> (6));
795 FLD (f_spr_l) = ((FLD (f_spr)) & (63));
796 }
797 errmsg = insert_normal (cd, fields->f_spr_h, 0, 0, 30, 6, 32, total_length, buffer);
798 if (errmsg)
799 break;
800 errmsg = insert_normal (cd, fields->f_spr_l, 0, 0, 17, 6, 32, total_length, buffer);
801 if (errmsg)
802 break;
803 }
804 break;
805 case FRV_OPERAND_U12 :
806 {
807 {
808 FLD (f_u12_h) = ((int) (FLD (f_u12)) >> (6));
809 FLD (f_u12_l) = ((FLD (f_u12)) & (63));
810 }
811 errmsg = insert_normal (cd, fields->f_u12_h, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, buffer);
812 if (errmsg)
813 break;
814 errmsg = insert_normal (cd, fields->f_u12_l, 0, 0, 5, 6, 32, total_length, buffer);
815 if (errmsg)
816 break;
817 }
818 break;
819 case FRV_OPERAND_U16 :
820 errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
821 break;
822 case FRV_OPERAND_U6 :
823 errmsg = insert_normal (cd, fields->f_u6, 0, 0, 5, 6, 32, total_length, buffer);
824 break;
825 case FRV_OPERAND_UHI16 :
826 errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
827 break;
828 case FRV_OPERAND_ULO16 :
829 errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer);
830 break;
831
832 default :
833 /* xgettext:c-format */
834 fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
835 opindex);
836 abort ();
837 }
838
839 return errmsg;
840 }
841
842 int frv_cgen_extract_operand
843 PARAMS ((CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
844 CGEN_FIELDS *, bfd_vma));
845
846 /* Main entry point for operand extraction.
847 The result is <= 0 for error, >0 for success.
848 ??? Actual values aren't well defined right now.
849
850 This function is basically just a big switch statement. Earlier versions
851 used tables to look up the function to use, but
852 - if the table contains both assembler and disassembler functions then
853 the disassembler contains much of the assembler and vice-versa,
854 - there's a lot of inlining possibilities as things grow,
855 - using a switch statement avoids the function call overhead.
856
857 This function could be moved into `print_insn_normal', but keeping it
858 separate makes clear the interface between `print_insn_normal' and each of
859 the handlers. */
860
861 int
862 frv_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
863 CGEN_CPU_DESC cd;
864 int opindex;
865 CGEN_EXTRACT_INFO *ex_info;
866 CGEN_INSN_INT insn_value;
867 CGEN_FIELDS * fields;
868 bfd_vma pc;
869 {
870 /* Assume success (for those operands that are nops). */
871 int length = 1;
872 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
873
874 switch (opindex)
875 {
876 case FRV_OPERAND_A0 :
877 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 1, 32, total_length, pc, & fields->f_A);
878 break;
879 case FRV_OPERAND_A1 :
880 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 1, 32, total_length, pc, & fields->f_A);
881 break;
882 case FRV_OPERAND_ACC40SI :
883 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Si);
884 break;
885 case FRV_OPERAND_ACC40SK :
886 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Sk);
887 break;
888 case FRV_OPERAND_ACC40UI :
889 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Ui);
890 break;
891 case FRV_OPERAND_ACC40UK :
892 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Uk);
893 break;
894 case FRV_OPERAND_ACCGI :
895 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACCGi);
896 break;
897 case FRV_OPERAND_ACCGK :
898 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACCGk);
899 break;
900 case FRV_OPERAND_CCI :
901 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 3, 32, total_length, pc, & fields->f_CCi);
902 break;
903 case FRV_OPERAND_CPRDOUBLEK :
904 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
905 break;
906 case FRV_OPERAND_CPRI :
907 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_CPRi);
908 break;
909 case FRV_OPERAND_CPRJ :
910 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_CPRj);
911 break;
912 case FRV_OPERAND_CPRK :
913 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk);
914 break;
915 case FRV_OPERAND_CRI :
916 length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_CRi);
917 break;
918 case FRV_OPERAND_CRJ :
919 length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 32, total_length, pc, & fields->f_CRj);
920 break;
921 case FRV_OPERAND_CRJ_FLOAT :
922 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_CRj_float);
923 break;
924 case FRV_OPERAND_CRJ_INT :
925 {
926 long value;
927 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & value);
928 value = ((value) + (4));
929 fields->f_CRj_int = value;
930 }
931 break;
932 case FRV_OPERAND_CRK :
933 length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 3, 32, total_length, pc, & fields->f_CRk);
934 break;
935 case FRV_OPERAND_FCCI_1 :
936 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_FCCi_1);
937 break;
938 case FRV_OPERAND_FCCI_2 :
939 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCi_2);
940 break;
941 case FRV_OPERAND_FCCI_3 :
942 length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_FCCi_3);
943 break;
944 case FRV_OPERAND_FCCK :
945 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCk);
946 break;
947 case FRV_OPERAND_FRDOUBLEI :
948 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
949 break;
950 case FRV_OPERAND_FRDOUBLEJ :
951 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
952 break;
953 case FRV_OPERAND_FRDOUBLEK :
954 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
955 break;
956 case FRV_OPERAND_FRI :
957 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
958 break;
959 case FRV_OPERAND_FRINTI :
960 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
961 break;
962 case FRV_OPERAND_FRINTIEVEN :
963 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi);
964 break;
965 case FRV_OPERAND_FRINTJ :
966 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
967 break;
968 case FRV_OPERAND_FRINTJEVEN :
969 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
970 break;
971 case FRV_OPERAND_FRINTK :
972 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
973 break;
974 case FRV_OPERAND_FRINTKEVEN :
975 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
976 break;
977 case FRV_OPERAND_FRJ :
978 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj);
979 break;
980 case FRV_OPERAND_FRK :
981 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
982 break;
983 case FRV_OPERAND_FRKHI :
984 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
985 break;
986 case FRV_OPERAND_FRKLO :
987 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk);
988 break;
989 case FRV_OPERAND_GRDOUBLEK :
990 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
991 break;
992 case FRV_OPERAND_GRI :
993 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_GRi);
994 break;
995 case FRV_OPERAND_GRJ :
996 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_GRj);
997 break;
998 case FRV_OPERAND_GRK :
999 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
1000 break;
1001 case FRV_OPERAND_GRKHI :
1002 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
1003 break;
1004 case FRV_OPERAND_GRKLO :
1005 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk);
1006 break;
1007 case FRV_OPERAND_ICCI_1 :
1008 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_ICCi_1);
1009 break;
1010 case FRV_OPERAND_ICCI_2 :
1011 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_ICCi_2);
1012 break;
1013 case FRV_OPERAND_ICCI_3 :
1014 length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_ICCi_3);
1015 break;
1016 case FRV_OPERAND_LI :
1017 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_LI);
1018 break;
1019 case FRV_OPERAND_AE :
1020 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_ae);
1021 break;
1022 case FRV_OPERAND_CCOND :
1023 length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 1, 32, total_length, pc, & fields->f_ccond);
1024 break;
1025 case FRV_OPERAND_COND :
1026 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 1, 32, total_length, pc, & fields->f_cond);
1027 break;
1028 case FRV_OPERAND_D12 :
1029 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
1030 break;
1031 case FRV_OPERAND_DEBUG :
1032 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_debug);
1033 break;
1034 case FRV_OPERAND_EIR :
1035 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_eir);
1036 break;
1037 case FRV_OPERAND_HINT :
1038 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1039 break;
1040 case FRV_OPERAND_HINT_NOT_TAKEN :
1041 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1042 break;
1043 case FRV_OPERAND_HINT_TAKEN :
1044 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint);
1045 break;
1046 case FRV_OPERAND_LABEL16 :
1047 {
1048 long value;
1049 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);
1050 value = ((((value) << (2))) + (pc));
1051 fields->f_label16 = value;
1052 }
1053 break;
1054 case FRV_OPERAND_LABEL24 :
1055 {
1056 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, pc, & fields->f_labelH6);
1057 if (length <= 0) break;
1058 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 18, 32, total_length, pc, & fields->f_labelL18);
1059 if (length <= 0) break;
1060 {
1061 FLD (f_label24) = ((((((((FLD (f_labelH6)) << (18))) | (FLD (f_labelL18)))) << (2))) + (pc));
1062 }
1063 }
1064 break;
1065 case FRV_OPERAND_LOCK :
1066 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_lock);
1067 break;
1068 case FRV_OPERAND_PACK :
1069 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 1, 32, total_length, pc, & fields->f_pack);
1070 break;
1071 case FRV_OPERAND_S10 :
1072 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, pc, & fields->f_s10);
1073 break;
1074 case FRV_OPERAND_S12 :
1075 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12);
1076 break;
1077 case FRV_OPERAND_S16 :
1078 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
1079 break;
1080 case FRV_OPERAND_S5 :
1081 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, pc, & fields->f_s5);
1082 break;
1083 case FRV_OPERAND_S6 :
1084 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, pc, & fields->f_s6);
1085 break;
1086 case FRV_OPERAND_S6_1 :
1087 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, pc, & fields->f_s6_1);
1088 break;
1089 case FRV_OPERAND_SLO16 :
1090 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16);
1091 break;
1092 case FRV_OPERAND_SPR :
1093 {
1094 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_spr_h);
1095 if (length <= 0) break;
1096 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_spr_l);
1097 if (length <= 0) break;
1098 {
1099 FLD (f_spr) = ((((FLD (f_spr_h)) << (6))) | (FLD (f_spr_l)));
1100 }
1101 }
1102 break;
1103 case FRV_OPERAND_U12 :
1104 {
1105 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, pc, & fields->f_u12_h);
1106 if (length <= 0) break;
1107 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u12_l);
1108 if (length <= 0) break;
1109 {
1110 FLD (f_u12) = ((((FLD (f_u12_h)) << (6))) | (FLD (f_u12_l)));
1111 }
1112 }
1113 break;
1114 case FRV_OPERAND_U16 :
1115 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1116 break;
1117 case FRV_OPERAND_U6 :
1118 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u6);
1119 break;
1120 case FRV_OPERAND_UHI16 :
1121 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1122 break;
1123 case FRV_OPERAND_ULO16 :
1124 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16);
1125 break;
1126
1127 default :
1128 /* xgettext:c-format */
1129 fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
1130 opindex);
1131 abort ();
1132 }
1133
1134 return length;
1135 }
1136
1137 cgen_insert_fn * const frv_cgen_insert_handlers[] =
1138 {
1139 insert_insn_normal,
1140 };
1141
1142 cgen_extract_fn * const frv_cgen_extract_handlers[] =
1143 {
1144 extract_insn_normal,
1145 };
1146
1147 int frv_cgen_get_int_operand
1148 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
1149 bfd_vma frv_cgen_get_vma_operand
1150 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
1151
1152 /* Getting values from cgen_fields is handled by a collection of functions.
1153 They are distinguished by the type of the VALUE argument they return.
1154 TODO: floating point, inlining support, remove cases where result type
1155 not appropriate. */
1156
1157 int
1158 frv_cgen_get_int_operand (cd, opindex, fields)
1159 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1160 int opindex;
1161 const CGEN_FIELDS * fields;
1162 {
1163 int value;
1164
1165 switch (opindex)
1166 {
1167 case FRV_OPERAND_A0 :
1168 value = fields->f_A;
1169 break;
1170 case FRV_OPERAND_A1 :
1171 value = fields->f_A;
1172 break;
1173 case FRV_OPERAND_ACC40SI :
1174 value = fields->f_ACC40Si;
1175 break;
1176 case FRV_OPERAND_ACC40SK :
1177 value = fields->f_ACC40Sk;
1178 break;
1179 case FRV_OPERAND_ACC40UI :
1180 value = fields->f_ACC40Ui;
1181 break;
1182 case FRV_OPERAND_ACC40UK :
1183 value = fields->f_ACC40Uk;
1184 break;
1185 case FRV_OPERAND_ACCGI :
1186 value = fields->f_ACCGi;
1187 break;
1188 case FRV_OPERAND_ACCGK :
1189 value = fields->f_ACCGk;
1190 break;
1191 case FRV_OPERAND_CCI :
1192 value = fields->f_CCi;
1193 break;
1194 case FRV_OPERAND_CPRDOUBLEK :
1195 value = fields->f_CPRk;
1196 break;
1197 case FRV_OPERAND_CPRI :
1198 value = fields->f_CPRi;
1199 break;
1200 case FRV_OPERAND_CPRJ :
1201 value = fields->f_CPRj;
1202 break;
1203 case FRV_OPERAND_CPRK :
1204 value = fields->f_CPRk;
1205 break;
1206 case FRV_OPERAND_CRI :
1207 value = fields->f_CRi;
1208 break;
1209 case FRV_OPERAND_CRJ :
1210 value = fields->f_CRj;
1211 break;
1212 case FRV_OPERAND_CRJ_FLOAT :
1213 value = fields->f_CRj_float;
1214 break;
1215 case FRV_OPERAND_CRJ_INT :
1216 value = fields->f_CRj_int;
1217 break;
1218 case FRV_OPERAND_CRK :
1219 value = fields->f_CRk;
1220 break;
1221 case FRV_OPERAND_FCCI_1 :
1222 value = fields->f_FCCi_1;
1223 break;
1224 case FRV_OPERAND_FCCI_2 :
1225 value = fields->f_FCCi_2;
1226 break;
1227 case FRV_OPERAND_FCCI_3 :
1228 value = fields->f_FCCi_3;
1229 break;
1230 case FRV_OPERAND_FCCK :
1231 value = fields->f_FCCk;
1232 break;
1233 case FRV_OPERAND_FRDOUBLEI :
1234 value = fields->f_FRi;
1235 break;
1236 case FRV_OPERAND_FRDOUBLEJ :
1237 value = fields->f_FRj;
1238 break;
1239 case FRV_OPERAND_FRDOUBLEK :
1240 value = fields->f_FRk;
1241 break;
1242 case FRV_OPERAND_FRI :
1243 value = fields->f_FRi;
1244 break;
1245 case FRV_OPERAND_FRINTI :
1246 value = fields->f_FRi;
1247 break;
1248 case FRV_OPERAND_FRINTIEVEN :
1249 value = fields->f_FRi;
1250 break;
1251 case FRV_OPERAND_FRINTJ :
1252 value = fields->f_FRj;
1253 break;
1254 case FRV_OPERAND_FRINTJEVEN :
1255 value = fields->f_FRj;
1256 break;
1257 case FRV_OPERAND_FRINTK :
1258 value = fields->f_FRk;
1259 break;
1260 case FRV_OPERAND_FRINTKEVEN :
1261 value = fields->f_FRk;
1262 break;
1263 case FRV_OPERAND_FRJ :
1264 value = fields->f_FRj;
1265 break;
1266 case FRV_OPERAND_FRK :
1267 value = fields->f_FRk;
1268 break;
1269 case FRV_OPERAND_FRKHI :
1270 value = fields->f_FRk;
1271 break;
1272 case FRV_OPERAND_FRKLO :
1273 value = fields->f_FRk;
1274 break;
1275 case FRV_OPERAND_GRDOUBLEK :
1276 value = fields->f_GRk;
1277 break;
1278 case FRV_OPERAND_GRI :
1279 value = fields->f_GRi;
1280 break;
1281 case FRV_OPERAND_GRJ :
1282 value = fields->f_GRj;
1283 break;
1284 case FRV_OPERAND_GRK :
1285 value = fields->f_GRk;
1286 break;
1287 case FRV_OPERAND_GRKHI :
1288 value = fields->f_GRk;
1289 break;
1290 case FRV_OPERAND_GRKLO :
1291 value = fields->f_GRk;
1292 break;
1293 case FRV_OPERAND_ICCI_1 :
1294 value = fields->f_ICCi_1;
1295 break;
1296 case FRV_OPERAND_ICCI_2 :
1297 value = fields->f_ICCi_2;
1298 break;
1299 case FRV_OPERAND_ICCI_3 :
1300 value = fields->f_ICCi_3;
1301 break;
1302 case FRV_OPERAND_LI :
1303 value = fields->f_LI;
1304 break;
1305 case FRV_OPERAND_AE :
1306 value = fields->f_ae;
1307 break;
1308 case FRV_OPERAND_CCOND :
1309 value = fields->f_ccond;
1310 break;
1311 case FRV_OPERAND_COND :
1312 value = fields->f_cond;
1313 break;
1314 case FRV_OPERAND_D12 :
1315 value = fields->f_d12;
1316 break;
1317 case FRV_OPERAND_DEBUG :
1318 value = fields->f_debug;
1319 break;
1320 case FRV_OPERAND_EIR :
1321 value = fields->f_eir;
1322 break;
1323 case FRV_OPERAND_HINT :
1324 value = fields->f_hint;
1325 break;
1326 case FRV_OPERAND_HINT_NOT_TAKEN :
1327 value = fields->f_hint;
1328 break;
1329 case FRV_OPERAND_HINT_TAKEN :
1330 value = fields->f_hint;
1331 break;
1332 case FRV_OPERAND_LABEL16 :
1333 value = fields->f_label16;
1334 break;
1335 case FRV_OPERAND_LABEL24 :
1336 value = fields->f_label24;
1337 break;
1338 case FRV_OPERAND_LOCK :
1339 value = fields->f_lock;
1340 break;
1341 case FRV_OPERAND_PACK :
1342 value = fields->f_pack;
1343 break;
1344 case FRV_OPERAND_S10 :
1345 value = fields->f_s10;
1346 break;
1347 case FRV_OPERAND_S12 :
1348 value = fields->f_d12;
1349 break;
1350 case FRV_OPERAND_S16 :
1351 value = fields->f_s16;
1352 break;
1353 case FRV_OPERAND_S5 :
1354 value = fields->f_s5;
1355 break;
1356 case FRV_OPERAND_S6 :
1357 value = fields->f_s6;
1358 break;
1359 case FRV_OPERAND_S6_1 :
1360 value = fields->f_s6_1;
1361 break;
1362 case FRV_OPERAND_SLO16 :
1363 value = fields->f_s16;
1364 break;
1365 case FRV_OPERAND_SPR :
1366 value = fields->f_spr;
1367 break;
1368 case FRV_OPERAND_U12 :
1369 value = fields->f_u12;
1370 break;
1371 case FRV_OPERAND_U16 :
1372 value = fields->f_u16;
1373 break;
1374 case FRV_OPERAND_U6 :
1375 value = fields->f_u6;
1376 break;
1377 case FRV_OPERAND_UHI16 :
1378 value = fields->f_u16;
1379 break;
1380 case FRV_OPERAND_ULO16 :
1381 value = fields->f_u16;
1382 break;
1383
1384 default :
1385 /* xgettext:c-format */
1386 fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
1387 opindex);
1388 abort ();
1389 }
1390
1391 return value;
1392 }
1393
1394 bfd_vma
1395 frv_cgen_get_vma_operand (cd, opindex, fields)
1396 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1397 int opindex;
1398 const CGEN_FIELDS * fields;
1399 {
1400 bfd_vma value;
1401
1402 switch (opindex)
1403 {
1404 case FRV_OPERAND_A0 :
1405 value = fields->f_A;
1406 break;
1407 case FRV_OPERAND_A1 :
1408 value = fields->f_A;
1409 break;
1410 case FRV_OPERAND_ACC40SI :
1411 value = fields->f_ACC40Si;
1412 break;
1413 case FRV_OPERAND_ACC40SK :
1414 value = fields->f_ACC40Sk;
1415 break;
1416 case FRV_OPERAND_ACC40UI :
1417 value = fields->f_ACC40Ui;
1418 break;
1419 case FRV_OPERAND_ACC40UK :
1420 value = fields->f_ACC40Uk;
1421 break;
1422 case FRV_OPERAND_ACCGI :
1423 value = fields->f_ACCGi;
1424 break;
1425 case FRV_OPERAND_ACCGK :
1426 value = fields->f_ACCGk;
1427 break;
1428 case FRV_OPERAND_CCI :
1429 value = fields->f_CCi;
1430 break;
1431 case FRV_OPERAND_CPRDOUBLEK :
1432 value = fields->f_CPRk;
1433 break;
1434 case FRV_OPERAND_CPRI :
1435 value = fields->f_CPRi;
1436 break;
1437 case FRV_OPERAND_CPRJ :
1438 value = fields->f_CPRj;
1439 break;
1440 case FRV_OPERAND_CPRK :
1441 value = fields->f_CPRk;
1442 break;
1443 case FRV_OPERAND_CRI :
1444 value = fields->f_CRi;
1445 break;
1446 case FRV_OPERAND_CRJ :
1447 value = fields->f_CRj;
1448 break;
1449 case FRV_OPERAND_CRJ_FLOAT :
1450 value = fields->f_CRj_float;
1451 break;
1452 case FRV_OPERAND_CRJ_INT :
1453 value = fields->f_CRj_int;
1454 break;
1455 case FRV_OPERAND_CRK :
1456 value = fields->f_CRk;
1457 break;
1458 case FRV_OPERAND_FCCI_1 :
1459 value = fields->f_FCCi_1;
1460 break;
1461 case FRV_OPERAND_FCCI_2 :
1462 value = fields->f_FCCi_2;
1463 break;
1464 case FRV_OPERAND_FCCI_3 :
1465 value = fields->f_FCCi_3;
1466 break;
1467 case FRV_OPERAND_FCCK :
1468 value = fields->f_FCCk;
1469 break;
1470 case FRV_OPERAND_FRDOUBLEI :
1471 value = fields->f_FRi;
1472 break;
1473 case FRV_OPERAND_FRDOUBLEJ :
1474 value = fields->f_FRj;
1475 break;
1476 case FRV_OPERAND_FRDOUBLEK :
1477 value = fields->f_FRk;
1478 break;
1479 case FRV_OPERAND_FRI :
1480 value = fields->f_FRi;
1481 break;
1482 case FRV_OPERAND_FRINTI :
1483 value = fields->f_FRi;
1484 break;
1485 case FRV_OPERAND_FRINTIEVEN :
1486 value = fields->f_FRi;
1487 break;
1488 case FRV_OPERAND_FRINTJ :
1489 value = fields->f_FRj;
1490 break;
1491 case FRV_OPERAND_FRINTJEVEN :
1492 value = fields->f_FRj;
1493 break;
1494 case FRV_OPERAND_FRINTK :
1495 value = fields->f_FRk;
1496 break;
1497 case FRV_OPERAND_FRINTKEVEN :
1498 value = fields->f_FRk;
1499 break;
1500 case FRV_OPERAND_FRJ :
1501 value = fields->f_FRj;
1502 break;
1503 case FRV_OPERAND_FRK :
1504 value = fields->f_FRk;
1505 break;
1506 case FRV_OPERAND_FRKHI :
1507 value = fields->f_FRk;
1508 break;
1509 case FRV_OPERAND_FRKLO :
1510 value = fields->f_FRk;
1511 break;
1512 case FRV_OPERAND_GRDOUBLEK :
1513 value = fields->f_GRk;
1514 break;
1515 case FRV_OPERAND_GRI :
1516 value = fields->f_GRi;
1517 break;
1518 case FRV_OPERAND_GRJ :
1519 value = fields->f_GRj;
1520 break;
1521 case FRV_OPERAND_GRK :
1522 value = fields->f_GRk;
1523 break;
1524 case FRV_OPERAND_GRKHI :
1525 value = fields->f_GRk;
1526 break;
1527 case FRV_OPERAND_GRKLO :
1528 value = fields->f_GRk;
1529 break;
1530 case FRV_OPERAND_ICCI_1 :
1531 value = fields->f_ICCi_1;
1532 break;
1533 case FRV_OPERAND_ICCI_2 :
1534 value = fields->f_ICCi_2;
1535 break;
1536 case FRV_OPERAND_ICCI_3 :
1537 value = fields->f_ICCi_3;
1538 break;
1539 case FRV_OPERAND_LI :
1540 value = fields->f_LI;
1541 break;
1542 case FRV_OPERAND_AE :
1543 value = fields->f_ae;
1544 break;
1545 case FRV_OPERAND_CCOND :
1546 value = fields->f_ccond;
1547 break;
1548 case FRV_OPERAND_COND :
1549 value = fields->f_cond;
1550 break;
1551 case FRV_OPERAND_D12 :
1552 value = fields->f_d12;
1553 break;
1554 case FRV_OPERAND_DEBUG :
1555 value = fields->f_debug;
1556 break;
1557 case FRV_OPERAND_EIR :
1558 value = fields->f_eir;
1559 break;
1560 case FRV_OPERAND_HINT :
1561 value = fields->f_hint;
1562 break;
1563 case FRV_OPERAND_HINT_NOT_TAKEN :
1564 value = fields->f_hint;
1565 break;
1566 case FRV_OPERAND_HINT_TAKEN :
1567 value = fields->f_hint;
1568 break;
1569 case FRV_OPERAND_LABEL16 :
1570 value = fields->f_label16;
1571 break;
1572 case FRV_OPERAND_LABEL24 :
1573 value = fields->f_label24;
1574 break;
1575 case FRV_OPERAND_LOCK :
1576 value = fields->f_lock;
1577 break;
1578 case FRV_OPERAND_PACK :
1579 value = fields->f_pack;
1580 break;
1581 case FRV_OPERAND_S10 :
1582 value = fields->f_s10;
1583 break;
1584 case FRV_OPERAND_S12 :
1585 value = fields->f_d12;
1586 break;
1587 case FRV_OPERAND_S16 :
1588 value = fields->f_s16;
1589 break;
1590 case FRV_OPERAND_S5 :
1591 value = fields->f_s5;
1592 break;
1593 case FRV_OPERAND_S6 :
1594 value = fields->f_s6;
1595 break;
1596 case FRV_OPERAND_S6_1 :
1597 value = fields->f_s6_1;
1598 break;
1599 case FRV_OPERAND_SLO16 :
1600 value = fields->f_s16;
1601 break;
1602 case FRV_OPERAND_SPR :
1603 value = fields->f_spr;
1604 break;
1605 case FRV_OPERAND_U12 :
1606 value = fields->f_u12;
1607 break;
1608 case FRV_OPERAND_U16 :
1609 value = fields->f_u16;
1610 break;
1611 case FRV_OPERAND_U6 :
1612 value = fields->f_u6;
1613 break;
1614 case FRV_OPERAND_UHI16 :
1615 value = fields->f_u16;
1616 break;
1617 case FRV_OPERAND_ULO16 :
1618 value = fields->f_u16;
1619 break;
1620
1621 default :
1622 /* xgettext:c-format */
1623 fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
1624 opindex);
1625 abort ();
1626 }
1627
1628 return value;
1629 }
1630
1631 void frv_cgen_set_int_operand
1632 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int));
1633 void frv_cgen_set_vma_operand
1634 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma));
1635
1636 /* Stuffing values in cgen_fields is handled by a collection of functions.
1637 They are distinguished by the type of the VALUE argument they accept.
1638 TODO: floating point, inlining support, remove cases where argument type
1639 not appropriate. */
1640
1641 void
1642 frv_cgen_set_int_operand (cd, opindex, fields, value)
1643 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1644 int opindex;
1645 CGEN_FIELDS * fields;
1646 int value;
1647 {
1648 switch (opindex)
1649 {
1650 case FRV_OPERAND_A0 :
1651 fields->f_A = value;
1652 break;
1653 case FRV_OPERAND_A1 :
1654 fields->f_A = value;
1655 break;
1656 case FRV_OPERAND_ACC40SI :
1657 fields->f_ACC40Si = value;
1658 break;
1659 case FRV_OPERAND_ACC40SK :
1660 fields->f_ACC40Sk = value;
1661 break;
1662 case FRV_OPERAND_ACC40UI :
1663 fields->f_ACC40Ui = value;
1664 break;
1665 case FRV_OPERAND_ACC40UK :
1666 fields->f_ACC40Uk = value;
1667 break;
1668 case FRV_OPERAND_ACCGI :
1669 fields->f_ACCGi = value;
1670 break;
1671 case FRV_OPERAND_ACCGK :
1672 fields->f_ACCGk = value;
1673 break;
1674 case FRV_OPERAND_CCI :
1675 fields->f_CCi = value;
1676 break;
1677 case FRV_OPERAND_CPRDOUBLEK :
1678 fields->f_CPRk = value;
1679 break;
1680 case FRV_OPERAND_CPRI :
1681 fields->f_CPRi = value;
1682 break;
1683 case FRV_OPERAND_CPRJ :
1684 fields->f_CPRj = value;
1685 break;
1686 case FRV_OPERAND_CPRK :
1687 fields->f_CPRk = value;
1688 break;
1689 case FRV_OPERAND_CRI :
1690 fields->f_CRi = value;
1691 break;
1692 case FRV_OPERAND_CRJ :
1693 fields->f_CRj = value;
1694 break;
1695 case FRV_OPERAND_CRJ_FLOAT :
1696 fields->f_CRj_float = value;
1697 break;
1698 case FRV_OPERAND_CRJ_INT :
1699 fields->f_CRj_int = value;
1700 break;
1701 case FRV_OPERAND_CRK :
1702 fields->f_CRk = value;
1703 break;
1704 case FRV_OPERAND_FCCI_1 :
1705 fields->f_FCCi_1 = value;
1706 break;
1707 case FRV_OPERAND_FCCI_2 :
1708 fields->f_FCCi_2 = value;
1709 break;
1710 case FRV_OPERAND_FCCI_3 :
1711 fields->f_FCCi_3 = value;
1712 break;
1713 case FRV_OPERAND_FCCK :
1714 fields->f_FCCk = value;
1715 break;
1716 case FRV_OPERAND_FRDOUBLEI :
1717 fields->f_FRi = value;
1718 break;
1719 case FRV_OPERAND_FRDOUBLEJ :
1720 fields->f_FRj = value;
1721 break;
1722 case FRV_OPERAND_FRDOUBLEK :
1723 fields->f_FRk = value;
1724 break;
1725 case FRV_OPERAND_FRI :
1726 fields->f_FRi = value;
1727 break;
1728 case FRV_OPERAND_FRINTI :
1729 fields->f_FRi = value;
1730 break;
1731 case FRV_OPERAND_FRINTIEVEN :
1732 fields->f_FRi = value;
1733 break;
1734 case FRV_OPERAND_FRINTJ :
1735 fields->f_FRj = value;
1736 break;
1737 case FRV_OPERAND_FRINTJEVEN :
1738 fields->f_FRj = value;
1739 break;
1740 case FRV_OPERAND_FRINTK :
1741 fields->f_FRk = value;
1742 break;
1743 case FRV_OPERAND_FRINTKEVEN :
1744 fields->f_FRk = value;
1745 break;
1746 case FRV_OPERAND_FRJ :
1747 fields->f_FRj = value;
1748 break;
1749 case FRV_OPERAND_FRK :
1750 fields->f_FRk = value;
1751 break;
1752 case FRV_OPERAND_FRKHI :
1753 fields->f_FRk = value;
1754 break;
1755 case FRV_OPERAND_FRKLO :
1756 fields->f_FRk = value;
1757 break;
1758 case FRV_OPERAND_GRDOUBLEK :
1759 fields->f_GRk = value;
1760 break;
1761 case FRV_OPERAND_GRI :
1762 fields->f_GRi = value;
1763 break;
1764 case FRV_OPERAND_GRJ :
1765 fields->f_GRj = value;
1766 break;
1767 case FRV_OPERAND_GRK :
1768 fields->f_GRk = value;
1769 break;
1770 case FRV_OPERAND_GRKHI :
1771 fields->f_GRk = value;
1772 break;
1773 case FRV_OPERAND_GRKLO :
1774 fields->f_GRk = value;
1775 break;
1776 case FRV_OPERAND_ICCI_1 :
1777 fields->f_ICCi_1 = value;
1778 break;
1779 case FRV_OPERAND_ICCI_2 :
1780 fields->f_ICCi_2 = value;
1781 break;
1782 case FRV_OPERAND_ICCI_3 :
1783 fields->f_ICCi_3 = value;
1784 break;
1785 case FRV_OPERAND_LI :
1786 fields->f_LI = value;
1787 break;
1788 case FRV_OPERAND_AE :
1789 fields->f_ae = value;
1790 break;
1791 case FRV_OPERAND_CCOND :
1792 fields->f_ccond = value;
1793 break;
1794 case FRV_OPERAND_COND :
1795 fields->f_cond = value;
1796 break;
1797 case FRV_OPERAND_D12 :
1798 fields->f_d12 = value;
1799 break;
1800 case FRV_OPERAND_DEBUG :
1801 fields->f_debug = value;
1802 break;
1803 case FRV_OPERAND_EIR :
1804 fields->f_eir = value;
1805 break;
1806 case FRV_OPERAND_HINT :
1807 fields->f_hint = value;
1808 break;
1809 case FRV_OPERAND_HINT_NOT_TAKEN :
1810 fields->f_hint = value;
1811 break;
1812 case FRV_OPERAND_HINT_TAKEN :
1813 fields->f_hint = value;
1814 break;
1815 case FRV_OPERAND_LABEL16 :
1816 fields->f_label16 = value;
1817 break;
1818 case FRV_OPERAND_LABEL24 :
1819 fields->f_label24 = value;
1820 break;
1821 case FRV_OPERAND_LOCK :
1822 fields->f_lock = value;
1823 break;
1824 case FRV_OPERAND_PACK :
1825 fields->f_pack = value;
1826 break;
1827 case FRV_OPERAND_S10 :
1828 fields->f_s10 = value;
1829 break;
1830 case FRV_OPERAND_S12 :
1831 fields->f_d12 = value;
1832 break;
1833 case FRV_OPERAND_S16 :
1834 fields->f_s16 = value;
1835 break;
1836 case FRV_OPERAND_S5 :
1837 fields->f_s5 = value;
1838 break;
1839 case FRV_OPERAND_S6 :
1840 fields->f_s6 = value;
1841 break;
1842 case FRV_OPERAND_S6_1 :
1843 fields->f_s6_1 = value;
1844 break;
1845 case FRV_OPERAND_SLO16 :
1846 fields->f_s16 = value;
1847 break;
1848 case FRV_OPERAND_SPR :
1849 fields->f_spr = value;
1850 break;
1851 case FRV_OPERAND_U12 :
1852 fields->f_u12 = value;
1853 break;
1854 case FRV_OPERAND_U16 :
1855 fields->f_u16 = value;
1856 break;
1857 case FRV_OPERAND_U6 :
1858 fields->f_u6 = value;
1859 break;
1860 case FRV_OPERAND_UHI16 :
1861 fields->f_u16 = value;
1862 break;
1863 case FRV_OPERAND_ULO16 :
1864 fields->f_u16 = value;
1865 break;
1866
1867 default :
1868 /* xgettext:c-format */
1869 fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
1870 opindex);
1871 abort ();
1872 }
1873 }
1874
1875 void
1876 frv_cgen_set_vma_operand (cd, opindex, fields, value)
1877 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
1878 int opindex;
1879 CGEN_FIELDS * fields;
1880 bfd_vma value;
1881 {
1882 switch (opindex)
1883 {
1884 case FRV_OPERAND_A0 :
1885 fields->f_A = value;
1886 break;
1887 case FRV_OPERAND_A1 :
1888 fields->f_A = value;
1889 break;
1890 case FRV_OPERAND_ACC40SI :
1891 fields->f_ACC40Si = value;
1892 break;
1893 case FRV_OPERAND_ACC40SK :
1894 fields->f_ACC40Sk = value;
1895 break;
1896 case FRV_OPERAND_ACC40UI :
1897 fields->f_ACC40Ui = value;
1898 break;
1899 case FRV_OPERAND_ACC40UK :
1900 fields->f_ACC40Uk = value;
1901 break;
1902 case FRV_OPERAND_ACCGI :
1903 fields->f_ACCGi = value;
1904 break;
1905 case FRV_OPERAND_ACCGK :
1906 fields->f_ACCGk = value;
1907 break;
1908 case FRV_OPERAND_CCI :
1909 fields->f_CCi = value;
1910 break;
1911 case FRV_OPERAND_CPRDOUBLEK :
1912 fields->f_CPRk = value;
1913 break;
1914 case FRV_OPERAND_CPRI :
1915 fields->f_CPRi = value;
1916 break;
1917 case FRV_OPERAND_CPRJ :
1918 fields->f_CPRj = value;
1919 break;
1920 case FRV_OPERAND_CPRK :
1921 fields->f_CPRk = value;
1922 break;
1923 case FRV_OPERAND_CRI :
1924 fields->f_CRi = value;
1925 break;
1926 case FRV_OPERAND_CRJ :
1927 fields->f_CRj = value;
1928 break;
1929 case FRV_OPERAND_CRJ_FLOAT :
1930 fields->f_CRj_float = value;
1931 break;
1932 case FRV_OPERAND_CRJ_INT :
1933 fields->f_CRj_int = value;
1934 break;
1935 case FRV_OPERAND_CRK :
1936 fields->f_CRk = value;
1937 break;
1938 case FRV_OPERAND_FCCI_1 :
1939 fields->f_FCCi_1 = value;
1940 break;
1941 case FRV_OPERAND_FCCI_2 :
1942 fields->f_FCCi_2 = value;
1943 break;
1944 case FRV_OPERAND_FCCI_3 :
1945 fields->f_FCCi_3 = value;
1946 break;
1947 case FRV_OPERAND_FCCK :
1948 fields->f_FCCk = value;
1949 break;
1950 case FRV_OPERAND_FRDOUBLEI :
1951 fields->f_FRi = value;
1952 break;
1953 case FRV_OPERAND_FRDOUBLEJ :
1954 fields->f_FRj = value;
1955 break;
1956 case FRV_OPERAND_FRDOUBLEK :
1957 fields->f_FRk = value;
1958 break;
1959 case FRV_OPERAND_FRI :
1960 fields->f_FRi = value;
1961 break;
1962 case FRV_OPERAND_FRINTI :
1963 fields->f_FRi = value;
1964 break;
1965 case FRV_OPERAND_FRINTIEVEN :
1966 fields->f_FRi = value;
1967 break;
1968 case FRV_OPERAND_FRINTJ :
1969 fields->f_FRj = value;
1970 break;
1971 case FRV_OPERAND_FRINTJEVEN :
1972 fields->f_FRj = value;
1973 break;
1974 case FRV_OPERAND_FRINTK :
1975 fields->f_FRk = value;
1976 break;
1977 case FRV_OPERAND_FRINTKEVEN :
1978 fields->f_FRk = value;
1979 break;
1980 case FRV_OPERAND_FRJ :
1981 fields->f_FRj = value;
1982 break;
1983 case FRV_OPERAND_FRK :
1984 fields->f_FRk = value;
1985 break;
1986 case FRV_OPERAND_FRKHI :
1987 fields->f_FRk = value;
1988 break;
1989 case FRV_OPERAND_FRKLO :
1990 fields->f_FRk = value;
1991 break;
1992 case FRV_OPERAND_GRDOUBLEK :
1993 fields->f_GRk = value;
1994 break;
1995 case FRV_OPERAND_GRI :
1996 fields->f_GRi = value;
1997 break;
1998 case FRV_OPERAND_GRJ :
1999 fields->f_GRj = value;
2000 break;
2001 case FRV_OPERAND_GRK :
2002 fields->f_GRk = value;
2003 break;
2004 case FRV_OPERAND_GRKHI :
2005 fields->f_GRk = value;
2006 break;
2007 case FRV_OPERAND_GRKLO :
2008 fields->f_GRk = value;
2009 break;
2010 case FRV_OPERAND_ICCI_1 :
2011 fields->f_ICCi_1 = value;
2012 break;
2013 case FRV_OPERAND_ICCI_2 :
2014 fields->f_ICCi_2 = value;
2015 break;
2016 case FRV_OPERAND_ICCI_3 :
2017 fields->f_ICCi_3 = value;
2018 break;
2019 case FRV_OPERAND_LI :
2020 fields->f_LI = value;
2021 break;
2022 case FRV_OPERAND_AE :
2023 fields->f_ae = value;
2024 break;
2025 case FRV_OPERAND_CCOND :
2026 fields->f_ccond = value;
2027 break;
2028 case FRV_OPERAND_COND :
2029 fields->f_cond = value;
2030 break;
2031 case FRV_OPERAND_D12 :
2032 fields->f_d12 = value;
2033 break;
2034 case FRV_OPERAND_DEBUG :
2035 fields->f_debug = value;
2036 break;
2037 case FRV_OPERAND_EIR :
2038 fields->f_eir = value;
2039 break;
2040 case FRV_OPERAND_HINT :
2041 fields->f_hint = value;
2042 break;
2043 case FRV_OPERAND_HINT_NOT_TAKEN :
2044 fields->f_hint = value;
2045 break;
2046 case FRV_OPERAND_HINT_TAKEN :
2047 fields->f_hint = value;
2048 break;
2049 case FRV_OPERAND_LABEL16 :
2050 fields->f_label16 = value;
2051 break;
2052 case FRV_OPERAND_LABEL24 :
2053 fields->f_label24 = value;
2054 break;
2055 case FRV_OPERAND_LOCK :
2056 fields->f_lock = value;
2057 break;
2058 case FRV_OPERAND_PACK :
2059 fields->f_pack = value;
2060 break;
2061 case FRV_OPERAND_S10 :
2062 fields->f_s10 = value;
2063 break;
2064 case FRV_OPERAND_S12 :
2065 fields->f_d12 = value;
2066 break;
2067 case FRV_OPERAND_S16 :
2068 fields->f_s16 = value;
2069 break;
2070 case FRV_OPERAND_S5 :
2071 fields->f_s5 = value;
2072 break;
2073 case FRV_OPERAND_S6 :
2074 fields->f_s6 = value;
2075 break;
2076 case FRV_OPERAND_S6_1 :
2077 fields->f_s6_1 = value;
2078 break;
2079 case FRV_OPERAND_SLO16 :
2080 fields->f_s16 = value;
2081 break;
2082 case FRV_OPERAND_SPR :
2083 fields->f_spr = value;
2084 break;
2085 case FRV_OPERAND_U12 :
2086 fields->f_u12 = value;
2087 break;
2088 case FRV_OPERAND_U16 :
2089 fields->f_u16 = value;
2090 break;
2091 case FRV_OPERAND_U6 :
2092 fields->f_u6 = value;
2093 break;
2094 case FRV_OPERAND_UHI16 :
2095 fields->f_u16 = value;
2096 break;
2097 case FRV_OPERAND_ULO16 :
2098 fields->f_u16 = value;
2099 break;
2100
2101 default :
2102 /* xgettext:c-format */
2103 fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
2104 opindex);
2105 abort ();
2106 }
2107 }
2108
2109 /* Function to call before using the instruction builder tables. */
2110
2111 void
2112 frv_cgen_init_ibld_table (cd)
2113 CGEN_CPU_DESC cd;
2114 {
2115 cd->insert_handlers = & frv_cgen_insert_handlers[0];
2116 cd->extract_handlers = & frv_cgen_extract_handlers[0];
2117
2118 cd->insert_operand = frv_cgen_insert_operand;
2119 cd->extract_operand = frv_cgen_extract_operand;
2120
2121 cd->get_int_operand = frv_cgen_get_int_operand;
2122 cd->set_int_operand = frv_cgen_set_int_operand;
2123 cd->get_vma_operand = frv_cgen_get_vma_operand;
2124 cd->set_vma_operand = frv_cgen_set_vma_operand;
2125 }
my patches to zpugcc