1 /* Instruction building/extraction support for openrisc. -*- C -*-
3 THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
4 - the resultant file is machine generated, cgen-ibld.in isn't
6 Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
8 This file is part of the GNU Binutils and GDB, the GNU debugger.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software Foundation, Inc.,
22 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
33 #include "openrisc-desc.h"
34 #include "openrisc-opc.h"
38 #define min(a,b) ((a) < (b) ? (a) : (b))
40 #define max(a,b) ((a) > (b) ? (a) : (b))
42 /* Used by the ifield rtx function. */
43 #define FLD(f) (fields->f)
45 static const char * insert_normal
46 PARAMS ((CGEN_CPU_DESC
, long, unsigned int, unsigned int, unsigned int,
47 unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR
));
48 static const char * insert_insn_normal
49 PARAMS ((CGEN_CPU_DESC
, const CGEN_INSN
*,
50 CGEN_FIELDS
*, CGEN_INSN_BYTES_PTR
, bfd_vma
));
52 static 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 *));
56 static int extract_insn_normal
57 PARAMS ((CGEN_CPU_DESC
, const CGEN_INSN
*, CGEN_EXTRACT_INFO
*,
58 CGEN_INSN_INT
, CGEN_FIELDS
*, bfd_vma
));
59 static void put_insn_int_value
60 PARAMS ((CGEN_CPU_DESC
, CGEN_INSN_BYTES_PTR
, int, int, CGEN_INSN_INT
));
61 const char * openrisc_cgen_insert_operand
62 PARAMS ((CGEN_CPU_DESC
, int, CGEN_FIELDS
*, CGEN_INSN_BYTES_PTR
, bfd_vma
));
63 int openrisc_cgen_extract_operand
64 PARAMS ((CGEN_CPU_DESC
, int, CGEN_EXTRACT_INFO
*, CGEN_INSN_INT
, CGEN_FIELDS
*, bfd_vma
));
65 int openrisc_cgen_get_int_operand
66 PARAMS ((CGEN_CPU_DESC
, int, const CGEN_FIELDS
*));
67 bfd_vma openrisc_cgen_get_vma_operand
68 PARAMS ((CGEN_CPU_DESC
, int, const CGEN_FIELDS
*));
69 void openrisc_cgen_set_int_operand
70 PARAMS ((CGEN_CPU_DESC
, int, CGEN_FIELDS
*, int));
71 void openrisc_cgen_set_vma_operand
72 PARAMS ((CGEN_CPU_DESC
, int, CGEN_FIELDS
*, bfd_vma
));
74 /* Operand insertion. */
78 /* Subroutine of insert_normal. */
80 static CGEN_INLINE
void
81 insert_1 (cd
, value
, start
, length
, word_length
, bufp
)
84 int start
,length
,word_length
;
89 int big_p
= CGEN_CPU_INSN_ENDIAN (cd
) == CGEN_ENDIAN_BIG
;
91 x
= bfd_get_bits (bufp
, word_length
, big_p
);
93 /* Written this way to avoid undefined behaviour. */
94 mask
= (((1L << (length
- 1)) - 1) << 1) | 1;
96 shift
= (start
+ 1) - length
;
98 shift
= (word_length
- (start
+ length
));
99 x
= (x
& ~(mask
<< shift
)) | ((value
& mask
) << shift
);
101 bfd_put_bits ((bfd_vma
) x
, bufp
, word_length
, big_p
);
104 #endif /* ! CGEN_INT_INSN_P */
106 /* Default insertion routine.
108 ATTRS is a mask of the boolean attributes.
109 WORD_OFFSET is the offset in bits from the start of the insn of the value.
110 WORD_LENGTH is the length of the word in bits in which the value resides.
111 START is the starting bit number in the word, architecture origin.
112 LENGTH is the length of VALUE in bits.
113 TOTAL_LENGTH is the total length of the insn in bits.
115 The result is an error message or NULL if success. */
117 /* ??? This duplicates functionality with bfd's howto table and
118 bfd_install_relocation. */
119 /* ??? This doesn't handle bfd_vma's. Create another function when
123 insert_normal (cd
, value
, attrs
, word_offset
, start
, length
, word_length
,
124 total_length
, buffer
)
128 unsigned int word_offset
, start
, length
, word_length
, total_length
;
129 CGEN_INSN_BYTES_PTR buffer
;
131 static char errbuf
[100];
132 /* Written this way to avoid undefined behaviour. */
133 unsigned long mask
= (((1L << (length
- 1)) - 1) << 1) | 1;
135 /* If LENGTH is zero, this operand doesn't contribute to the value. */
145 if (word_length
> 32)
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
)
153 && word_length
> total_length
)
154 word_length
= total_length
;
157 /* Ensure VALUE will fit. */
158 if (CGEN_BOOL_ATTR (attrs
, CGEN_IFLD_SIGN_OPT
))
160 long minval
= - (1L << (length
- 1));
161 unsigned long maxval
= mask
;
163 if ((value
> 0 && (unsigned long) value
> maxval
)
166 /* xgettext:c-format */
168 _("operand out of range (%ld not between %ld and %lu)"),
169 value
, minval
, maxval
);
173 else if (! CGEN_BOOL_ATTR (attrs
, CGEN_IFLD_SIGNED
))
175 unsigned long maxval
= mask
;
177 if ((unsigned long) value
> maxval
)
179 /* xgettext:c-format */
181 _("operand out of range (%lu not between 0 and %lu)"),
188 if (! cgen_signed_overflow_ok_p (cd
))
190 long minval
= - (1L << (length
- 1));
191 long maxval
= (1L << (length
- 1)) - 1;
193 if (value
< minval
|| value
> maxval
)
196 /* xgettext:c-format */
197 (errbuf
, _("operand out of range (%ld not between %ld and %ld)"),
198 value
, minval
, maxval
);
209 if (CGEN_INSN_LSB0_P
)
210 shift
= (word_offset
+ start
+ 1) - length
;
212 shift
= total_length
- (word_offset
+ start
+ length
);
213 *buffer
= (*buffer
& ~(mask
<< shift
)) | ((value
& mask
) << shift
);
216 #else /* ! CGEN_INT_INSN_P */
219 unsigned char *bufp
= (unsigned char *) buffer
+ word_offset
/ 8;
221 insert_1 (cd
, value
, start
, length
, word_length
, bufp
);
224 #endif /* ! CGEN_INT_INSN_P */
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. */
237 insert_insn_normal (cd
, insn
, fields
, buffer
, pc
)
239 const CGEN_INSN
* insn
;
240 CGEN_FIELDS
* fields
;
241 CGEN_INSN_BYTES_PTR buffer
;
244 const CGEN_SYNTAX
*syntax
= CGEN_INSN_SYNTAX (insn
);
246 const CGEN_SYNTAX_CHAR_TYPE
* syn
;
248 CGEN_INIT_INSERT (cd
);
249 value
= CGEN_INSN_BASE_VALUE (insn
);
251 /* If we're recording insns as numbers (rather than a string of bytes),
252 target byte order handling is deferred until later. */
256 put_insn_int_value (cd
, buffer
, cd
->base_insn_bitsize
,
257 CGEN_FIELDS_BITSIZE (fields
), value
);
261 cgen_put_insn_value (cd
, buffer
, min (cd
->base_insn_bitsize
,
262 CGEN_FIELDS_BITSIZE (fields
)),
265 #endif /* ! CGEN_INT_INSN_P */
267 /* ??? It would be better to scan the format's fields.
268 Still need to be able to insert a value based on the operand though;
269 e.g. storing a branch displacement that got resolved later.
270 Needs more thought first. */
272 for (syn
= CGEN_SYNTAX_STRING (syntax
); * syn
; ++ syn
)
276 if (CGEN_SYNTAX_CHAR_P (* syn
))
279 errmsg
= (* cd
->insert_operand
) (cd
, CGEN_SYNTAX_FIELD (*syn
),
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. */
292 put_insn_int_value (cd
, buf
, length
, insn_length
, value
)
293 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED
;
294 CGEN_INSN_BYTES_PTR buf
;
299 /* For architectures with insns smaller than the base-insn-bitsize,
300 length may be too big. */
301 if (length
> insn_length
)
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
);
312 /* Operand extraction. */
314 #if ! CGEN_INT_INSN_P
316 /* Subroutine of extract_normal.
317 Ensure sufficient bytes are cached in EX_INFO.
318 OFFSET is the offset in bytes from the start of the insn of the value.
319 BYTES is the length of the needed value.
320 Returns 1 for success, 0 for failure. */
322 static CGEN_INLINE
int
323 fill_cache (cd
, ex_info
, offset
, bytes
, pc
)
325 CGEN_EXTRACT_INFO
*ex_info
;
329 /* It's doubtful that the middle part has already been fetched so
330 we don't optimize that case. kiss. */
332 disassemble_info
*info
= (disassemble_info
*) ex_info
->dis_info
;
334 /* First do a quick check. */
335 mask
= (1 << bytes
) - 1;
336 if (((ex_info
->valid
>> offset
) & mask
) == mask
)
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
))
349 status
= (*info
->read_memory_func
)
350 (pc
, ex_info
->insn_bytes
+ offset
, bytes
, info
);
354 (*info
->memory_error_func
) (status
, pc
, info
);
358 ex_info
->valid
|= ((1 << bytes
) - 1) << offset
;
364 /* Subroutine of extract_normal. */
366 static CGEN_INLINE
long
367 extract_1 (cd
, ex_info
, start
, length
, word_length
, bufp
, pc
)
369 CGEN_EXTRACT_INFO
*ex_info
;
370 int start
,length
,word_length
;
376 int big_p
= CGEN_CPU_INSN_ENDIAN (cd
) == CGEN_ENDIAN_BIG
;
378 x
= bfd_get_bits (bufp
, word_length
, big_p
);
380 if (CGEN_INSN_LSB0_P
)
381 shift
= (start
+ 1) - length
;
383 shift
= (word_length
- (start
+ length
));
387 #endif /* ! CGEN_INT_INSN_P */
389 /* Default extraction routine.
391 INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
392 or sometimes less for cases like the m32r where the base insn size is 32
393 but some insns are 16 bits.
394 ATTRS is a mask of the boolean attributes. We only need `SIGNED',
395 but for generality we take a bitmask of all of them.
396 WORD_OFFSET is the offset in bits from the start of the insn of the value.
397 WORD_LENGTH is the length of the word in bits in which the value resides.
398 START is the starting bit number in the word, architecture origin.
399 LENGTH is the length of VALUE in bits.
400 TOTAL_LENGTH is the total length of the insn in bits.
402 Returns 1 for success, 0 for failure. */
404 /* ??? The return code isn't properly used. wip. */
406 /* ??? This doesn't handle bfd_vma's. Create another function when
410 extract_normal (cd
, ex_info
, insn_value
, attrs
, word_offset
, start
, length
,
411 word_length
, total_length
, pc
, valuep
)
413 #if ! CGEN_INT_INSN_P
414 CGEN_EXTRACT_INFO
*ex_info
;
416 CGEN_EXTRACT_INFO
*ex_info ATTRIBUTE_UNUSED
;
418 CGEN_INSN_INT insn_value
;
420 unsigned int word_offset
, start
, length
, word_length
, total_length
;
421 #if ! CGEN_INT_INSN_P
424 bfd_vma pc ATTRIBUTE_UNUSED
;
430 /* If LENGTH is zero, this operand doesn't contribute to the value
431 so give it a standard value of zero. */
444 if (word_length
> 32)
447 /* For architectures with insns smaller than the insn-base-bitsize,
448 word_length may be too big. */
449 if (cd
->min_insn_bitsize
< cd
->base_insn_bitsize
)
452 && word_length
> total_length
)
453 word_length
= total_length
;
456 /* Does the value reside in INSN_VALUE, and at the right alignment? */
458 if (CGEN_INT_INSN_P
|| (word_offset
== 0 && word_length
== total_length
))
460 if (CGEN_INSN_LSB0_P
)
461 value
= insn_value
>> ((word_offset
+ start
+ 1) - length
);
463 value
= insn_value
>> (total_length
- ( word_offset
+ start
+ length
));
466 #if ! CGEN_INT_INSN_P
470 unsigned char *bufp
= ex_info
->insn_bytes
+ word_offset
/ 8;
472 if (word_length
> 32)
475 if (fill_cache (cd
, ex_info
, word_offset
/ 8, word_length
/ 8, pc
) == 0)
478 value
= extract_1 (cd
, ex_info
, start
, length
, word_length
, bufp
, pc
);
481 #endif /* ! CGEN_INT_INSN_P */
483 /* Written this way to avoid undefined behaviour. */
484 mask
= (((1L << (length
- 1)) - 1) << 1) | 1;
488 if (CGEN_BOOL_ATTR (attrs
, CGEN_IFLD_SIGNED
)
489 && (value
& (1L << (length
- 1))))
497 /* Default insn extractor.
499 INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
500 The extracted fields are stored in FIELDS.
501 EX_INFO is used to handle reading variable length insns.
502 Return the length of the insn in bits, or 0 if no match,
503 or -1 if an error occurs fetching data (memory_error_func will have
507 extract_insn_normal (cd
, insn
, ex_info
, insn_value
, fields
, pc
)
509 const CGEN_INSN
*insn
;
510 CGEN_EXTRACT_INFO
*ex_info
;
511 CGEN_INSN_INT insn_value
;
515 const CGEN_SYNTAX
*syntax
= CGEN_INSN_SYNTAX (insn
);
516 const CGEN_SYNTAX_CHAR_TYPE
*syn
;
518 CGEN_FIELDS_BITSIZE (fields
) = CGEN_INSN_BITSIZE (insn
);
520 CGEN_INIT_EXTRACT (cd
);
522 for (syn
= CGEN_SYNTAX_STRING (syntax
); *syn
; ++syn
)
526 if (CGEN_SYNTAX_CHAR_P (*syn
))
529 length
= (* cd
->extract_operand
) (cd
, CGEN_SYNTAX_FIELD (*syn
),
530 ex_info
, insn_value
, fields
, pc
);
535 /* We recognized and successfully extracted this insn. */
536 return CGEN_INSN_BITSIZE (insn
);
539 /* machine generated code added here */
541 /* Main entry point for operand insertion.
543 This function is basically just a big switch statement. Earlier versions
544 used tables to look up the function to use, but
545 - if the table contains both assembler and disassembler functions then
546 the disassembler contains much of the assembler and vice-versa,
547 - there's a lot of inlining possibilities as things grow,
548 - using a switch statement avoids the function call overhead.
550 This function could be moved into `parse_insn_normal', but keeping it
551 separate makes clear the interface between `parse_insn_normal' and each of
552 the handlers. It's also needed by GAS to insert operands that couldn't be
553 resolved during parsing.
557 openrisc_cgen_insert_operand (cd
, opindex
, fields
, buffer
, pc
)
560 CGEN_FIELDS
* fields
;
561 CGEN_INSN_BYTES_PTR buffer
;
564 const char * errmsg
= NULL
;
565 unsigned int total_length
= CGEN_FIELDS_BITSIZE (fields
);
569 case OPENRISC_OPERAND_ABS_26
:
571 long value
= fields
->f_abs26
;
572 value
= ((unsigned int) (pc
) >> (2));
573 errmsg
= insert_normal (cd
, value
, 0|(1<<CGEN_IFLD_SIGNED
)|(1<<CGEN_IFLD_ABS_ADDR
), 0, 25, 26, 32, total_length
, buffer
);
576 case OPENRISC_OPERAND_DISP_26
:
578 long value
= fields
->f_disp26
;
579 value
= ((int) (((value
) - (pc
))) >> (2));
580 errmsg
= insert_normal (cd
, value
, 0|(1<<CGEN_IFLD_SIGNED
)|(1<<CGEN_IFLD_PCREL_ADDR
), 0, 25, 26, 32, total_length
, buffer
);
583 case OPENRISC_OPERAND_HI16
:
584 errmsg
= insert_normal (cd
, fields
->f_simm16
, 0|(1<<CGEN_IFLD_SIGNED
), 0, 15, 16, 32, total_length
, buffer
);
586 case OPENRISC_OPERAND_LO16
:
587 errmsg
= insert_normal (cd
, fields
->f_lo16
, 0|(1<<CGEN_IFLD_SIGNED
), 0, 15, 16, 32, total_length
, buffer
);
589 case OPENRISC_OPERAND_OP_F_23
:
590 errmsg
= insert_normal (cd
, fields
->f_op4
, 0, 0, 23, 3, 32, total_length
, buffer
);
592 case OPENRISC_OPERAND_OP_F_3
:
593 errmsg
= insert_normal (cd
, fields
->f_op5
, 0, 0, 25, 5, 32, total_length
, buffer
);
595 case OPENRISC_OPERAND_RA
:
596 errmsg
= insert_normal (cd
, fields
->f_r2
, 0, 0, 20, 5, 32, total_length
, buffer
);
598 case OPENRISC_OPERAND_RB
:
599 errmsg
= insert_normal (cd
, fields
->f_r3
, 0, 0, 15, 5, 32, total_length
, buffer
);
601 case OPENRISC_OPERAND_RD
:
602 errmsg
= insert_normal (cd
, fields
->f_r1
, 0, 0, 25, 5, 32, total_length
, buffer
);
604 case OPENRISC_OPERAND_SIMM_16
:
605 errmsg
= insert_normal (cd
, fields
->f_simm16
, 0|(1<<CGEN_IFLD_SIGNED
), 0, 15, 16, 32, total_length
, buffer
);
607 case OPENRISC_OPERAND_UI16NC
:
610 FLD (f_i16_2
) = ((((unsigned int) (FLD (f_i16nc
)) >> (11))) & (31));
611 FLD (f_i16_1
) = ((FLD (f_i16nc
)) & (2047));
613 errmsg
= insert_normal (cd
, fields
->f_i16_1
, 0, 0, 10, 11, 32, total_length
, buffer
);
616 errmsg
= insert_normal (cd
, fields
->f_i16_2
, 0, 0, 25, 5, 32, total_length
, buffer
);
621 case OPENRISC_OPERAND_UIMM_16
:
622 errmsg
= insert_normal (cd
, fields
->f_uimm16
, 0, 0, 15, 16, 32, total_length
, buffer
);
624 case OPENRISC_OPERAND_UIMM_5
:
625 errmsg
= insert_normal (cd
, fields
->f_uimm5
, 0, 0, 4, 5, 32, total_length
, buffer
);
629 /* xgettext:c-format */
630 fprintf (stderr
, _("Unrecognized field %d while building insn.\n"),
638 /* Main entry point for operand extraction.
639 The result is <= 0 for error, >0 for success.
640 ??? Actual values aren't well defined right now.
642 This function is basically just a big switch statement. Earlier versions
643 used tables to look up the function to use, but
644 - if the table contains both assembler and disassembler functions then
645 the disassembler contains much of the assembler and vice-versa,
646 - there's a lot of inlining possibilities as things grow,
647 - using a switch statement avoids the function call overhead.
649 This function could be moved into `print_insn_normal', but keeping it
650 separate makes clear the interface between `print_insn_normal' and each of
655 openrisc_cgen_extract_operand (cd
, opindex
, ex_info
, insn_value
, fields
, pc
)
658 CGEN_EXTRACT_INFO
*ex_info
;
659 CGEN_INSN_INT insn_value
;
660 CGEN_FIELDS
* fields
;
663 /* Assume success (for those operands that are nops). */
665 unsigned int total_length
= CGEN_FIELDS_BITSIZE (fields
);
669 case OPENRISC_OPERAND_ABS_26
:
672 length
= extract_normal (cd
, ex_info
, insn_value
, 0|(1<<CGEN_IFLD_SIGNED
)|(1<<CGEN_IFLD_ABS_ADDR
), 0, 25, 26, 32, total_length
, pc
, & value
);
673 value
= ((value
) << (2));
674 fields
->f_abs26
= value
;
677 case OPENRISC_OPERAND_DISP_26
:
680 length
= extract_normal (cd
, ex_info
, insn_value
, 0|(1<<CGEN_IFLD_SIGNED
)|(1<<CGEN_IFLD_PCREL_ADDR
), 0, 25, 26, 32, total_length
, pc
, & value
);
681 value
= ((((value
) << (2))) + (pc
));
682 fields
->f_disp26
= value
;
685 case OPENRISC_OPERAND_HI16
:
686 length
= extract_normal (cd
, ex_info
, insn_value
, 0|(1<<CGEN_IFLD_SIGNED
), 0, 15, 16, 32, total_length
, pc
, & fields
->f_simm16
);
688 case OPENRISC_OPERAND_LO16
:
689 length
= extract_normal (cd
, ex_info
, insn_value
, 0|(1<<CGEN_IFLD_SIGNED
), 0, 15, 16, 32, total_length
, pc
, & fields
->f_lo16
);
691 case OPENRISC_OPERAND_OP_F_23
:
692 length
= extract_normal (cd
, ex_info
, insn_value
, 0, 0, 23, 3, 32, total_length
, pc
, & fields
->f_op4
);
694 case OPENRISC_OPERAND_OP_F_3
:
695 length
= extract_normal (cd
, ex_info
, insn_value
, 0, 0, 25, 5, 32, total_length
, pc
, & fields
->f_op5
);
697 case OPENRISC_OPERAND_RA
:
698 length
= extract_normal (cd
, ex_info
, insn_value
, 0, 0, 20, 5, 32, total_length
, pc
, & fields
->f_r2
);
700 case OPENRISC_OPERAND_RB
:
701 length
= extract_normal (cd
, ex_info
, insn_value
, 0, 0, 15, 5, 32, total_length
, pc
, & fields
->f_r3
);
703 case OPENRISC_OPERAND_RD
:
704 length
= extract_normal (cd
, ex_info
, insn_value
, 0, 0, 25, 5, 32, total_length
, pc
, & fields
->f_r1
);
706 case OPENRISC_OPERAND_SIMM_16
:
707 length
= extract_normal (cd
, ex_info
, insn_value
, 0|(1<<CGEN_IFLD_SIGNED
), 0, 15, 16, 32, total_length
, pc
, & fields
->f_simm16
);
709 case OPENRISC_OPERAND_UI16NC
:
711 length
= extract_normal (cd
, ex_info
, insn_value
, 0, 0, 10, 11, 32, total_length
, pc
, & fields
->f_i16_1
);
712 if (length
<= 0) break;
713 length
= extract_normal (cd
, ex_info
, insn_value
, 0, 0, 25, 5, 32, total_length
, pc
, & fields
->f_i16_2
);
714 if (length
<= 0) break;
716 extern long openrisc_sign_extend_16bit
PARAMS ((long));
718 FLD (f_i16nc
) = openrisc_sign_extend_16bit (((((FLD (f_i16_2
)) << (11))) | (FLD (f_i16_1
))));
722 case OPENRISC_OPERAND_UIMM_16
:
723 length
= extract_normal (cd
, ex_info
, insn_value
, 0, 0, 15, 16, 32, total_length
, pc
, & fields
->f_uimm16
);
725 case OPENRISC_OPERAND_UIMM_5
:
726 length
= extract_normal (cd
, ex_info
, insn_value
, 0, 0, 4, 5, 32, total_length
, pc
, & fields
->f_uimm5
);
730 /* xgettext:c-format */
731 fprintf (stderr
, _("Unrecognized field %d while decoding insn.\n"),
739 cgen_insert_fn
* const openrisc_cgen_insert_handlers
[] =
744 cgen_extract_fn
* const openrisc_cgen_extract_handlers
[] =
749 /* Getting values from cgen_fields is handled by a collection of functions.
750 They are distinguished by the type of the VALUE argument they return.
751 TODO: floating point, inlining support, remove cases where result type
755 openrisc_cgen_get_int_operand (cd
, opindex
, fields
)
756 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED
;
758 const CGEN_FIELDS
* fields
;
764 case OPENRISC_OPERAND_ABS_26
:
765 value
= fields
->f_abs26
;
767 case OPENRISC_OPERAND_DISP_26
:
768 value
= fields
->f_disp26
;
770 case OPENRISC_OPERAND_HI16
:
771 value
= fields
->f_simm16
;
773 case OPENRISC_OPERAND_LO16
:
774 value
= fields
->f_lo16
;
776 case OPENRISC_OPERAND_OP_F_23
:
777 value
= fields
->f_op4
;
779 case OPENRISC_OPERAND_OP_F_3
:
780 value
= fields
->f_op5
;
782 case OPENRISC_OPERAND_RA
:
783 value
= fields
->f_r2
;
785 case OPENRISC_OPERAND_RB
:
786 value
= fields
->f_r3
;
788 case OPENRISC_OPERAND_RD
:
789 value
= fields
->f_r1
;
791 case OPENRISC_OPERAND_SIMM_16
:
792 value
= fields
->f_simm16
;
794 case OPENRISC_OPERAND_UI16NC
:
795 value
= fields
->f_i16nc
;
797 case OPENRISC_OPERAND_UIMM_16
:
798 value
= fields
->f_uimm16
;
800 case OPENRISC_OPERAND_UIMM_5
:
801 value
= fields
->f_uimm5
;
805 /* xgettext:c-format */
806 fprintf (stderr
, _("Unrecognized field %d while getting int operand.\n"),
815 openrisc_cgen_get_vma_operand (cd
, opindex
, fields
)
816 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED
;
818 const CGEN_FIELDS
* fields
;
824 case OPENRISC_OPERAND_ABS_26
:
825 value
= fields
->f_abs26
;
827 case OPENRISC_OPERAND_DISP_26
:
828 value
= fields
->f_disp26
;
830 case OPENRISC_OPERAND_HI16
:
831 value
= fields
->f_simm16
;
833 case OPENRISC_OPERAND_LO16
:
834 value
= fields
->f_lo16
;
836 case OPENRISC_OPERAND_OP_F_23
:
837 value
= fields
->f_op4
;
839 case OPENRISC_OPERAND_OP_F_3
:
840 value
= fields
->f_op5
;
842 case OPENRISC_OPERAND_RA
:
843 value
= fields
->f_r2
;
845 case OPENRISC_OPERAND_RB
:
846 value
= fields
->f_r3
;
848 case OPENRISC_OPERAND_RD
:
849 value
= fields
->f_r1
;
851 case OPENRISC_OPERAND_SIMM_16
:
852 value
= fields
->f_simm16
;
854 case OPENRISC_OPERAND_UI16NC
:
855 value
= fields
->f_i16nc
;
857 case OPENRISC_OPERAND_UIMM_16
:
858 value
= fields
->f_uimm16
;
860 case OPENRISC_OPERAND_UIMM_5
:
861 value
= fields
->f_uimm5
;
865 /* xgettext:c-format */
866 fprintf (stderr
, _("Unrecognized field %d while getting vma operand.\n"),
874 /* Stuffing values in cgen_fields is handled by a collection of functions.
875 They are distinguished by the type of the VALUE argument they accept.
876 TODO: floating point, inlining support, remove cases where argument type
880 openrisc_cgen_set_int_operand (cd
, opindex
, fields
, value
)
881 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED
;
883 CGEN_FIELDS
* fields
;
888 case OPENRISC_OPERAND_ABS_26
:
889 fields
->f_abs26
= value
;
891 case OPENRISC_OPERAND_DISP_26
:
892 fields
->f_disp26
= value
;
894 case OPENRISC_OPERAND_HI16
:
895 fields
->f_simm16
= value
;
897 case OPENRISC_OPERAND_LO16
:
898 fields
->f_lo16
= value
;
900 case OPENRISC_OPERAND_OP_F_23
:
901 fields
->f_op4
= value
;
903 case OPENRISC_OPERAND_OP_F_3
:
904 fields
->f_op5
= value
;
906 case OPENRISC_OPERAND_RA
:
907 fields
->f_r2
= value
;
909 case OPENRISC_OPERAND_RB
:
910 fields
->f_r3
= value
;
912 case OPENRISC_OPERAND_RD
:
913 fields
->f_r1
= value
;
915 case OPENRISC_OPERAND_SIMM_16
:
916 fields
->f_simm16
= value
;
918 case OPENRISC_OPERAND_UI16NC
:
919 fields
->f_i16nc
= value
;
921 case OPENRISC_OPERAND_UIMM_16
:
922 fields
->f_uimm16
= value
;
924 case OPENRISC_OPERAND_UIMM_5
:
925 fields
->f_uimm5
= value
;
929 /* xgettext:c-format */
930 fprintf (stderr
, _("Unrecognized field %d while setting int operand.\n"),
937 openrisc_cgen_set_vma_operand (cd
, opindex
, fields
, value
)
938 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED
;
940 CGEN_FIELDS
* fields
;
945 case OPENRISC_OPERAND_ABS_26
:
946 fields
->f_abs26
= value
;
948 case OPENRISC_OPERAND_DISP_26
:
949 fields
->f_disp26
= value
;
951 case OPENRISC_OPERAND_HI16
:
952 fields
->f_simm16
= value
;
954 case OPENRISC_OPERAND_LO16
:
955 fields
->f_lo16
= value
;
957 case OPENRISC_OPERAND_OP_F_23
:
958 fields
->f_op4
= value
;
960 case OPENRISC_OPERAND_OP_F_3
:
961 fields
->f_op5
= value
;
963 case OPENRISC_OPERAND_RA
:
964 fields
->f_r2
= value
;
966 case OPENRISC_OPERAND_RB
:
967 fields
->f_r3
= value
;
969 case OPENRISC_OPERAND_RD
:
970 fields
->f_r1
= value
;
972 case OPENRISC_OPERAND_SIMM_16
:
973 fields
->f_simm16
= value
;
975 case OPENRISC_OPERAND_UI16NC
:
976 fields
->f_i16nc
= value
;
978 case OPENRISC_OPERAND_UIMM_16
:
979 fields
->f_uimm16
= value
;
981 case OPENRISC_OPERAND_UIMM_5
:
982 fields
->f_uimm5
= value
;
986 /* xgettext:c-format */
987 fprintf (stderr
, _("Unrecognized field %d while setting vma operand.\n"),
993 /* Function to call before using the instruction builder tables. */
996 openrisc_cgen_init_ibld_table (cd
)
999 cd
->insert_handlers
= & openrisc_cgen_insert_handlers
[0];
1000 cd
->extract_handlers
= & openrisc_cgen_extract_handlers
[0];
1002 cd
->insert_operand
= openrisc_cgen_insert_operand
;
1003 cd
->extract_operand
= openrisc_cgen_extract_operand
;
1005 cd
->get_int_operand
= openrisc_cgen_get_int_operand
;
1006 cd
->set_int_operand
= openrisc_cgen_set_int_operand
;
1007 cd
->get_vma_operand
= openrisc_cgen_get_vma_operand
;
1008 cd
->set_vma_operand
= openrisc_cgen_set_vma_operand
;