* Makefile.in: Regenerate.
[binutils.git] / opcodes / ia64-opc.c
blob9726381dd6af7bb52ea795958a81d2ead3ea987a
1 /* ia64-opc.c -- Functions to access the compacted opcode table
2 Copyright 1999, 2000 Free Software Foundation, Inc.
3 Written by Bob Manson of Cygnus Solutions, <manson@cygnus.com>
5 This file is part of GDB, GAS, and the GNU binutils.
7 GDB, GAS, and the GNU binutils are free software; you can redistribute
8 them and/or modify them under the terms of the GNU General Public
9 License as published by the Free Software Foundation; either version
10 2, or (at your option) any later version.
12 GDB, GAS, and the GNU binutils are distributed in the hope that they
13 will be useful, but WITHOUT ANY WARRANTY; without even the implied
14 warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 the GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this file; see the file COPYING. If not, write to the
19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
22 #include "ansidecl.h"
23 #include "libiberty.h"
24 #include "sysdep.h"
25 #include "ia64-asmtab.h"
26 #include "ia64-asmtab.c"
28 static void get_opc_prefix PARAMS ((const char **, char *));
29 static short int find_string_ent PARAMS ((const char *));
30 static short int find_main_ent PARAMS ((short int));
31 static short int find_completer PARAMS ((short int, short int, const char *));
32 static ia64_insn apply_completer PARAMS ((ia64_insn, int));
33 static int extract_op_bits PARAMS ((int, int, int));
34 static int extract_op PARAMS ((int, int *, unsigned int *));
35 static int opcode_verify PARAMS ((ia64_insn, int, enum ia64_insn_type));
36 static int locate_opcode_ent PARAMS ((ia64_insn, enum ia64_insn_type));
37 static struct ia64_opcode *make_ia64_opcode
38 PARAMS ((ia64_insn, const char *, int, int));
39 static struct ia64_opcode *ia64_find_matching_opcode
40 PARAMS ((const char *, short int));
42 const struct ia64_templ_desc ia64_templ_desc[16] =
44 { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" }, /* 0 */
45 { 2, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" },
46 { 0, { IA64_UNIT_M, IA64_UNIT_L, IA64_UNIT_X }, "MLX" },
47 { 0, { 0, }, "-3-" },
48 { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" }, /* 4 */
49 { 1, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" },
50 { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_I }, "MFI" },
51 { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_F }, "MMF" },
52 { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_B }, "MIB" }, /* 8 */
53 { 0, { IA64_UNIT_M, IA64_UNIT_B, IA64_UNIT_B }, "MBB" },
54 { 0, { 0, }, "-a-" },
55 { 0, { IA64_UNIT_B, IA64_UNIT_B, IA64_UNIT_B }, "BBB" },
56 { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_B }, "MMB" }, /* c */
57 { 0, { 0, }, "-d-" },
58 { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_B }, "MFB" },
59 { 0, { 0, }, "-f-" },
63 /* Copy the prefix contained in *PTR (up to a '.' or a NUL) to DEST.
64 PTR will be adjusted to point to the start of the next portion
65 of the opcode, or at the NUL character. */
67 static void
68 get_opc_prefix (ptr, dest)
69 const char **ptr;
70 char *dest;
72 char *c = strchr (*ptr, '.');
73 if (c != NULL)
75 memcpy (dest, *ptr, c - *ptr);
76 dest[c - *ptr] = '\0';
77 *ptr = c + 1;
79 else
81 int l = strlen (*ptr);
82 memcpy (dest, *ptr, l);
83 dest[l] = '\0';
84 *ptr += l;
88 /* Find the index of the entry in the string table corresponding to
89 STR; return -1 if one does not exist. */
91 static short
92 find_string_ent (str)
93 const char *str;
95 short start = 0;
96 short end = sizeof (ia64_strings) / sizeof (const char *);
97 short i = (start + end) / 2;
99 if (strcmp (str, ia64_strings[end - 1]) > 0)
101 return -1;
103 while (start <= end)
105 int c = strcmp (str, ia64_strings[i]);
106 if (c < 0)
108 end = i - 1;
110 else if (c == 0)
112 return i;
114 else
116 start = i + 1;
118 i = (start + end) / 2;
120 return -1;
123 /* Find the opcode in the main opcode table whose name is STRINGINDEX, or
124 return -1 if one does not exist. */
126 static short
127 find_main_ent (nameindex)
128 short nameindex;
130 short start = 0;
131 short end = sizeof (main_table) / sizeof (struct ia64_main_table);
132 short i = (start + end) / 2;
134 if (nameindex < main_table[0].name_index
135 || nameindex > main_table[end - 1].name_index)
137 return -1;
139 while (start <= end)
141 if (nameindex < main_table[i].name_index)
143 end = i - 1;
145 else if (nameindex == main_table[i].name_index)
147 while (i > 0 && main_table[i - 1].name_index == nameindex)
149 i--;
151 return i;
153 else
155 start = i + 1;
157 i = (start + end) / 2;
159 return -1;
162 /* Find the index of the entry in the completer table that is part of
163 MAIN_ENT (starting from PREV_COMPLETER) that matches NAME, or
164 return -1 if one does not exist. */
166 static short
167 find_completer (main_ent, prev_completer, name)
168 short main_ent;
169 short prev_completer;
170 const char *name;
172 short name_index = find_string_ent (name);
174 if (name_index < 0)
176 return -1;
179 if (prev_completer == -1)
181 prev_completer = main_table[main_ent].completers;
183 else
185 prev_completer = completer_table[prev_completer].subentries;
188 while (prev_completer != -1)
190 if (completer_table[prev_completer].name_index == name_index)
192 return prev_completer;
194 prev_completer = completer_table[prev_completer].alternative;
196 return -1;
199 /* Apply the completer referred to by COMPLETER_INDEX to OPCODE, and
200 return the result. */
202 static ia64_insn
203 apply_completer (opcode, completer_index)
204 ia64_insn opcode;
205 int completer_index;
207 ia64_insn mask = completer_table[completer_index].mask;
208 ia64_insn bits = completer_table[completer_index].bits;
209 int shiftamt = (completer_table[completer_index].offset & 63);
211 mask = mask << shiftamt;
212 bits = bits << shiftamt;
213 opcode = (opcode & ~mask) | bits;
214 return opcode;
217 /* Extract BITS number of bits starting from OP_POINTER + BITOFFSET in
218 the dis_table array, and return its value. (BITOFFSET is numbered
219 starting from MSB to LSB, so a BITOFFSET of 0 indicates the MSB of the
220 first byte in OP_POINTER.) */
222 static int
223 extract_op_bits (op_pointer, bitoffset, bits)
224 int op_pointer;
225 int bitoffset;
226 int bits;
228 int res = 0;
230 op_pointer += (bitoffset / 8);
232 if (bitoffset % 8)
234 unsigned int op = dis_table[op_pointer++];
235 int numb = 8 - (bitoffset % 8);
236 int mask = (1 << numb) - 1;
237 int bata = (bits < numb) ? bits : numb;
238 int delta = numb - bata;
240 res = (res << bata) | ((op & mask) >> delta);
241 bitoffset += bata;
242 bits -= bata;
244 while (bits >= 8)
246 res = (res << 8) | (dis_table[op_pointer++] & 255);
247 bits -= 8;
249 if (bits > 0)
251 unsigned int op = (dis_table[op_pointer++] & 255);
252 res = (res << bits) | (op >> (8 - bits));
254 return res;
257 /* Examine the state machine entry at OP_POINTER in the dis_table
258 array, and extract its values into OPVAL and OP. The length of the
259 state entry in bits is returned. */
261 static int
262 extract_op (op_pointer, opval, op)
263 int op_pointer;
264 int *opval;
265 unsigned int *op;
267 int oplen = 5;
269 *op = dis_table[op_pointer];
271 if ((*op) & 0x40)
273 opval[0] = extract_op_bits (op_pointer, oplen, 5);
274 oplen += 5;
276 switch ((*op) & 0x30)
278 case 0x10:
280 opval[1] = extract_op_bits (op_pointer, oplen, 8);
281 oplen += 8;
282 opval[1] += op_pointer;
283 break;
285 case 0x20:
287 opval[1] = extract_op_bits (op_pointer, oplen, 16);
288 if (! (opval[1] & 32768))
290 opval[1] += op_pointer;
292 oplen += 16;
293 break;
295 case 0x30:
297 oplen--;
298 opval[2] = extract_op_bits (op_pointer, oplen, 12);
299 oplen += 12;
300 opval[2] |= 32768;
301 break;
304 if (((*op) & 0x08) && (((*op) & 0x30) != 0x30))
306 opval[2] = extract_op_bits (op_pointer, oplen, 16);
307 oplen += 16;
308 if (! (opval[2] & 32768))
310 opval[2] += op_pointer;
313 return oplen;
316 /* Returns a non-zero value if the opcode in the main_table list at
317 PLACE matches OPCODE and is of type TYPE. */
319 static int
320 opcode_verify (opcode, place, type)
321 ia64_insn opcode;
322 int place;
323 enum ia64_insn_type type;
325 if (main_table[place].opcode_type != type)
327 return 0;
329 if (main_table[place].flags
330 & (IA64_OPCODE_F2_EQ_F3 | IA64_OPCODE_LEN_EQ_64MCNT))
332 const struct ia64_operand *o1, *o2;
333 ia64_insn f2, f3;
335 if (main_table[place].flags & IA64_OPCODE_F2_EQ_F3)
337 o1 = elf64_ia64_operands + IA64_OPND_F2;
338 o2 = elf64_ia64_operands + IA64_OPND_F3;
339 (*o1->extract) (o1, opcode, &f2);
340 (*o2->extract) (o2, opcode, &f3);
341 if (f2 != f3)
342 return 0;
344 else
346 ia64_insn len, count;
348 /* length must equal 64-count: */
349 o1 = elf64_ia64_operands + IA64_OPND_LEN6;
350 o2 = elf64_ia64_operands + main_table[place].operands[2];
351 (*o1->extract) (o1, opcode, &len);
352 (*o2->extract) (o2, opcode, &count);
353 if (len != 64 - count)
354 return 0;
357 return 1;
360 /* Find an instruction entry in the ia64_dis_names array that matches
361 opcode OPCODE and is of type TYPE. Returns either a positive index
362 into the array, or a negative value if an entry for OPCODE could
363 not be found. Checks all matches and returns the one with the highest
364 priority. */
366 static int
367 locate_opcode_ent (opcode, type)
368 ia64_insn opcode;
369 enum ia64_insn_type type;
371 int currtest[41];
372 int bitpos[41];
373 int op_ptr[41];
374 int currstatenum = 0;
375 short found_disent = -1;
376 short found_priority = -1;
378 currtest[currstatenum] = 0;
379 op_ptr[currstatenum] = 0;
380 bitpos[currstatenum] = 40;
382 while (1)
384 int op_pointer = op_ptr[currstatenum];
385 unsigned int op;
386 int currbitnum = bitpos[currstatenum];
387 int oplen;
388 int opval[3];
389 int next_op;
390 int currbit;
392 oplen = extract_op (op_pointer, opval, &op);
394 bitpos[currstatenum] = currbitnum;
396 /* Skip opval[0] bits in the instruction. */
397 if (op & 0x40)
399 currbitnum -= opval[0];
402 /* The value of the current bit being tested. */
403 currbit = opcode & (((ia64_insn) 1) << currbitnum) ? 1 : 0;
404 next_op = -1;
406 /* We always perform the tests specified in the current state in
407 a particular order, falling through to the next test if the
408 previous one failed. */
409 switch (currtest[currstatenum])
411 case 0:
412 currtest[currstatenum]++;
413 if (currbit == 0 && (op & 0x80))
415 /* Check for a zero bit. If this test solely checks for
416 a zero bit, we can check for up to 8 consecutive zero
417 bits (the number to check is specified by the lower 3
418 bits in the state code.)
420 If the state instruction matches, we go to the very
421 next state instruction; otherwise, try the next test. */
423 if ((op & 0xf8) == 0x80)
425 int count = op & 0x7;
426 int x;
428 for (x = 0; x <= count; x++)
430 int i =
431 opcode & (((ia64_insn) 1) << (currbitnum - x)) ? 1 : 0;
432 if (i)
434 break;
437 if (x > count)
439 next_op = op_pointer + ((oplen + 7) / 8);
440 currbitnum -= count;
441 break;
444 else if (! currbit)
446 next_op = op_pointer + ((oplen + 7) / 8);
447 break;
450 /* FALLTHROUGH */
451 case 1:
452 /* If the bit in the instruction is one, go to the state
453 instruction specified by opval[1]. */
454 currtest[currstatenum]++;
455 if (currbit && (op & 0x30) != 0 && ((op & 0x30) != 0x30))
457 next_op = opval[1];
458 break;
460 /* FALLTHROUGH */
461 case 2:
462 /* Don't care. Skip the current bit and go to the state
463 instruction specified by opval[2].
465 An encoding of 0x30 is special; this means that a 12-bit
466 offset into the ia64_dis_names[] array is specified. */
467 currtest[currstatenum]++;
468 if ((op & 0x08) || ((op & 0x30) == 0x30))
470 next_op = opval[2];
471 break;
475 /* If bit 15 is set in the address of the next state, an offset
476 in the ia64_dis_names array was specified instead. We then
477 check to see if an entry in the list of opcodes matches the
478 opcode we were given; if so, we have succeeded. */
480 if ((next_op >= 0) && (next_op & 32768))
482 short disent = next_op & 32767;
483 short priority = -1;
485 if (next_op > 65535)
487 abort ();
490 /* Run through the list of opcodes to check, trying to find
491 one that matches. */
492 while (disent >= 0)
494 int place = ia64_dis_names[disent].insn_index;
496 priority = ia64_dis_names[disent].priority;
498 if (opcode_verify (opcode, place, type)
499 && priority > found_priority)
501 break;
503 if (ia64_dis_names[disent].next_flag)
505 disent++;
507 else
509 disent = -1;
513 if (disent >= 0)
515 found_disent = disent;
516 found_priority = priority;
518 /* Try the next test in this state, regardless of whether a match
519 was found. */
520 next_op = -2;
523 /* next_op == -1 is "back up to the previous state".
524 next_op == -2 is "stay in this state and try the next test".
525 Otherwise, transition to the state indicated by next_op. */
527 if (next_op == -1)
529 currstatenum--;
530 if (currstatenum < 0)
532 return found_disent;
535 else if (next_op >= 0)
537 currstatenum++;
538 bitpos[currstatenum] = currbitnum - 1;
539 op_ptr[currstatenum] = next_op;
540 currtest[currstatenum] = 0;
545 /* Construct an ia64_opcode entry based on OPCODE, NAME and PLACE. */
547 static struct ia64_opcode *
548 make_ia64_opcode (opcode, name, place, depind)
549 ia64_insn opcode;
550 const char *name;
551 int place;
552 int depind;
554 struct ia64_opcode *res =
555 (struct ia64_opcode *) xmalloc (sizeof (struct ia64_opcode));
556 res->name = xstrdup (name);
557 res->type = main_table[place].opcode_type;
558 res->num_outputs = main_table[place].num_outputs;
559 res->opcode = opcode;
560 res->mask = main_table[place].mask;
561 res->operands[0] = main_table[place].operands[0];
562 res->operands[1] = main_table[place].operands[1];
563 res->operands[2] = main_table[place].operands[2];
564 res->operands[3] = main_table[place].operands[3];
565 res->operands[4] = main_table[place].operands[4];
566 res->flags = main_table[place].flags;
567 res->ent_index = place;
568 res->dependencies = &op_dependencies[depind];
569 return res;
572 /* Determine the ia64_opcode entry for the opcode specified by INSN
573 and TYPE. If a valid entry is not found, return NULL. */
574 struct ia64_opcode *
575 ia64_dis_opcode (insn, type)
576 ia64_insn insn;
577 enum ia64_insn_type type;
579 int disent = locate_opcode_ent (insn, type);
581 if (disent < 0)
583 return NULL;
585 else
587 unsigned int cb = ia64_dis_names[disent].completer_index;
588 static char name[128];
589 int place = ia64_dis_names[disent].insn_index;
590 int ci = main_table[place].completers;
591 ia64_insn tinsn = main_table[place].opcode;
593 strcpy (name, ia64_strings [main_table[place].name_index]);
595 while (cb)
597 if (cb & 1)
599 int cname = completer_table[ci].name_index;
601 tinsn = apply_completer (tinsn, ci);
603 if (ia64_strings[cname][0] != '\0')
605 strcat (name, ".");
606 strcat (name, ia64_strings[cname]);
608 if (cb != 1)
610 ci = completer_table[ci].subentries;
613 else
615 ci = completer_table[ci].alternative;
617 if (ci < 0)
619 abort ();
621 cb = cb >> 1;
623 if (tinsn != (insn & main_table[place].mask))
625 abort ();
627 return make_ia64_opcode (insn, name, place,
628 completer_table[ci].dependencies);
632 /* Search the main_opcode table starting from PLACE for an opcode that
633 matches NAME. Return NULL if one is not found. */
635 static struct ia64_opcode *
636 ia64_find_matching_opcode (name, place)
637 const char *name;
638 short place;
640 char op[129];
641 const char *suffix;
642 short name_index;
644 if (strlen (name) > 128)
646 return NULL;
648 suffix = name;
649 get_opc_prefix (&suffix, op);
650 name_index = find_string_ent (op);
651 if (name_index < 0)
653 return NULL;
656 while (main_table[place].name_index == name_index)
658 const char *curr_suffix = suffix;
659 ia64_insn curr_insn = main_table[place].opcode;
660 short completer = -1;
662 do {
663 if (suffix[0] == '\0')
665 completer = find_completer (place, completer, suffix);
667 else
669 get_opc_prefix (&curr_suffix, op);
670 completer = find_completer (place, completer, op);
672 if (completer != -1)
674 curr_insn = apply_completer (curr_insn, completer);
676 } while (completer != -1 && curr_suffix[0] != '\0');
678 if (completer != -1 && curr_suffix[0] == '\0'
679 && completer_table[completer].terminal_completer)
681 int depind = completer_table[completer].dependencies;
682 return make_ia64_opcode (curr_insn, name, place, depind);
684 else
686 place++;
689 return NULL;
692 /* Find the next opcode after PREV_ENT that matches PREV_ENT, or return NULL
693 if one does not exist.
695 It is the caller's responsibility to invoke ia64_free_opcode () to
696 release any resources used by the returned entry. */
698 struct ia64_opcode *
699 ia64_find_next_opcode (prev_ent)
700 struct ia64_opcode *prev_ent;
702 return ia64_find_matching_opcode (prev_ent->name,
703 prev_ent->ent_index + 1);
706 /* Find the first opcode that matches NAME, or return NULL if it does
707 not exist.
709 It is the caller's responsibility to invoke ia64_free_opcode () to
710 release any resources used by the returned entry. */
712 struct ia64_opcode *
713 ia64_find_opcode (name)
714 const char *name;
716 char op[129];
717 const char *suffix;
718 short place;
719 short name_index;
721 if (strlen (name) > 128)
723 return NULL;
725 suffix = name;
726 get_opc_prefix (&suffix, op);
727 name_index = find_string_ent (op);
728 if (name_index < 0)
730 return NULL;
733 place = find_main_ent (name_index);
735 if (place < 0)
737 return NULL;
739 return ia64_find_matching_opcode (name, place);
742 /* Free any resources used by ENT. */
743 void
744 ia64_free_opcode (ent)
745 struct ia64_opcode *ent;
747 free ((void *)ent->name);
748 free (ent);
751 const struct ia64_dependency *
752 ia64_find_dependency (index)
753 int index;
755 index = DEP(index);
757 if (index < 0
758 || index >= (int)(sizeof(dependencies) / sizeof(dependencies[0])))
759 return NULL;
761 return &dependencies[index];