daily update
[binutils.git] / bfd / xtensa-isa.c
blob35b27db84d4b3966195d4755d0c934b416d2a281
1 /* Configurable Xtensa ISA support.
2 Copyright 2003, 2004, 2005, 2007, 2008 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) return -1;
1033 if (!intop->encode)
1035 /* This is a default operand for a field. How can we tell if the
1036 value fits in the field? Write the value into the field,
1037 read it back, and then make sure we get the same value. */
1039 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1040 static xtensa_insnbuf tmpbuf = 0;
1041 int slot_id;
1043 if (!tmpbuf)
1045 tmpbuf = xtensa_insnbuf_alloc (isa);
1046 CHECK_ALLOC (tmpbuf, -1);
1049 /* A default operand is always associated with a field,
1050 but check just to be sure.... */
1051 if (intop->field_id == XTENSA_UNDEFINED)
1053 xtisa_errno = xtensa_isa_internal_error;
1054 strcpy (xtisa_error_msg, "operand has no field");
1055 return -1;
1058 /* Find some slot that includes the field. */
1059 for (slot_id = 0; slot_id < intisa->num_slots; slot_id++)
1061 xtensa_get_field_fn get_fn =
1062 intisa->slots[slot_id].get_field_fns[intop->field_id];
1063 xtensa_set_field_fn set_fn =
1064 intisa->slots[slot_id].set_field_fns[intop->field_id];
1066 if (get_fn && set_fn)
1068 (*set_fn) (tmpbuf, *valp);
1069 return ((*get_fn) (tmpbuf) != *valp);
1073 /* Couldn't find any slot containing the field.... */
1074 xtisa_errno = xtensa_isa_no_field;
1075 strcpy (xtisa_error_msg, "field does not exist in any slot");
1076 return -1;
1079 /* Encode the value. In some cases, the encoding function may detect
1080 errors, but most of the time the only way to determine if the value
1081 was successfully encoded is to decode it and check if it matches
1082 the original value. */
1083 orig_val = *valp;
1084 if ((*intop->encode) (valp) ||
1085 (test_val = *valp, (*intop->decode) (&test_val)) ||
1086 test_val != orig_val)
1088 xtisa_errno = xtensa_isa_bad_value;
1089 sprintf (xtisa_error_msg, "cannot encode operand value 0x%08x", *valp);
1090 return -1;
1093 return 0;
1098 xtensa_operand_decode (xtensa_isa isa, xtensa_opcode opc, int opnd,
1099 uint32 *valp)
1101 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1102 xtensa_operand_internal *intop;
1104 intop = get_operand (intisa, opc, opnd);
1105 if (!intop) return -1;
1107 /* Use identity function for "default" operands. */
1108 if (!intop->decode)
1109 return 0;
1111 if ((*intop->decode) (valp))
1113 xtisa_errno = xtensa_isa_bad_value;
1114 sprintf (xtisa_error_msg, "cannot decode operand value 0x%08x", *valp);
1115 return -1;
1117 return 0;
1122 xtensa_operand_is_register (xtensa_isa isa, xtensa_opcode opc, int opnd)
1124 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1125 xtensa_operand_internal *intop;
1127 intop = get_operand (intisa, opc, opnd);
1128 if (!intop) return XTENSA_UNDEFINED;
1130 if ((intop->flags & XTENSA_OPERAND_IS_REGISTER) != 0)
1131 return 1;
1132 return 0;
1136 xtensa_regfile
1137 xtensa_operand_regfile (xtensa_isa isa, xtensa_opcode opc, int opnd)
1139 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1140 xtensa_operand_internal *intop;
1142 intop = get_operand (intisa, opc, opnd);
1143 if (!intop) return XTENSA_UNDEFINED;
1145 return intop->regfile;
1150 xtensa_operand_num_regs (xtensa_isa isa, xtensa_opcode opc, int opnd)
1152 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1153 xtensa_operand_internal *intop;
1155 intop = get_operand (intisa, opc, opnd);
1156 if (!intop) return XTENSA_UNDEFINED;
1158 return intop->num_regs;
1163 xtensa_operand_is_known_reg (xtensa_isa isa, xtensa_opcode opc, int opnd)
1165 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1166 xtensa_operand_internal *intop;
1168 intop = get_operand (intisa, opc, opnd);
1169 if (!intop) return XTENSA_UNDEFINED;
1171 if ((intop->flags & XTENSA_OPERAND_IS_UNKNOWN) == 0)
1172 return 1;
1173 return 0;
1178 xtensa_operand_is_PCrelative (xtensa_isa isa, xtensa_opcode opc, int opnd)
1180 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1181 xtensa_operand_internal *intop;
1183 intop = get_operand (intisa, opc, opnd);
1184 if (!intop) return XTENSA_UNDEFINED;
1186 if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) != 0)
1187 return 1;
1188 return 0;
1193 xtensa_operand_do_reloc (xtensa_isa isa, xtensa_opcode opc, int opnd,
1194 uint32 *valp, uint32 pc)
1196 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1197 xtensa_operand_internal *intop;
1199 intop = get_operand (intisa, opc, opnd);
1200 if (!intop) return -1;
1202 if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) == 0)
1203 return 0;
1205 if (!intop->do_reloc)
1207 xtisa_errno = xtensa_isa_internal_error;
1208 strcpy (xtisa_error_msg, "operand missing do_reloc function");
1209 return -1;
1212 if ((*intop->do_reloc) (valp, pc))
1214 xtisa_errno = xtensa_isa_bad_value;
1215 sprintf (xtisa_error_msg,
1216 "do_reloc failed for value 0x%08x at PC 0x%08x", *valp, pc);
1217 return -1;
1220 return 0;
1225 xtensa_operand_undo_reloc (xtensa_isa isa, xtensa_opcode opc, int opnd,
1226 uint32 *valp, uint32 pc)
1228 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1229 xtensa_operand_internal *intop;
1231 intop = get_operand (intisa, opc, opnd);
1232 if (!intop) return -1;
1234 if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) == 0)
1235 return 0;
1237 if (!intop->undo_reloc)
1239 xtisa_errno = xtensa_isa_internal_error;
1240 strcpy (xtisa_error_msg, "operand missing undo_reloc function");
1241 return -1;
1244 if ((*intop->undo_reloc) (valp, pc))
1246 xtisa_errno = xtensa_isa_bad_value;
1247 sprintf (xtisa_error_msg,
1248 "undo_reloc failed for value 0x%08x at PC 0x%08x", *valp, pc);
1249 return -1;
1252 return 0;
1257 /* State Operands. */
1260 #define CHECK_STATE_OPERAND(INTISA,OPC,ICLASS,STOP,ERRVAL) \
1261 do { \
1262 if ((STOP) < 0 || (STOP) >= (ICLASS)->num_stateOperands) \
1264 xtisa_errno = xtensa_isa_bad_operand; \
1265 sprintf (xtisa_error_msg, "invalid state operand number (%d); " \
1266 "opcode \"%s\" has %d state operands", (STOP), \
1267 (INTISA)->opcodes[(OPC)].name, (ICLASS)->num_stateOperands); \
1268 return (ERRVAL); \
1270 } while (0)
1273 xtensa_state
1274 xtensa_stateOperand_state (xtensa_isa isa, xtensa_opcode opc, int stOp)
1276 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1277 xtensa_iclass_internal *iclass;
1278 int iclass_id;
1280 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
1281 iclass_id = intisa->opcodes[opc].iclass_id;
1282 iclass = &intisa->iclasses[iclass_id];
1283 CHECK_STATE_OPERAND (intisa, opc, iclass, stOp, XTENSA_UNDEFINED);
1284 return iclass->stateOperands[stOp].u.state;
1288 char
1289 xtensa_stateOperand_inout (xtensa_isa isa, xtensa_opcode opc, int stOp)
1291 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1292 xtensa_iclass_internal *iclass;
1293 int iclass_id;
1295 CHECK_OPCODE (intisa, opc, 0);
1296 iclass_id = intisa->opcodes[opc].iclass_id;
1297 iclass = &intisa->iclasses[iclass_id];
1298 CHECK_STATE_OPERAND (intisa, opc, iclass, stOp, 0);
1299 return iclass->stateOperands[stOp].inout;
1304 /* Interface Operands. */
1307 #define CHECK_INTERFACE_OPERAND(INTISA,OPC,ICLASS,IFOP,ERRVAL) \
1308 do { \
1309 if ((IFOP) < 0 || (IFOP) >= (ICLASS)->num_interfaceOperands) \
1311 xtisa_errno = xtensa_isa_bad_operand; \
1312 sprintf (xtisa_error_msg, "invalid interface operand number (%d); " \
1313 "opcode \"%s\" has %d interface operands", (IFOP), \
1314 (INTISA)->opcodes[(OPC)].name, \
1315 (ICLASS)->num_interfaceOperands); \
1316 return (ERRVAL); \
1318 } while (0)
1321 xtensa_interface
1322 xtensa_interfaceOperand_interface (xtensa_isa isa, xtensa_opcode opc,
1323 int ifOp)
1325 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1326 xtensa_iclass_internal *iclass;
1327 int iclass_id;
1329 CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
1330 iclass_id = intisa->opcodes[opc].iclass_id;
1331 iclass = &intisa->iclasses[iclass_id];
1332 CHECK_INTERFACE_OPERAND (intisa, opc, iclass, ifOp, XTENSA_UNDEFINED);
1333 return iclass->interfaceOperands[ifOp];
1338 /* Register Files. */
1341 #define CHECK_REGFILE(INTISA,RF,ERRVAL) \
1342 do { \
1343 if ((RF) < 0 || (RF) >= (INTISA)->num_regfiles) \
1345 xtisa_errno = xtensa_isa_bad_regfile; \
1346 strcpy (xtisa_error_msg, "invalid regfile specifier"); \
1347 return (ERRVAL); \
1349 } while (0)
1352 xtensa_regfile
1353 xtensa_regfile_lookup (xtensa_isa isa, const char *name)
1355 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1356 int n;
1358 if (!name || !*name)
1360 xtisa_errno = xtensa_isa_bad_regfile;
1361 strcpy (xtisa_error_msg, "invalid regfile name");
1362 return XTENSA_UNDEFINED;
1365 /* The expected number of regfiles is small; use a linear search. */
1366 for (n = 0; n < intisa->num_regfiles; n++)
1368 if (!strcmp (intisa->regfiles[n].name, name))
1369 return n;
1372 xtisa_errno = xtensa_isa_bad_regfile;
1373 sprintf (xtisa_error_msg, "regfile \"%s\" not recognized", name);
1374 return XTENSA_UNDEFINED;
1378 xtensa_regfile
1379 xtensa_regfile_lookup_shortname (xtensa_isa isa, const char *shortname)
1381 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1382 int n;
1384 if (!shortname || !*shortname)
1386 xtisa_errno = xtensa_isa_bad_regfile;
1387 strcpy (xtisa_error_msg, "invalid regfile shortname");
1388 return XTENSA_UNDEFINED;
1391 /* The expected number of regfiles is small; use a linear search. */
1392 for (n = 0; n < intisa->num_regfiles; n++)
1394 /* Ignore regfile views since they always have the same shortnames
1395 as their parents. */
1396 if (intisa->regfiles[n].parent != n)
1397 continue;
1398 if (!strcmp (intisa->regfiles[n].shortname, shortname))
1399 return n;
1402 xtisa_errno = xtensa_isa_bad_regfile;
1403 sprintf (xtisa_error_msg, "regfile shortname \"%s\" not recognized",
1404 shortname);
1405 return XTENSA_UNDEFINED;
1409 const char *
1410 xtensa_regfile_name (xtensa_isa isa, xtensa_regfile rf)
1412 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1413 CHECK_REGFILE (intisa, rf, NULL);
1414 return intisa->regfiles[rf].name;
1418 const char *
1419 xtensa_regfile_shortname (xtensa_isa isa, xtensa_regfile rf)
1421 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1422 CHECK_REGFILE (intisa, rf, NULL);
1423 return intisa->regfiles[rf].shortname;
1427 xtensa_regfile
1428 xtensa_regfile_view_parent (xtensa_isa isa, xtensa_regfile rf)
1430 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1431 CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
1432 return intisa->regfiles[rf].parent;
1437 xtensa_regfile_num_bits (xtensa_isa isa, xtensa_regfile rf)
1439 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1440 CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
1441 return intisa->regfiles[rf].num_bits;
1446 xtensa_regfile_num_entries (xtensa_isa isa, xtensa_regfile rf)
1448 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1449 CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
1450 return intisa->regfiles[rf].num_entries;
1455 /* Processor States. */
1458 #define CHECK_STATE(INTISA,ST,ERRVAL) \
1459 do { \
1460 if ((ST) < 0 || (ST) >= (INTISA)->num_states) \
1462 xtisa_errno = xtensa_isa_bad_state; \
1463 strcpy (xtisa_error_msg, "invalid state specifier"); \
1464 return (ERRVAL); \
1466 } while (0)
1469 xtensa_state
1470 xtensa_state_lookup (xtensa_isa isa, const char *name)
1472 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1473 xtensa_lookup_entry entry, *result = 0;
1475 if (!name || !*name)
1477 xtisa_errno = xtensa_isa_bad_state;
1478 strcpy (xtisa_error_msg, "invalid state name");
1479 return XTENSA_UNDEFINED;
1482 if (intisa->num_states != 0)
1484 entry.key = name;
1485 result = bsearch (&entry, intisa->state_lookup_table, intisa->num_states,
1486 sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
1489 if (!result)
1491 xtisa_errno = xtensa_isa_bad_state;
1492 sprintf (xtisa_error_msg, "state \"%s\" not recognized", name);
1493 return XTENSA_UNDEFINED;
1496 return result->u.state;
1500 const char *
1501 xtensa_state_name (xtensa_isa isa, xtensa_state st)
1503 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1504 CHECK_STATE (intisa, st, NULL);
1505 return intisa->states[st].name;
1510 xtensa_state_num_bits (xtensa_isa isa, xtensa_state st)
1512 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1513 CHECK_STATE (intisa, st, XTENSA_UNDEFINED);
1514 return intisa->states[st].num_bits;
1519 xtensa_state_is_exported (xtensa_isa isa, xtensa_state st)
1521 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1522 CHECK_STATE (intisa, st, XTENSA_UNDEFINED);
1523 if ((intisa->states[st].flags & XTENSA_STATE_IS_EXPORTED) != 0)
1524 return 1;
1525 return 0;
1530 /* Sysregs. */
1533 #define CHECK_SYSREG(INTISA,SYSREG,ERRVAL) \
1534 do { \
1535 if ((SYSREG) < 0 || (SYSREG) >= (INTISA)->num_sysregs) \
1537 xtisa_errno = xtensa_isa_bad_sysreg; \
1538 strcpy (xtisa_error_msg, "invalid sysreg specifier"); \
1539 return (ERRVAL); \
1541 } while (0)
1544 xtensa_sysreg
1545 xtensa_sysreg_lookup (xtensa_isa isa, int num, int is_user)
1547 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1549 if (is_user != 0)
1550 is_user = 1;
1552 if (num < 0 || num > intisa->max_sysreg_num[is_user]
1553 || intisa->sysreg_table[is_user][num] == XTENSA_UNDEFINED)
1555 xtisa_errno = xtensa_isa_bad_sysreg;
1556 strcpy (xtisa_error_msg, "sysreg not recognized");
1557 return XTENSA_UNDEFINED;
1560 return intisa->sysreg_table[is_user][num];
1564 xtensa_sysreg
1565 xtensa_sysreg_lookup_name (xtensa_isa isa, const char *name)
1567 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1568 xtensa_lookup_entry entry, *result = 0;
1570 if (!name || !*name)
1572 xtisa_errno = xtensa_isa_bad_sysreg;
1573 strcpy (xtisa_error_msg, "invalid sysreg name");
1574 return XTENSA_UNDEFINED;
1577 if (intisa->num_sysregs != 0)
1579 entry.key = name;
1580 result = bsearch (&entry, intisa->sysreg_lookup_table,
1581 intisa->num_sysregs, sizeof (xtensa_lookup_entry),
1582 xtensa_isa_name_compare);
1585 if (!result)
1587 xtisa_errno = xtensa_isa_bad_sysreg;
1588 sprintf (xtisa_error_msg, "sysreg \"%s\" not recognized", name);
1589 return XTENSA_UNDEFINED;
1592 return result->u.sysreg;
1596 const char *
1597 xtensa_sysreg_name (xtensa_isa isa, xtensa_sysreg sysreg)
1599 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1600 CHECK_SYSREG (intisa, sysreg, NULL);
1601 return intisa->sysregs[sysreg].name;
1606 xtensa_sysreg_number (xtensa_isa isa, xtensa_sysreg sysreg)
1608 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1609 CHECK_SYSREG (intisa, sysreg, XTENSA_UNDEFINED);
1610 return intisa->sysregs[sysreg].number;
1615 xtensa_sysreg_is_user (xtensa_isa isa, xtensa_sysreg sysreg)
1617 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1618 CHECK_SYSREG (intisa, sysreg, XTENSA_UNDEFINED);
1619 if (intisa->sysregs[sysreg].is_user)
1620 return 1;
1621 return 0;
1626 /* Interfaces. */
1629 #define CHECK_INTERFACE(INTISA,INTF,ERRVAL) \
1630 do { \
1631 if ((INTF) < 0 || (INTF) >= (INTISA)->num_interfaces) \
1633 xtisa_errno = xtensa_isa_bad_interface; \
1634 strcpy (xtisa_error_msg, "invalid interface specifier"); \
1635 return (ERRVAL); \
1637 } while (0)
1640 xtensa_interface
1641 xtensa_interface_lookup (xtensa_isa isa, const char *ifname)
1643 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1644 xtensa_lookup_entry entry, *result = 0;
1646 if (!ifname || !*ifname)
1648 xtisa_errno = xtensa_isa_bad_interface;
1649 strcpy (xtisa_error_msg, "invalid interface name");
1650 return XTENSA_UNDEFINED;
1653 if (intisa->num_interfaces != 0)
1655 entry.key = ifname;
1656 result = bsearch (&entry, intisa->interface_lookup_table,
1657 intisa->num_interfaces, sizeof (xtensa_lookup_entry),
1658 xtensa_isa_name_compare);
1661 if (!result)
1663 xtisa_errno = xtensa_isa_bad_interface;
1664 sprintf (xtisa_error_msg, "interface \"%s\" not recognized", ifname);
1665 return XTENSA_UNDEFINED;
1668 return result->u.intf;
1672 const char *
1673 xtensa_interface_name (xtensa_isa isa, xtensa_interface intf)
1675 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1676 CHECK_INTERFACE (intisa, intf, NULL);
1677 return intisa->interfaces[intf].name;
1682 xtensa_interface_num_bits (xtensa_isa isa, xtensa_interface intf)
1684 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1685 CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
1686 return intisa->interfaces[intf].num_bits;
1690 char
1691 xtensa_interface_inout (xtensa_isa isa, xtensa_interface intf)
1693 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1694 CHECK_INTERFACE (intisa, intf, 0);
1695 return intisa->interfaces[intf].inout;
1700 xtensa_interface_has_side_effect (xtensa_isa isa, xtensa_interface intf)
1702 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1703 CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
1704 if ((intisa->interfaces[intf].flags & XTENSA_INTERFACE_HAS_SIDE_EFFECT) != 0)
1705 return 1;
1706 return 0;
1711 xtensa_interface_class_id (xtensa_isa isa, xtensa_interface intf)
1713 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1714 CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
1715 return intisa->interfaces[intf].class_id;
1720 /* Functional Units. */
1723 #define CHECK_FUNCUNIT(INTISA,FUN,ERRVAL) \
1724 do { \
1725 if ((FUN) < 0 || (FUN) >= (INTISA)->num_funcUnits) \
1727 xtisa_errno = xtensa_isa_bad_funcUnit; \
1728 strcpy (xtisa_error_msg, "invalid functional unit specifier"); \
1729 return (ERRVAL); \
1731 } while (0)
1734 xtensa_funcUnit
1735 xtensa_funcUnit_lookup (xtensa_isa isa, const char *fname)
1737 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1738 xtensa_lookup_entry entry, *result = 0;
1740 if (!fname || !*fname)
1742 xtisa_errno = xtensa_isa_bad_funcUnit;
1743 strcpy (xtisa_error_msg, "invalid functional unit name");
1744 return XTENSA_UNDEFINED;
1747 if (intisa->num_funcUnits != 0)
1749 entry.key = fname;
1750 result = bsearch (&entry, intisa->funcUnit_lookup_table,
1751 intisa->num_funcUnits, sizeof (xtensa_lookup_entry),
1752 xtensa_isa_name_compare);
1755 if (!result)
1757 xtisa_errno = xtensa_isa_bad_funcUnit;
1758 sprintf (xtisa_error_msg,
1759 "functional unit \"%s\" not recognized", fname);
1760 return XTENSA_UNDEFINED;
1763 return result->u.fun;
1767 const char *
1768 xtensa_funcUnit_name (xtensa_isa isa, xtensa_funcUnit fun)
1770 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1771 CHECK_FUNCUNIT (intisa, fun, NULL);
1772 return intisa->funcUnits[fun].name;
1777 xtensa_funcUnit_num_copies (xtensa_isa isa, xtensa_funcUnit fun)
1779 xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1780 CHECK_FUNCUNIT (intisa, fun, XTENSA_UNDEFINED);
1781 return intisa->funcUnits[fun].num_copies;