merge from gcc
[gdb/gnu.git] / bfd / xtensa-isa.c
blobcf5543ebcdc33f811178a6b466255c69470d2d92
1 /* Configurable Xtensa ISA support.
2 Copyright 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "libbfd.h"
24 #include "xtensa-isa.h"
25 #include "xtensa-isa-internal.h"
27 xtensa_isa_status xtisa_errno;
28 char xtisa_error_msg[1024];
31 xtensa_isa_status
32 xtensa_isa_errno (xtensa_isa isa __attribute__ ((unused)))
34 return xtisa_errno;
38 char *
39 xtensa_isa_error_msg (xtensa_isa isa __attribute__ ((unused)))
41 return xtisa_error_msg;
45 #define CHECK_ALLOC(MEM,ERRVAL) \
46 do { \
47 if ((MEM) == 0) \
48 { \
49 xtisa_errno = xtensa_isa_out_of_memory; \
50 strcpy (xtisa_error_msg, "out of memory"); \
51 return (ERRVAL); \
52 } \
53 } while (0)
55 #define CHECK_ALLOC_FOR_INIT(MEM,ERRVAL,ERRNO_P,ERROR_MSG_P) \
56 do { \
57 if ((MEM) == 0) \
58 { \
59 xtisa_errno = xtensa_isa_out_of_memory; \
60 strcpy (xtisa_error_msg, "out of memory"); \
61 if (ERRNO_P) *(ERRNO_P) = xtisa_errno; \
62 if (ERROR_MSG_P) *(ERROR_MSG_P) = xtisa_error_msg; \
63 return (ERRVAL); \
64 } \
65 } while (0)
69 /* Instruction buffers. */
71 int
72 xtensa_insnbuf_size (xtensa_isa isa)
74 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
75 return intisa->insnbuf_size;
79 xtensa_insnbuf
80 xtensa_insnbuf_alloc (xtensa_isa isa)
82 xtensa_insnbuf result = (xtensa_insnbuf)
83 malloc (xtensa_insnbuf_size (isa) * sizeof (xtensa_insnbuf_word));
84 CHECK_ALLOC (result, 0);
85 return result;
89 void
90 xtensa_insnbuf_free (xtensa_isa isa __attribute__ ((unused)),
91 xtensa_insnbuf buf)
93 free (buf);
97 /* Given <byte_index>, the index of a byte in a xtensa_insnbuf, our
98 internal representation of a xtensa instruction word, return the index of
99 its word and the bit index of its low order byte in the xtensa_insnbuf. */
101 static inline int
102 byte_to_word_index (int byte_index)
104 return byte_index / sizeof (xtensa_insnbuf_word);
108 static inline int
109 byte_to_bit_index (int byte_index)
111 return (byte_index & 0x3) * 8;
115 /* Copy an instruction in the 32-bit words pointed at by "insn" to
116 characters pointed at by "cp". This is more complicated than you
117 might think because we want 16-bit instructions in bytes 2 & 3 for
118 big-endian configurations. This function allows us to specify
119 which byte in "insn" to start with and which way to increment,
120 allowing trivial implementation for both big- and little-endian
121 configurations....and it seems to make pretty good code for
122 both. */
125 xtensa_insnbuf_to_chars (xtensa_isa isa,
126 const xtensa_insnbuf insn,
127 unsigned char *cp,
128 int num_chars)
130 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
131 int insn_size = xtensa_isa_maxlength (isa);
132 int fence_post, start, increment, i, byte_count;
133 xtensa_format fmt;
135 if (num_chars == 0)
136 num_chars = insn_size;
138 if (intisa->is_big_endian)
140 start = insn_size - 1;
141 increment = -1;
143 else
145 start = 0;
146 increment = 1;
149 /* Find the instruction format. Do nothing if the buffer does not contain
150 a valid instruction since we need to know how many bytes to copy. */
151 fmt = xtensa_format_decode (isa, insn);
152 if (fmt == XTENSA_UNDEFINED)
153 return XTENSA_UNDEFINED;
155 byte_count = xtensa_format_length (isa, fmt);
156 if (byte_count == XTENSA_UNDEFINED)
157 return XTENSA_UNDEFINED;
159 if (byte_count > num_chars)
161 xtisa_errno = xtensa_isa_buffer_overflow;
162 strcpy (xtisa_error_msg, "output buffer too small for instruction");
163 return XTENSA_UNDEFINED;
166 fence_post = start + (byte_count * increment);
168 for (i = start; i != fence_post; i += increment, ++cp)
170 int word_inx = byte_to_word_index (i);
171 int bit_inx = byte_to_bit_index (i);
173 *cp = (insn[word_inx] >> bit_inx) & 0xff;
176 return byte_count;
180 /* Inward conversion from byte stream to xtensa_insnbuf. See
181 xtensa_insnbuf_to_chars for a discussion of why this is complicated
182 by endianness. */
184 void
185 xtensa_insnbuf_from_chars (xtensa_isa isa,
186 xtensa_insnbuf insn,
187 const unsigned char *cp,
188 int num_chars)
190 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
191 int max_size, insn_size, fence_post, start, increment, i;
193 max_size = xtensa_isa_maxlength (isa);
195 /* Decode the instruction length so we know how many bytes to read. */
196 insn_size = (intisa->length_decode_fn) (cp);
197 if (insn_size == XTENSA_UNDEFINED)
199 /* This should never happen when the byte stream contains a
200 valid instruction. Just read the maximum number of bytes.... */
201 insn_size = max_size;
204 if (num_chars == 0 || num_chars > insn_size)
205 num_chars = insn_size;
207 if (intisa->is_big_endian)
209 start = max_size - 1;
210 increment = -1;
212 else
214 start = 0;
215 increment = 1;
218 fence_post = start + (num_chars * increment);
219 memset (insn, 0, xtensa_insnbuf_size (isa) * sizeof (xtensa_insnbuf_word));
221 for (i = start; i != fence_post; i += increment, ++cp)
223 int word_inx = byte_to_word_index (i);
224 int bit_inx = byte_to_bit_index (i);
226 insn[word_inx] |= (*cp & 0xff) << bit_inx;
232 /* ISA information. */
234 extern xtensa_isa_internal xtensa_modules;
236 xtensa_isa
237 xtensa_isa_init (xtensa_isa_status *errno_p, char **error_msg_p)
239 xtensa_isa_internal *isa = &xtensa_modules;
240 int n, is_user;
242 /* Set up the opcode name lookup table. */
243 isa->opname_lookup_table =
244 bfd_malloc (isa->num_opcodes * sizeof (xtensa_lookup_entry));
245 CHECK_ALLOC_FOR_INIT (isa->opname_lookup_table, NULL, errno_p, error_msg_p);
246 for (n = 0; n < isa->num_opcodes; n++)
248 isa->opname_lookup_table[n].key = isa->opcodes[n].name;
249 isa->opname_lookup_table[n].u.opcode = n;
251 qsort (isa->opname_lookup_table, isa->num_opcodes,
252 sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
254 /* Set up the state name lookup table. */
255 isa->state_lookup_table =
256 bfd_malloc (isa->num_states * sizeof (xtensa_lookup_entry));
257 CHECK_ALLOC_FOR_INIT (isa->state_lookup_table, NULL, errno_p, error_msg_p);
258 for (n = 0; n < isa->num_states; n++)
260 isa->state_lookup_table[n].key = isa->states[n].name;
261 isa->state_lookup_table[n].u.state = n;
263 qsort (isa->state_lookup_table, isa->num_states,
264 sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
266 /* Set up the sysreg name lookup table. */
267 isa->sysreg_lookup_table =
268 bfd_malloc (isa->num_sysregs * sizeof (xtensa_lookup_entry));
269 CHECK_ALLOC_FOR_INIT (isa->sysreg_lookup_table, NULL, errno_p, error_msg_p);
270 for (n = 0; n < isa->num_sysregs; n++)
272 isa->sysreg_lookup_table[n].key = isa->sysregs[n].name;
273 isa->sysreg_lookup_table[n].u.sysreg = n;
275 qsort (isa->sysreg_lookup_table, isa->num_sysregs,
276 sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
278 /* Set up the user & system sysreg number tables. */
279 for (is_user = 0; is_user < 2; is_user++)
281 isa->sysreg_table[is_user] =
282 bfd_malloc ((isa->max_sysreg_num[is_user] + 1)
283 * sizeof (xtensa_sysreg));
284 CHECK_ALLOC_FOR_INIT (isa->sysreg_table[is_user], NULL,
285 errno_p, error_msg_p);
287 for (n = 0; n <= isa->max_sysreg_num[is_user]; n++)
288 isa->sysreg_table[is_user][n] = XTENSA_UNDEFINED;
290 for (n = 0; n < isa->num_sysregs; n++)
292 xtensa_sysreg_internal *sreg = &isa->sysregs[n];
293 is_user = sreg->is_user;
295 isa->sysreg_table[is_user][sreg->number] = n;
298 /* Set up the interface lookup table. */
299 isa->interface_lookup_table =
300 bfd_malloc (isa->num_interfaces * sizeof (xtensa_lookup_entry));
301 CHECK_ALLOC_FOR_INIT (isa->interface_lookup_table, NULL, errno_p,
302 error_msg_p);
303 for (n = 0; n < isa->num_interfaces; n++)
305 isa->interface_lookup_table[n].key = isa->interfaces[n].name;
306 isa->interface_lookup_table[n].u.intf = n;
308 qsort (isa->interface_lookup_table, isa->num_interfaces,
309 sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
311 /* Set up the funcUnit lookup table. */
312 isa->funcUnit_lookup_table =
313 bfd_malloc (isa->num_funcUnits * sizeof (xtensa_lookup_entry));
314 CHECK_ALLOC_FOR_INIT (isa->funcUnit_lookup_table, NULL, errno_p,
315 error_msg_p);
316 for (n = 0; n < isa->num_funcUnits; n++)
318 isa->funcUnit_lookup_table[n].key = isa->funcUnits[n].name;
319 isa->funcUnit_lookup_table[n].u.fun = n;
321 qsort (isa->funcUnit_lookup_table, isa->num_funcUnits,
322 sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
324 isa->insnbuf_size = ((isa->insn_size + sizeof (xtensa_insnbuf_word) - 1) /
325 sizeof (xtensa_insnbuf_word));
327 return (xtensa_isa) isa;
331 void
332 xtensa_isa_free (xtensa_isa isa)
334 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
335 int n;
337 /* With this version of the code, the xtensa_isa structure is not
338 dynamically allocated, so this function is not essential. Free
339 the memory allocated by xtensa_isa_init and restore the xtensa_isa
340 structure to its initial state. */
342 if (intisa->opname_lookup_table)
344 free (intisa->opname_lookup_table);
345 intisa->opname_lookup_table = 0;
348 if (intisa->state_lookup_table)
350 free (intisa->state_lookup_table);
351 intisa->state_lookup_table = 0;
354 if (intisa->sysreg_lookup_table)
356 free (intisa->sysreg_lookup_table);
357 intisa->sysreg_lookup_table = 0;
359 for (n = 0; n < 2; n++)
361 if (intisa->sysreg_table[n])
363 free (intisa->sysreg_table[n]);
364 intisa->sysreg_table[n] = 0;
368 if (intisa->interface_lookup_table)
370 free (intisa->interface_lookup_table);
371 intisa->interface_lookup_table = 0;
374 if (intisa->funcUnit_lookup_table)
376 free (intisa->funcUnit_lookup_table);
377 intisa->funcUnit_lookup_table = 0;
383 xtensa_isa_name_compare (const void *v1, const void *v2)
385 xtensa_lookup_entry *e1 = (xtensa_lookup_entry *) v1;
386 xtensa_lookup_entry *e2 = (xtensa_lookup_entry *) v2;
388 return strcasecmp (e1->key, e2->key);
393 xtensa_isa_maxlength (xtensa_isa isa)
395 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
396 return intisa->insn_size;
401 xtensa_isa_length_from_chars (xtensa_isa isa, const unsigned char *cp)
403 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
404 return (intisa->length_decode_fn) (cp);
409 xtensa_isa_num_pipe_stages (xtensa_isa isa)
411 xtensa_opcode opcode;
412 xtensa_funcUnit_use *use;
413 int num_opcodes, num_uses;
414 int i, stage;
415 static int max_stage = XTENSA_UNDEFINED;
417 /* Only compute the value once. */
418 if (max_stage != XTENSA_UNDEFINED)
419 return max_stage + 1;
421 num_opcodes = xtensa_isa_num_opcodes (isa);
422 for (opcode = 0; opcode < num_opcodes; opcode++)
424 num_uses = xtensa_opcode_num_funcUnit_uses (isa, opcode);
425 for (i = 0; i < num_uses; i++)
427 use = xtensa_opcode_funcUnit_use (isa, opcode, i);
428 stage = use->stage;
429 if (stage > max_stage)
430 max_stage = stage;
434 return max_stage + 1;
439 xtensa_isa_num_formats (xtensa_isa isa)
441 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
442 return intisa->num_formats;
447 xtensa_isa_num_opcodes (xtensa_isa isa)
449 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
450 return intisa->num_opcodes;
455 xtensa_isa_num_regfiles (xtensa_isa isa)
457 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
458 return intisa->num_regfiles;
463 xtensa_isa_num_states (xtensa_isa isa)
465 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
466 return intisa->num_states;
471 xtensa_isa_num_sysregs (xtensa_isa isa)
473 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
474 return intisa->num_sysregs;
479 xtensa_isa_num_interfaces (xtensa_isa isa)
481 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
482 return intisa->num_interfaces;
487 xtensa_isa_num_funcUnits (xtensa_isa isa)
489 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
490 return intisa->num_funcUnits;
495 /* Instruction formats. */
498 #define CHECK_FORMAT(INTISA,FMT,ERRVAL) \
499 do { \
500 if ((FMT) < 0 || (FMT) >= (INTISA)->num_formats) \
502 xtisa_errno = xtensa_isa_bad_format; \
503 strcpy (xtisa_error_msg, "invalid format specifier"); \
504 return (ERRVAL); \
506 } while (0)
509 #define CHECK_SLOT(INTISA,FMT,SLOT,ERRVAL) \
510 do { \
511 if ((SLOT) < 0 || (SLOT) >= (INTISA)->formats[FMT].num_slots) \
513 xtisa_errno = xtensa_isa_bad_slot; \
514 strcpy (xtisa_error_msg, "invalid slot specifier"); \
515 return (ERRVAL); \
517 } while (0)
520 const char *
521 xtensa_format_name (xtensa_isa isa, xtensa_format fmt)
523 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
524 CHECK_FORMAT (intisa, fmt, NULL);
525 return intisa->formats[fmt].name;
529 xtensa_format
530 xtensa_format_lookup (xtensa_isa isa, const char *fmtname)
532 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
533 int fmt;
535 if (!fmtname || !*fmtname)
537 xtisa_errno = xtensa_isa_bad_format;
538 strcpy (xtisa_error_msg, "invalid format name");
539 return XTENSA_UNDEFINED;
542 for (fmt = 0; fmt < intisa->num_formats; fmt++)
544 if (strcasecmp (fmtname, intisa->formats[fmt].name) == 0)
545 return fmt;
548 xtisa_errno = xtensa_isa_bad_format;
549 sprintf (xtisa_error_msg, "format \"%s\" not recognized", fmtname);
550 return XTENSA_UNDEFINED;
554 xtensa_format
555 xtensa_format_decode (xtensa_isa isa, const xtensa_insnbuf insn)
557 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
558 xtensa_format fmt;
560 fmt = (intisa->format_decode_fn) (insn);
561 if (fmt != XTENSA_UNDEFINED)
562 return fmt;
564 xtisa_errno = xtensa_isa_bad_format;
565 strcpy (xtisa_error_msg, "cannot decode instruction format");
566 return XTENSA_UNDEFINED;
571 xtensa_format_encode (xtensa_isa isa, xtensa_format fmt, xtensa_insnbuf insn)
573 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
574 CHECK_FORMAT (intisa, fmt, -1);
575 (*intisa->formats[fmt].encode_fn) (insn);
576 return 0;
581 xtensa_format_length (xtensa_isa isa, xtensa_format fmt)
583 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
584 CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
585 return intisa->formats[fmt].length;
590 xtensa_format_num_slots (xtensa_isa isa, xtensa_format fmt)
592 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
593 CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
594 return intisa->formats[fmt].num_slots;
598 xtensa_opcode
599 xtensa_format_slot_nop_opcode (xtensa_isa isa, xtensa_format fmt, int slot)
601 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
602 int slot_id;
604 CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
605 CHECK_SLOT (intisa, fmt, slot, XTENSA_UNDEFINED);
607 slot_id = intisa->formats[fmt].slot_id[slot];
608 return xtensa_opcode_lookup (isa, intisa->slots[slot_id].nop_name);
613 xtensa_format_get_slot (xtensa_isa isa, xtensa_format fmt, int slot,
614 const xtensa_insnbuf insn, xtensa_insnbuf slotbuf)
616 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
617 int slot_id;
619 CHECK_FORMAT (intisa, fmt, -1);
620 CHECK_SLOT (intisa, fmt, slot, -1);
622 slot_id = intisa->formats[fmt].slot_id[slot];
623 (*intisa->slots[slot_id].get_fn) (insn, slotbuf);
624 return 0;
629 xtensa_format_set_slot (xtensa_isa isa, xtensa_format fmt, int slot,
630 xtensa_insnbuf insn, const xtensa_insnbuf slotbuf)
632 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
633 int slot_id;
635 CHECK_FORMAT (intisa, fmt, -1);
636 CHECK_SLOT (intisa, fmt, slot, -1);
638 slot_id = intisa->formats[fmt].slot_id[slot];
639 (*intisa->slots[slot_id].set_fn) (insn, slotbuf);
640 return 0;
645 /* Opcode information. */
648 #define CHECK_OPCODE(INTISA,OPC,ERRVAL) \
649 do { \
650 if ((OPC) < 0 || (OPC) >= (INTISA)->num_opcodes) \
652 xtisa_errno = xtensa_isa_bad_opcode; \
653 strcpy (xtisa_error_msg, "invalid opcode specifier"); \
654 return (ERRVAL); \
656 } while (0)
659 xtensa_opcode
660 xtensa_opcode_lookup (xtensa_isa isa, const char *opname)
662 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
663 xtensa_lookup_entry entry, *result = 0;
665 if (!opname || !*opname)
667 xtisa_errno = xtensa_isa_bad_opcode;
668 strcpy (xtisa_error_msg, "invalid opcode name");
669 return XTENSA_UNDEFINED;
672 if (intisa->num_opcodes != 0)
674 entry.key = opname;
675 result = bsearch (&entry, intisa->opname_lookup_table,
676 intisa->num_opcodes, sizeof (xtensa_lookup_entry),
677 xtensa_isa_name_compare);
680 if (!result)
682 xtisa_errno = xtensa_isa_bad_opcode;
683 sprintf (xtisa_error_msg, "opcode \"%s\" not recognized", opname);
684 return XTENSA_UNDEFINED;
687 return result->u.opcode;
691 xtensa_opcode
692 xtensa_opcode_decode (xtensa_isa isa, xtensa_format fmt, int slot,
693 const xtensa_insnbuf slotbuf)
695 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
696 int slot_id;
697 xtensa_opcode opc;
699 CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
700 CHECK_SLOT (intisa, fmt, slot, XTENSA_UNDEFINED);
702 slot_id = intisa->formats[fmt].slot_id[slot];
704 opc = (intisa->slots[slot_id].opcode_decode_fn) (slotbuf);
705 if (opc != XTENSA_UNDEFINED)
706 return opc;
708 xtisa_errno = xtensa_isa_bad_opcode;
709 strcpy (xtisa_error_msg, "cannot decode opcode");
710 return XTENSA_UNDEFINED;
715 xtensa_opcode_encode (xtensa_isa isa, xtensa_format fmt, int slot,
716 xtensa_insnbuf slotbuf, xtensa_opcode opc)
718 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
719 int slot_id;
720 xtensa_opcode_encode_fn encode_fn;
722 CHECK_FORMAT (intisa, fmt, -1);
723 CHECK_SLOT (intisa, fmt, slot, -1);
724 CHECK_OPCODE (intisa, opc, -1);
726 slot_id = intisa->formats[fmt].slot_id[slot];
727 encode_fn = intisa->opcodes[opc].encode_fns[slot_id];
728 if (!encode_fn)
730 xtisa_errno = xtensa_isa_wrong_slot;
731 sprintf (xtisa_error_msg,
732 "opcode \"%s\" is not allowed in slot %d of format \"%s\"",
733 intisa->opcodes[opc].name, slot, intisa->formats[fmt].name);
734 return -1;
736 (*encode_fn) (slotbuf);
737 return 0;
741 const char *
742 xtensa_opcode_name (xtensa_isa isa, xtensa_opcode opc)
744 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
745 CHECK_OPCODE (intisa, opc, NULL);
746 return intisa->opcodes[opc].name;
751 xtensa_opcode_is_branch (xtensa_isa isa, xtensa_opcode opc)
753 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
754 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
755 if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_BRANCH) != 0)
756 return 1;
757 return 0;
762 xtensa_opcode_is_jump (xtensa_isa isa, xtensa_opcode opc)
764 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
765 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
766 if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_JUMP) != 0)
767 return 1;
768 return 0;
773 xtensa_opcode_is_loop (xtensa_isa isa, xtensa_opcode opc)
775 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
776 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
777 if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_LOOP) != 0)
778 return 1;
779 return 0;
784 xtensa_opcode_is_call (xtensa_isa isa, xtensa_opcode opc)
786 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
787 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
788 if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_CALL) != 0)
789 return 1;
790 return 0;
795 xtensa_opcode_num_operands (xtensa_isa isa, xtensa_opcode opc)
797 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
798 int iclass_id;
800 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
801 iclass_id = intisa->opcodes[opc].iclass_id;
802 return intisa->iclasses[iclass_id].num_operands;
807 xtensa_opcode_num_stateOperands (xtensa_isa isa, xtensa_opcode opc)
809 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
810 int iclass_id;
812 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
813 iclass_id = intisa->opcodes[opc].iclass_id;
814 return intisa->iclasses[iclass_id].num_stateOperands;
819 xtensa_opcode_num_interfaceOperands (xtensa_isa isa, xtensa_opcode opc)
821 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
822 int iclass_id;
824 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
825 iclass_id = intisa->opcodes[opc].iclass_id;
826 return intisa->iclasses[iclass_id].num_interfaceOperands;
831 xtensa_opcode_num_funcUnit_uses (xtensa_isa isa, xtensa_opcode opc)
833 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
834 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
835 return intisa->opcodes[opc].num_funcUnit_uses;
839 xtensa_funcUnit_use *
840 xtensa_opcode_funcUnit_use (xtensa_isa isa, xtensa_opcode opc, int u)
842 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
843 CHECK_OPCODE (intisa, opc, NULL);
844 if (u < 0 || u >= intisa->opcodes[opc].num_funcUnit_uses)
846 xtisa_errno = xtensa_isa_bad_funcUnit;
847 sprintf (xtisa_error_msg, "invalid functional unit use number (%d); "
848 "opcode \"%s\" has %d", u, intisa->opcodes[opc].name,
849 intisa->opcodes[opc].num_funcUnit_uses);
850 return NULL;
852 return &intisa->opcodes[opc].funcUnit_uses[u];
857 /* Operand information. */
860 #define CHECK_OPERAND(INTISA,OPC,ICLASS,OPND,ERRVAL) \
861 do { \
862 if ((OPND) < 0 || (OPND) >= (ICLASS)->num_operands) \
864 xtisa_errno = xtensa_isa_bad_operand; \
865 sprintf (xtisa_error_msg, "invalid operand number (%d); " \
866 "opcode \"%s\" has %d operands", (OPND), \
867 (INTISA)->opcodes[(OPC)].name, (ICLASS)->num_operands); \
868 return (ERRVAL); \
870 } while (0)
873 static xtensa_operand_internal *
874 get_operand (xtensa_isa_internal *intisa, xtensa_opcode opc, int opnd)
876 xtensa_iclass_internal *iclass;
877 int iclass_id, operand_id;
879 CHECK_OPCODE (intisa, opc, NULL);
880 iclass_id = intisa->opcodes[opc].iclass_id;
881 iclass = &intisa->iclasses[iclass_id];
882 CHECK_OPERAND (intisa, opc, iclass, opnd, NULL);
883 operand_id = iclass->operands[opnd].u.operand_id;
884 return &intisa->operands[operand_id];
888 const char *
889 xtensa_operand_name (xtensa_isa isa, xtensa_opcode opc, int opnd)
891 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
892 xtensa_operand_internal *intop;
894 intop = get_operand (intisa, opc, opnd);
895 if (!intop) return NULL;
896 return intop->name;
901 xtensa_operand_is_visible (xtensa_isa isa, xtensa_opcode opc, int opnd)
903 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
904 xtensa_iclass_internal *iclass;
905 int iclass_id, operand_id;
906 xtensa_operand_internal *intop;
908 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
909 iclass_id = intisa->opcodes[opc].iclass_id;
910 iclass = &intisa->iclasses[iclass_id];
911 CHECK_OPERAND (intisa, opc, iclass, opnd, XTENSA_UNDEFINED);
913 /* Special case for "sout" operands. */
914 if (iclass->operands[opnd].inout == 's')
915 return 0;
917 operand_id = iclass->operands[opnd].u.operand_id;
918 intop = &intisa->operands[operand_id];
920 if ((intop->flags & XTENSA_OPERAND_IS_INVISIBLE) == 0)
921 return 1;
922 return 0;
926 char
927 xtensa_operand_inout (xtensa_isa isa, xtensa_opcode opc, int opnd)
929 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
930 xtensa_iclass_internal *iclass;
931 int iclass_id;
932 char inout;
934 CHECK_OPCODE (intisa, opc, 0);
935 iclass_id = intisa->opcodes[opc].iclass_id;
936 iclass = &intisa->iclasses[iclass_id];
937 CHECK_OPERAND (intisa, opc, iclass, opnd, 0);
938 inout = iclass->operands[opnd].inout;
940 /* Special case for "sout" operands. */
941 if (inout == 's')
942 return 'o';
944 return inout;
949 xtensa_operand_get_field (xtensa_isa isa, xtensa_opcode opc, int opnd,
950 xtensa_format fmt, int slot,
951 const xtensa_insnbuf slotbuf, uint32 *valp)
953 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
954 xtensa_operand_internal *intop;
955 int slot_id;
956 xtensa_get_field_fn get_fn;
958 intop = get_operand (intisa, opc, opnd);
959 if (!intop) return -1;
961 CHECK_FORMAT (intisa, fmt, -1);
962 CHECK_SLOT (intisa, fmt, slot, -1);
964 slot_id = intisa->formats[fmt].slot_id[slot];
965 if (intop->field_id == XTENSA_UNDEFINED)
967 xtisa_errno = xtensa_isa_no_field;
968 strcpy (xtisa_error_msg, "implicit operand has no field");
969 return -1;
971 get_fn = intisa->slots[slot_id].get_field_fns[intop->field_id];
972 if (!get_fn)
974 xtisa_errno = xtensa_isa_wrong_slot;
975 sprintf (xtisa_error_msg,
976 "operand \"%s\" does not exist in slot %d of format \"%s\"",
977 intop->name, slot, intisa->formats[fmt].name);
978 return -1;
980 *valp = (*get_fn) (slotbuf);
981 return 0;
986 xtensa_operand_set_field (xtensa_isa isa, xtensa_opcode opc, int opnd,
987 xtensa_format fmt, int slot,
988 xtensa_insnbuf slotbuf, uint32 val)
990 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
991 xtensa_operand_internal *intop;
992 int slot_id;
993 xtensa_set_field_fn set_fn;
995 intop = get_operand (intisa, opc, opnd);
996 if (!intop) return -1;
998 CHECK_FORMAT (intisa, fmt, -1);
999 CHECK_SLOT (intisa, fmt, slot, -1);
1001 slot_id = intisa->formats[fmt].slot_id[slot];
1002 if (intop->field_id == XTENSA_UNDEFINED)
1004 xtisa_errno = xtensa_isa_no_field;
1005 strcpy (xtisa_error_msg, "implicit operand has no field");
1006 return -1;
1008 set_fn = intisa->slots[slot_id].set_field_fns[intop->field_id];
1009 if (!set_fn)
1011 xtisa_errno = xtensa_isa_wrong_slot;
1012 sprintf (xtisa_error_msg,
1013 "operand \"%s\" does not exist in slot %d of format \"%s\"",
1014 intop->name, slot, intisa->formats[fmt].name);
1015 return -1;
1017 (*set_fn) (slotbuf, val);
1018 return 0;
1023 xtensa_operand_encode (xtensa_isa isa, xtensa_opcode opc, int opnd,
1024 uint32 *valp)
1026 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1027 xtensa_operand_internal *intop;
1028 uint32 test_val, orig_val;
1030 intop = get_operand (intisa, opc, opnd);
1031 if (!intop)
1032 return -1;
1034 if (!intop->encode)
1036 /* This is a default operand for a field. How can we tell if the
1037 value fits in the field? Write the value into the field,
1038 read it back, and then make sure we get the same value. */
1039 static xtensa_insnbuf tmpbuf = 0;
1040 int slot_id;
1042 if (!tmpbuf)
1044 tmpbuf = xtensa_insnbuf_alloc (isa);
1045 CHECK_ALLOC (tmpbuf, -1);
1048 /* A default operand is always associated with a field,
1049 but check just to be sure.... */
1050 if (intop->field_id == XTENSA_UNDEFINED)
1052 xtisa_errno = xtensa_isa_internal_error;
1053 strcpy (xtisa_error_msg, "operand has no field");
1054 return -1;
1057 /* Find some slot that includes the field. */
1058 for (slot_id = 0; slot_id < intisa->num_slots; slot_id++)
1060 xtensa_get_field_fn get_fn =
1061 intisa->slots[slot_id].get_field_fns[intop->field_id];
1062 xtensa_set_field_fn set_fn =
1063 intisa->slots[slot_id].set_field_fns[intop->field_id];
1065 if (get_fn && set_fn)
1067 (*set_fn) (tmpbuf, *valp);
1068 return ((*get_fn) (tmpbuf) != *valp);
1072 /* Couldn't find any slot containing the field.... */
1073 xtisa_errno = xtensa_isa_no_field;
1074 strcpy (xtisa_error_msg, "field does not exist in any slot");
1075 return -1;
1078 /* Encode the value. In some cases, the encoding function may detect
1079 errors, but most of the time the only way to determine if the value
1080 was successfully encoded is to decode it and check if it matches
1081 the original value. */
1082 orig_val = *valp;
1083 if ((*intop->encode) (valp)
1084 || (test_val = *valp, (*intop->decode) (&test_val))
1085 || test_val != orig_val)
1087 xtisa_errno = xtensa_isa_bad_value;
1088 sprintf (xtisa_error_msg, "cannot encode operand value 0x%08x", *valp);
1089 return -1;
1092 return 0;
1097 xtensa_operand_decode (xtensa_isa isa, xtensa_opcode opc, int opnd,
1098 uint32 *valp)
1100 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1101 xtensa_operand_internal *intop;
1103 intop = get_operand (intisa, opc, opnd);
1104 if (!intop) return -1;
1106 /* Use identity function for "default" operands. */
1107 if (!intop->decode)
1108 return 0;
1110 if ((*intop->decode) (valp))
1112 xtisa_errno = xtensa_isa_bad_value;
1113 sprintf (xtisa_error_msg, "cannot decode operand value 0x%08x", *valp);
1114 return -1;
1116 return 0;
1121 xtensa_operand_is_register (xtensa_isa isa, xtensa_opcode opc, int opnd)
1123 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1124 xtensa_operand_internal *intop;
1126 intop = get_operand (intisa, opc, opnd);
1127 if (!intop) return XTENSA_UNDEFINED;
1129 if ((intop->flags & XTENSA_OPERAND_IS_REGISTER) != 0)
1130 return 1;
1131 return 0;
1135 xtensa_regfile
1136 xtensa_operand_regfile (xtensa_isa isa, xtensa_opcode opc, int opnd)
1138 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1139 xtensa_operand_internal *intop;
1141 intop = get_operand (intisa, opc, opnd);
1142 if (!intop) return XTENSA_UNDEFINED;
1144 return intop->regfile;
1149 xtensa_operand_num_regs (xtensa_isa isa, xtensa_opcode opc, int opnd)
1151 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1152 xtensa_operand_internal *intop;
1154 intop = get_operand (intisa, opc, opnd);
1155 if (!intop) return XTENSA_UNDEFINED;
1157 return intop->num_regs;
1162 xtensa_operand_is_known_reg (xtensa_isa isa, xtensa_opcode opc, int opnd)
1164 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1165 xtensa_operand_internal *intop;
1167 intop = get_operand (intisa, opc, opnd);
1168 if (!intop) return XTENSA_UNDEFINED;
1170 if ((intop->flags & XTENSA_OPERAND_IS_UNKNOWN) == 0)
1171 return 1;
1172 return 0;
1177 xtensa_operand_is_PCrelative (xtensa_isa isa, xtensa_opcode opc, int opnd)
1179 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1180 xtensa_operand_internal *intop;
1182 intop = get_operand (intisa, opc, opnd);
1183 if (!intop) return XTENSA_UNDEFINED;
1185 if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) != 0)
1186 return 1;
1187 return 0;
1192 xtensa_operand_do_reloc (xtensa_isa isa, xtensa_opcode opc, int opnd,
1193 uint32 *valp, uint32 pc)
1195 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1196 xtensa_operand_internal *intop;
1198 intop = get_operand (intisa, opc, opnd);
1199 if (!intop) return -1;
1201 if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) == 0)
1202 return 0;
1204 if (!intop->do_reloc)
1206 xtisa_errno = xtensa_isa_internal_error;
1207 strcpy (xtisa_error_msg, "operand missing do_reloc function");
1208 return -1;
1211 if ((*intop->do_reloc) (valp, pc))
1213 xtisa_errno = xtensa_isa_bad_value;
1214 sprintf (xtisa_error_msg,
1215 "do_reloc failed for value 0x%08x at PC 0x%08x", *valp, pc);
1216 return -1;
1219 return 0;
1224 xtensa_operand_undo_reloc (xtensa_isa isa, xtensa_opcode opc, int opnd,
1225 uint32 *valp, uint32 pc)
1227 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1228 xtensa_operand_internal *intop;
1230 intop = get_operand (intisa, opc, opnd);
1231 if (!intop) return -1;
1233 if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) == 0)
1234 return 0;
1236 if (!intop->undo_reloc)
1238 xtisa_errno = xtensa_isa_internal_error;
1239 strcpy (xtisa_error_msg, "operand missing undo_reloc function");
1240 return -1;
1243 if ((*intop->undo_reloc) (valp, pc))
1245 xtisa_errno = xtensa_isa_bad_value;
1246 sprintf (xtisa_error_msg,
1247 "undo_reloc failed for value 0x%08x at PC 0x%08x", *valp, pc);
1248 return -1;
1251 return 0;
1256 /* State Operands. */
1259 #define CHECK_STATE_OPERAND(INTISA,OPC,ICLASS,STOP,ERRVAL) \
1260 do { \
1261 if ((STOP) < 0 || (STOP) >= (ICLASS)->num_stateOperands) \
1263 xtisa_errno = xtensa_isa_bad_operand; \
1264 sprintf (xtisa_error_msg, "invalid state operand number (%d); " \
1265 "opcode \"%s\" has %d state operands", (STOP), \
1266 (INTISA)->opcodes[(OPC)].name, (ICLASS)->num_stateOperands); \
1267 return (ERRVAL); \
1269 } while (0)
1272 xtensa_state
1273 xtensa_stateOperand_state (xtensa_isa isa, xtensa_opcode opc, int stOp)
1275 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1276 xtensa_iclass_internal *iclass;
1277 int iclass_id;
1279 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
1280 iclass_id = intisa->opcodes[opc].iclass_id;
1281 iclass = &intisa->iclasses[iclass_id];
1282 CHECK_STATE_OPERAND (intisa, opc, iclass, stOp, XTENSA_UNDEFINED);
1283 return iclass->stateOperands[stOp].u.state;
1287 char
1288 xtensa_stateOperand_inout (xtensa_isa isa, xtensa_opcode opc, int stOp)
1290 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1291 xtensa_iclass_internal *iclass;
1292 int iclass_id;
1294 CHECK_OPCODE (intisa, opc, 0);
1295 iclass_id = intisa->opcodes[opc].iclass_id;
1296 iclass = &intisa->iclasses[iclass_id];
1297 CHECK_STATE_OPERAND (intisa, opc, iclass, stOp, 0);
1298 return iclass->stateOperands[stOp].inout;
1303 /* Interface Operands. */
1306 #define CHECK_INTERFACE_OPERAND(INTISA,OPC,ICLASS,IFOP,ERRVAL) \
1307 do { \
1308 if ((IFOP) < 0 || (IFOP) >= (ICLASS)->num_interfaceOperands) \
1310 xtisa_errno = xtensa_isa_bad_operand; \
1311 sprintf (xtisa_error_msg, "invalid interface operand number (%d); " \
1312 "opcode \"%s\" has %d interface operands", (IFOP), \
1313 (INTISA)->opcodes[(OPC)].name, \
1314 (ICLASS)->num_interfaceOperands); \
1315 return (ERRVAL); \
1317 } while (0)
1320 xtensa_interface
1321 xtensa_interfaceOperand_interface (xtensa_isa isa, xtensa_opcode opc,
1322 int ifOp)
1324 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1325 xtensa_iclass_internal *iclass;
1326 int iclass_id;
1328 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
1329 iclass_id = intisa->opcodes[opc].iclass_id;
1330 iclass = &intisa->iclasses[iclass_id];
1331 CHECK_INTERFACE_OPERAND (intisa, opc, iclass, ifOp, XTENSA_UNDEFINED);
1332 return iclass->interfaceOperands[ifOp];
1337 /* Register Files. */
1340 #define CHECK_REGFILE(INTISA,RF,ERRVAL) \
1341 do { \
1342 if ((RF) < 0 || (RF) >= (INTISA)->num_regfiles) \
1344 xtisa_errno = xtensa_isa_bad_regfile; \
1345 strcpy (xtisa_error_msg, "invalid regfile specifier"); \
1346 return (ERRVAL); \
1348 } while (0)
1351 xtensa_regfile
1352 xtensa_regfile_lookup (xtensa_isa isa, const char *name)
1354 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1355 int n;
1357 if (!name || !*name)
1359 xtisa_errno = xtensa_isa_bad_regfile;
1360 strcpy (xtisa_error_msg, "invalid regfile name");
1361 return XTENSA_UNDEFINED;
1364 /* The expected number of regfiles is small; use a linear search. */
1365 for (n = 0; n < intisa->num_regfiles; n++)
1367 if (!filename_cmp (intisa->regfiles[n].name, name))
1368 return n;
1371 xtisa_errno = xtensa_isa_bad_regfile;
1372 sprintf (xtisa_error_msg, "regfile \"%s\" not recognized", name);
1373 return XTENSA_UNDEFINED;
1377 xtensa_regfile
1378 xtensa_regfile_lookup_shortname (xtensa_isa isa, const char *shortname)
1380 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1381 int n;
1383 if (!shortname || !*shortname)
1385 xtisa_errno = xtensa_isa_bad_regfile;
1386 strcpy (xtisa_error_msg, "invalid regfile shortname");
1387 return XTENSA_UNDEFINED;
1390 /* The expected number of regfiles is small; use a linear search. */
1391 for (n = 0; n < intisa->num_regfiles; n++)
1393 /* Ignore regfile views since they always have the same shortnames
1394 as their parents. */
1395 if (intisa->regfiles[n].parent != n)
1396 continue;
1397 if (!filename_cmp (intisa->regfiles[n].shortname, shortname))
1398 return n;
1401 xtisa_errno = xtensa_isa_bad_regfile;
1402 sprintf (xtisa_error_msg, "regfile shortname \"%s\" not recognized",
1403 shortname);
1404 return XTENSA_UNDEFINED;
1408 const char *
1409 xtensa_regfile_name (xtensa_isa isa, xtensa_regfile rf)
1411 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1412 CHECK_REGFILE (intisa, rf, NULL);
1413 return intisa->regfiles[rf].name;
1417 const char *
1418 xtensa_regfile_shortname (xtensa_isa isa, xtensa_regfile rf)
1420 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1421 CHECK_REGFILE (intisa, rf, NULL);
1422 return intisa->regfiles[rf].shortname;
1426 xtensa_regfile
1427 xtensa_regfile_view_parent (xtensa_isa isa, xtensa_regfile rf)
1429 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1430 CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
1431 return intisa->regfiles[rf].parent;
1436 xtensa_regfile_num_bits (xtensa_isa isa, xtensa_regfile rf)
1438 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1439 CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
1440 return intisa->regfiles[rf].num_bits;
1445 xtensa_regfile_num_entries (xtensa_isa isa, xtensa_regfile rf)
1447 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1448 CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
1449 return intisa->regfiles[rf].num_entries;
1454 /* Processor States. */
1457 #define CHECK_STATE(INTISA,ST,ERRVAL) \
1458 do { \
1459 if ((ST) < 0 || (ST) >= (INTISA)->num_states) \
1461 xtisa_errno = xtensa_isa_bad_state; \
1462 strcpy (xtisa_error_msg, "invalid state specifier"); \
1463 return (ERRVAL); \
1465 } while (0)
1468 xtensa_state
1469 xtensa_state_lookup (xtensa_isa isa, const char *name)
1471 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1472 xtensa_lookup_entry entry, *result = 0;
1474 if (!name || !*name)
1476 xtisa_errno = xtensa_isa_bad_state;
1477 strcpy (xtisa_error_msg, "invalid state name");
1478 return XTENSA_UNDEFINED;
1481 if (intisa->num_states != 0)
1483 entry.key = name;
1484 result = bsearch (&entry, intisa->state_lookup_table, intisa->num_states,
1485 sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
1488 if (!result)
1490 xtisa_errno = xtensa_isa_bad_state;
1491 sprintf (xtisa_error_msg, "state \"%s\" not recognized", name);
1492 return XTENSA_UNDEFINED;
1495 return result->u.state;
1499 const char *
1500 xtensa_state_name (xtensa_isa isa, xtensa_state st)
1502 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1503 CHECK_STATE (intisa, st, NULL);
1504 return intisa->states[st].name;
1509 xtensa_state_num_bits (xtensa_isa isa, xtensa_state st)
1511 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1512 CHECK_STATE (intisa, st, XTENSA_UNDEFINED);
1513 return intisa->states[st].num_bits;
1518 xtensa_state_is_exported (xtensa_isa isa, xtensa_state st)
1520 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1521 CHECK_STATE (intisa, st, XTENSA_UNDEFINED);
1522 if ((intisa->states[st].flags & XTENSA_STATE_IS_EXPORTED) != 0)
1523 return 1;
1524 return 0;
1529 xtensa_state_is_shared_or (xtensa_isa isa, xtensa_state st)
1531 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1532 CHECK_STATE (intisa, st, XTENSA_UNDEFINED);
1533 if ((intisa->states[st].flags & XTENSA_STATE_IS_SHARED_OR) != 0)
1534 return 1;
1535 return 0;
1540 /* Sysregs. */
1543 #define CHECK_SYSREG(INTISA,SYSREG,ERRVAL) \
1544 do { \
1545 if ((SYSREG) < 0 || (SYSREG) >= (INTISA)->num_sysregs) \
1547 xtisa_errno = xtensa_isa_bad_sysreg; \
1548 strcpy (xtisa_error_msg, "invalid sysreg specifier"); \
1549 return (ERRVAL); \
1551 } while (0)
1554 xtensa_sysreg
1555 xtensa_sysreg_lookup (xtensa_isa isa, int num, int is_user)
1557 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1559 if (is_user != 0)
1560 is_user = 1;
1562 if (num < 0 || num > intisa->max_sysreg_num[is_user]
1563 || intisa->sysreg_table[is_user][num] == XTENSA_UNDEFINED)
1565 xtisa_errno = xtensa_isa_bad_sysreg;
1566 strcpy (xtisa_error_msg, "sysreg not recognized");
1567 return XTENSA_UNDEFINED;
1570 return intisa->sysreg_table[is_user][num];
1574 xtensa_sysreg
1575 xtensa_sysreg_lookup_name (xtensa_isa isa, const char *name)
1577 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1578 xtensa_lookup_entry entry, *result = 0;
1580 if (!name || !*name)
1582 xtisa_errno = xtensa_isa_bad_sysreg;
1583 strcpy (xtisa_error_msg, "invalid sysreg name");
1584 return XTENSA_UNDEFINED;
1587 if (intisa->num_sysregs != 0)
1589 entry.key = name;
1590 result = bsearch (&entry, intisa->sysreg_lookup_table,
1591 intisa->num_sysregs, sizeof (xtensa_lookup_entry),
1592 xtensa_isa_name_compare);
1595 if (!result)
1597 xtisa_errno = xtensa_isa_bad_sysreg;
1598 sprintf (xtisa_error_msg, "sysreg \"%s\" not recognized", name);
1599 return XTENSA_UNDEFINED;
1602 return result->u.sysreg;
1606 const char *
1607 xtensa_sysreg_name (xtensa_isa isa, xtensa_sysreg sysreg)
1609 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1610 CHECK_SYSREG (intisa, sysreg, NULL);
1611 return intisa->sysregs[sysreg].name;
1616 xtensa_sysreg_number (xtensa_isa isa, xtensa_sysreg sysreg)
1618 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1619 CHECK_SYSREG (intisa, sysreg, XTENSA_UNDEFINED);
1620 return intisa->sysregs[sysreg].number;
1625 xtensa_sysreg_is_user (xtensa_isa isa, xtensa_sysreg sysreg)
1627 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1628 CHECK_SYSREG (intisa, sysreg, XTENSA_UNDEFINED);
1629 if (intisa->sysregs[sysreg].is_user)
1630 return 1;
1631 return 0;
1636 /* Interfaces. */
1639 #define CHECK_INTERFACE(INTISA,INTF,ERRVAL) \
1640 do { \
1641 if ((INTF) < 0 || (INTF) >= (INTISA)->num_interfaces) \
1643 xtisa_errno = xtensa_isa_bad_interface; \
1644 strcpy (xtisa_error_msg, "invalid interface specifier"); \
1645 return (ERRVAL); \
1647 } while (0)
1650 xtensa_interface
1651 xtensa_interface_lookup (xtensa_isa isa, const char *ifname)
1653 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1654 xtensa_lookup_entry entry, *result = 0;
1656 if (!ifname || !*ifname)
1658 xtisa_errno = xtensa_isa_bad_interface;
1659 strcpy (xtisa_error_msg, "invalid interface name");
1660 return XTENSA_UNDEFINED;
1663 if (intisa->num_interfaces != 0)
1665 entry.key = ifname;
1666 result = bsearch (&entry, intisa->interface_lookup_table,
1667 intisa->num_interfaces, sizeof (xtensa_lookup_entry),
1668 xtensa_isa_name_compare);
1671 if (!result)
1673 xtisa_errno = xtensa_isa_bad_interface;
1674 sprintf (xtisa_error_msg, "interface \"%s\" not recognized", ifname);
1675 return XTENSA_UNDEFINED;
1678 return result->u.intf;
1682 const char *
1683 xtensa_interface_name (xtensa_isa isa, xtensa_interface intf)
1685 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1686 CHECK_INTERFACE (intisa, intf, NULL);
1687 return intisa->interfaces[intf].name;
1692 xtensa_interface_num_bits (xtensa_isa isa, xtensa_interface intf)
1694 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1695 CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
1696 return intisa->interfaces[intf].num_bits;
1700 char
1701 xtensa_interface_inout (xtensa_isa isa, xtensa_interface intf)
1703 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1704 CHECK_INTERFACE (intisa, intf, 0);
1705 return intisa->interfaces[intf].inout;
1710 xtensa_interface_has_side_effect (xtensa_isa isa, xtensa_interface intf)
1712 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1713 CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
1714 if ((intisa->interfaces[intf].flags & XTENSA_INTERFACE_HAS_SIDE_EFFECT) != 0)
1715 return 1;
1716 return 0;
1721 xtensa_interface_class_id (xtensa_isa isa, xtensa_interface intf)
1723 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1724 CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
1725 return intisa->interfaces[intf].class_id;
1730 /* Functional Units. */
1733 #define CHECK_FUNCUNIT(INTISA,FUN,ERRVAL) \
1734 do { \
1735 if ((FUN) < 0 || (FUN) >= (INTISA)->num_funcUnits) \
1737 xtisa_errno = xtensa_isa_bad_funcUnit; \
1738 strcpy (xtisa_error_msg, "invalid functional unit specifier"); \
1739 return (ERRVAL); \
1741 } while (0)
1744 xtensa_funcUnit
1745 xtensa_funcUnit_lookup (xtensa_isa isa, const char *fname)
1747 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1748 xtensa_lookup_entry entry, *result = 0;
1750 if (!fname || !*fname)
1752 xtisa_errno = xtensa_isa_bad_funcUnit;
1753 strcpy (xtisa_error_msg, "invalid functional unit name");
1754 return XTENSA_UNDEFINED;
1757 if (intisa->num_funcUnits != 0)
1759 entry.key = fname;
1760 result = bsearch (&entry, intisa->funcUnit_lookup_table,
1761 intisa->num_funcUnits, sizeof (xtensa_lookup_entry),
1762 xtensa_isa_name_compare);
1765 if (!result)
1767 xtisa_errno = xtensa_isa_bad_funcUnit;
1768 sprintf (xtisa_error_msg,
1769 "functional unit \"%s\" not recognized", fname);
1770 return XTENSA_UNDEFINED;
1773 return result->u.fun;
1777 const char *
1778 xtensa_funcUnit_name (xtensa_isa isa, xtensa_funcUnit fun)
1780 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1781 CHECK_FUNCUNIT (intisa, fun, NULL);
1782 return intisa->funcUnits[fun].name;
1787 xtensa_funcUnit_num_copies (xtensa_isa isa, xtensa_funcUnit fun)
1789 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1790 CHECK_FUNCUNIT (intisa, fun, XTENSA_UNDEFINED);
1791 return intisa->funcUnits[fun].num_copies;