merge from gcc
[binutils.git] / opcodes / ia64-gen.c
bloba4e2cecd20bf89cd2b94483b60490e8a456fd20e
1 /* ia64-gen.c -- Generate a shrunk set of opcode tables
2 Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 Written by Bob Manson, 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 /* While the ia64-opc-* set of opcode tables are easy to maintain,
23 they waste a tremendous amount of space. ia64-gen rearranges the
24 instructions into a directed acyclic graph (DAG) of instruction opcodes and
25 their possible completers, as well as compacting the set of strings used.
27 The disassembler table consists of a state machine that does
28 branching based on the bits of the opcode being disassembled. The
29 state encodings have been chosen to minimize the amount of space
30 required.
32 The resource table is constructed based on some text dependency tables,
33 which are also easier to maintain than the final representation. */
35 #include <stdio.h>
36 #include <stdarg.h>
37 #include <errno.h>
39 #include "ansidecl.h"
40 #include "libiberty.h"
41 #include "safe-ctype.h"
42 #include "sysdep.h"
43 #include "getopt.h"
44 #include "ia64-opc.h"
45 #include "ia64-opc-a.c"
46 #include "ia64-opc-i.c"
47 #include "ia64-opc-m.c"
48 #include "ia64-opc-b.c"
49 #include "ia64-opc-f.c"
50 #include "ia64-opc-x.c"
51 #include "ia64-opc-d.c"
53 #include <libintl.h>
54 #define _(String) gettext (String)
56 const char * program_name = NULL;
57 int debug = 0;
59 #define tmalloc(X) (X *) xmalloc (sizeof (X))
61 /* The main opcode table entry. Each entry is a unique combination of
62 name and flags (no two entries in the table compare as being equal
63 via opcodes_eq). */
64 struct main_entry
66 /* The base name of this opcode. The names of its completers are
67 appended to it to generate the full instruction name. */
68 struct string_entry *name;
69 /* The base opcode entry. Which one to use is a fairly arbitrary choice;
70 it uses the first one passed to add_opcode_entry. */
71 struct ia64_opcode *opcode;
72 /* The list of completers that can be applied to this opcode. */
73 struct completer_entry *completers;
74 /* Next entry in the chain. */
75 struct main_entry *next;
76 /* Index in the main table. */
77 int main_index;
78 } *maintable, **ordered_table;
80 int otlen = 0;
81 int ottotlen = 0;
82 int opcode_count = 0;
84 /* The set of possible completers for an opcode. */
85 struct completer_entry
87 /* This entry's index in the ia64_completer_table[] array. */
88 int num;
90 /* The name of the completer. */
91 struct string_entry *name;
93 /* This entry's parent. */
94 struct completer_entry *parent;
96 /* Set if this is a terminal completer (occurs at the end of an
97 opcode). */
98 int is_terminal;
100 /* An alternative completer. */
101 struct completer_entry *alternative;
103 /* Additional completers that can be appended to this one. */
104 struct completer_entry *addl_entries;
106 /* Before compute_completer_bits () is invoked, this contains the actual
107 instruction opcode for this combination of opcode and completers.
108 Afterwards, it contains those bits that are different from its
109 parent opcode. */
110 ia64_insn bits;
112 /* Bits set to 1 correspond to those bits in this completer's opcode
113 that are different from its parent completer's opcode (or from
114 the base opcode if the entry is the root of the opcode's completer
115 list). This field is filled in by compute_completer_bits (). */
116 ia64_insn mask;
118 /* Index into the opcode dependency list, or -1 if none. */
119 int dependencies;
121 /* Remember the order encountered in the opcode tables. */
122 int order;
125 /* One entry in the disassembler name table. */
126 struct disent
128 /* The index into the ia64_name_dis array for this entry. */
129 int ournum;
131 /* The index into the main_table[] array. */
132 int insn;
134 /* The disassmbly priority of this entry. */
135 int priority;
137 /* The completer_index value for this entry. */
138 int completer_index;
140 /* How many other entries share this decode. */
141 int nextcnt;
143 /* The next entry sharing the same decode. */
144 struct disent *nexte;
146 /* The next entry in the name list. */
147 struct disent *next_ent;
148 } *disinsntable = NULL;
150 /* A state machine that will eventually be used to generate the
151 disassembler table. */
152 struct bittree
154 struct disent *disent;
155 struct bittree *bits[3]; /* 0, 1, and X (don't care). */
156 int bits_to_skip;
157 int skip_flag;
158 } *bittree;
160 /* The string table contains all opcodes and completers sorted in
161 alphabetical order. */
163 /* One entry in the string table. */
164 struct string_entry
166 /* The index in the ia64_strings[] array for this entry. */
167 int num;
168 /* And the string. */
169 char *s;
170 } **string_table = NULL;
172 int strtablen = 0;
173 int strtabtotlen = 0;
176 /* Resource dependency entries. */
177 struct rdep
179 char *name; /* Resource name. */
180 unsigned
181 mode:2, /* RAW, WAW, or WAR. */
182 semantics:3; /* Dependency semantics. */
183 char *extra; /* Additional semantics info. */
184 int nchks;
185 int total_chks; /* Total #of terminal insns. */
186 int *chks; /* Insn classes which read (RAW), write
187 (WAW), or write (WAR) this rsrc. */
188 int *chknotes; /* Dependency notes for each class. */
189 int nregs;
190 int total_regs; /* Total #of terminal insns. */
191 int *regs; /* Insn class which write (RAW), write2
192 (WAW), or read (WAR) this rsrc. */
193 int *regnotes; /* Dependency notes for each class. */
195 int waw_special; /* Special WAW dependency note. */
196 } **rdeps = NULL;
198 static int rdepslen = 0;
199 static int rdepstotlen = 0;
201 /* Array of all instruction classes. */
202 struct iclass
204 char *name; /* Instruction class name. */
205 int is_class; /* Is a class, not a terminal. */
206 int nsubs;
207 int *subs; /* Other classes within this class. */
208 int nxsubs;
209 int xsubs[4]; /* Exclusions. */
210 char *comment; /* Optional comment. */
211 int note; /* Optional note. */
212 int terminal_resolved; /* Did we match this with anything? */
213 int orphan; /* Detect class orphans. */
214 } **ics = NULL;
216 static int iclen = 0;
217 static int ictotlen = 0;
219 /* An opcode dependency (chk/reg pair of dependency lists). */
220 struct opdep
222 int chk; /* index into dlists */
223 int reg; /* index into dlists */
224 } **opdeps;
226 static int opdeplen = 0;
227 static int opdeptotlen = 0;
229 /* A generic list of dependencies w/notes encoded. These may be shared. */
230 struct deplist
232 int len;
233 unsigned short *deps;
234 } **dlists;
236 static int dlistlen = 0;
237 static int dlisttotlen = 0;
240 static void fail (const char *, ...);
241 static void warn (const char *, ...);
242 static struct rdep * insert_resource (const char *, enum ia64_dependency_mode);
243 static int deplist_equals (struct deplist *, struct deplist *);
244 static short insert_deplist (int, unsigned short *);
245 static short insert_dependencies (int, unsigned short *, int, unsigned short *);
246 static void mark_used (struct iclass *, int);
247 static int fetch_insn_class (const char *, int);
248 static int sub_compare (const void *, const void *);
249 static void load_insn_classes (void);
250 static void parse_resource_users (const char *, int **, int *, int **);
251 static int parse_semantics (char *);
252 static void add_dep (const char *, const char *, const char *, int, int, char *, int);
253 static void load_depfile (const char *, enum ia64_dependency_mode);
254 static void load_dependencies (void);
255 static int irf_operand (int, const char *);
256 static int in_iclass_mov_x (struct ia64_opcode *, struct iclass *, const char *, const char *);
257 static int in_iclass (struct ia64_opcode *, struct iclass *, const char *, const char *, int *);
258 static int lookup_regindex (const char *, int);
259 static int lookup_specifier (const char *);
260 static void print_dependency_table (void);
261 static struct string_entry * insert_string (char *);
262 static void gen_dis_table (struct bittree *);
263 static void print_dis_table (void);
264 static void generate_disassembler (void);
265 static void print_string_table (void);
266 static int completer_entries_eq (struct completer_entry *, struct completer_entry *);
267 static struct completer_entry * insert_gclist (struct completer_entry *);
268 static int get_prefix_len (const char *);
269 static void compute_completer_bits (struct main_entry *, struct completer_entry *);
270 static void collapse_redundant_completers (void);
271 static int insert_opcode_dependencies (struct ia64_opcode *, struct completer_entry *);
272 static void insert_completer_entry (struct ia64_opcode *, struct main_entry *, int);
273 static void print_completer_entry (struct completer_entry *);
274 static void print_completer_table (void);
275 static int opcodes_eq (struct ia64_opcode *, struct ia64_opcode *);
276 static void add_opcode_entry (struct ia64_opcode *);
277 static void print_main_table (void);
278 static void shrink (struct ia64_opcode *);
279 static void print_version (void);
280 static void usage (FILE *, int);
281 static void finish_distable (void);
282 static void insert_bit_table_ent (struct bittree *, int, ia64_insn, ia64_insn, int, int, int);
283 static void add_dis_entry (struct bittree *, ia64_insn, ia64_insn, int, struct completer_entry *, int);
284 static void compact_distree (struct bittree *);
285 static struct bittree * make_bittree_entry (void);
286 static struct disent * add_dis_table_ent (struct disent *, int, int, int);
289 static void
290 fail (const char *message, ...)
292 va_list args;
294 va_start (args, message);
295 fprintf (stderr, _("%s: Error: "), program_name);
296 vfprintf (stderr, message, args);
297 va_end (args);
298 xexit (1);
301 static void
302 warn (const char *message, ...)
304 va_list args;
306 va_start (args, message);
308 fprintf (stderr, _("%s: Warning: "), program_name);
309 vfprintf (stderr, message, args);
310 va_end (args);
313 /* Add NAME to the resource table, where TYPE is RAW or WAW. */
314 static struct rdep *
315 insert_resource (const char *name, enum ia64_dependency_mode type)
317 if (rdepslen == rdepstotlen)
319 rdepstotlen += 20;
320 rdeps = (struct rdep **)
321 xrealloc (rdeps, sizeof(struct rdep **) * rdepstotlen);
323 rdeps[rdepslen] = tmalloc(struct rdep);
324 memset((void *)rdeps[rdepslen], 0, sizeof(struct rdep));
325 rdeps[rdepslen]->name = xstrdup (name);
326 rdeps[rdepslen]->mode = type;
327 rdeps[rdepslen]->waw_special = 0;
329 return rdeps[rdepslen++];
332 /* Are the lists of dependency indexes equivalent? */
333 static int
334 deplist_equals (struct deplist *d1, struct deplist *d2)
336 int i;
338 if (d1->len != d2->len)
339 return 0;
341 for (i = 0; i < d1->len; i++)
342 if (d1->deps[i] != d2->deps[i])
343 return 0;
345 return 1;
348 /* Add the list of dependencies to the list of dependency lists. */
349 static short
350 insert_deplist (int count, unsigned short *deps)
352 /* Sort the list, then see if an equivalent list exists already.
353 this results in a much smaller set of dependency lists. */
354 struct deplist *list;
355 char set[0x10000];
356 int i;
358 memset ((void *)set, 0, sizeof (set));
359 for (i = 0; i < count; i++)
360 set[deps[i]] = 1;
362 count = 0;
363 for (i = 0; i < (int) sizeof (set); i++)
364 if (set[i])
365 ++count;
367 list = tmalloc (struct deplist);
368 list->len = count;
369 list->deps = (unsigned short *) malloc (sizeof (unsigned short) * count);
371 for (i = 0, count = 0; i < (int) sizeof (set); i++)
372 if (set[i])
373 list->deps[count++] = i;
375 /* Does this list exist already? */
376 for (i = 0; i < dlistlen; i++)
377 if (deplist_equals (list, dlists[i]))
379 free (list->deps);
380 free (list);
381 return i;
384 if (dlistlen == dlisttotlen)
386 dlisttotlen += 20;
387 dlists = (struct deplist **)
388 xrealloc (dlists, sizeof(struct deplist **) * dlisttotlen);
390 dlists[dlistlen] = list;
392 return dlistlen++;
395 /* Add the given pair of dependency lists to the opcode dependency list. */
396 static short
397 insert_dependencies (int nchks, unsigned short *chks,
398 int nregs, unsigned short *regs)
400 struct opdep *pair;
401 int i;
402 int regind = -1;
403 int chkind = -1;
405 if (nregs > 0)
406 regind = insert_deplist (nregs, regs);
407 if (nchks > 0)
408 chkind = insert_deplist (nchks, chks);
410 for (i = 0; i < opdeplen; i++)
411 if (opdeps[i]->chk == chkind
412 && opdeps[i]->reg == regind)
413 return i;
415 pair = tmalloc (struct opdep);
416 pair->chk = chkind;
417 pair->reg = regind;
419 if (opdeplen == opdeptotlen)
421 opdeptotlen += 20;
422 opdeps = (struct opdep **)
423 xrealloc (opdeps, sizeof(struct opdep **) * opdeptotlen);
425 opdeps[opdeplen] = pair;
427 return opdeplen++;
430 static void
431 mark_used (struct iclass *ic, int clear_terminals)
433 int i;
435 ic->orphan = 0;
436 if (clear_terminals)
437 ic->terminal_resolved = 1;
439 for (i = 0; i < ic->nsubs; i++)
440 mark_used (ics[ic->subs[i]], clear_terminals);
442 for (i = 0; i < ic->nxsubs; i++)
443 mark_used (ics[ic->xsubs[i]], clear_terminals);
446 /* Look up an instruction class; if CREATE make a new one if none found;
447 returns the index into the insn class array. */
448 static int
449 fetch_insn_class (const char *full_name, int create)
451 char *name;
452 char *notestr;
453 char *xsect;
454 char *comment;
455 int i, note = 0;
456 int ind;
457 int is_class = 0;
459 if (strncmp (full_name, "IC:", 3) == 0)
461 name = xstrdup (full_name + 3);
462 is_class = 1;
464 else
465 name = xstrdup (full_name);
467 if ((xsect = strchr(name, '\\')) != NULL)
468 is_class = 1;
469 if ((comment = strchr(name, '[')) != NULL)
470 is_class = 1;
471 if ((notestr = strchr(name, '+')) != NULL)
472 is_class = 1;
474 /* If it is a composite class, then ignore comments and notes that come after
475 the '\\', since they don't apply to the part we are decoding now. */
476 if (xsect)
478 if (comment > xsect)
479 comment = 0;
480 if (notestr > xsect)
481 notestr = 0;
484 if (notestr)
486 char *nextnotestr;
488 note = atoi (notestr + 1);
489 if ((nextnotestr = strchr (notestr + 1, '+')) != NULL)
491 if (strcmp (notestr, "+1+13") == 0)
492 note = 13;
493 else if (!xsect || nextnotestr < xsect)
494 warn (_("multiple note %s not handled\n"), notestr);
498 /* If it's a composite class, leave the notes and comments in place so that
499 we have a unique name for the composite class. Otherwise, we remove
500 them. */
501 if (!xsect)
503 if (notestr)
504 *notestr = 0;
505 if (comment)
506 *comment = 0;
509 for (i = 0; i < iclen; i++)
510 if (strcmp (name, ics[i]->name) == 0
511 && ((comment == NULL && ics[i]->comment == NULL)
512 || (comment != NULL && ics[i]->comment != NULL
513 && strncmp (ics[i]->comment, comment,
514 strlen (ics[i]->comment)) == 0))
515 && note == ics[i]->note)
516 return i;
518 if (!create)
519 return -1;
521 /* Doesn't exist, so make a new one. */
522 if (iclen == ictotlen)
524 ictotlen += 20;
525 ics = (struct iclass **)
526 xrealloc (ics, (ictotlen) * sizeof (struct iclass *));
529 ind = iclen++;
530 ics[ind] = tmalloc (struct iclass);
531 memset ((void *)ics[ind], 0, sizeof (struct iclass));
532 ics[ind]->name = xstrdup (name);
533 ics[ind]->is_class = is_class;
534 ics[ind]->orphan = 1;
536 if (comment)
538 ics[ind]->comment = xstrdup (comment + 1);
539 ics[ind]->comment[strlen (ics[ind]->comment)-1] = 0;
542 if (notestr)
543 ics[ind]->note = note;
545 /* If it's a composite class, there's a comment or note, look for an
546 existing class or terminal with the same name. */
547 if ((xsect || comment || notestr) && is_class)
549 /* First, populate with the class we're based on. */
550 char *subname = name;
552 if (xsect)
553 *xsect = 0;
554 else if (comment)
555 *comment = 0;
556 else if (notestr)
557 *notestr = 0;
559 ics[ind]->nsubs = 1;
560 ics[ind]->subs = tmalloc(int);
561 ics[ind]->subs[0] = fetch_insn_class (subname, 1);;
564 while (xsect)
566 char *subname = xsect + 1;
568 xsect = strchr (subname, '\\');
569 if (xsect)
570 *xsect = 0;
571 ics[ind]->xsubs[ics[ind]->nxsubs] = fetch_insn_class (subname,1);
572 ics[ind]->nxsubs++;
574 free (name);
576 return ind;
579 /* For sorting a class's sub-class list only; make sure classes appear before
580 terminals. */
581 static int
582 sub_compare (const void *e1, const void *e2)
584 struct iclass *ic1 = ics[*(int *)e1];
585 struct iclass *ic2 = ics[*(int *)e2];
587 if (ic1->is_class)
589 if (!ic2->is_class)
590 return -1;
592 else if (ic2->is_class)
593 return 1;
595 return strcmp (ic1->name, ic2->name);
598 static void
599 load_insn_classes (void)
601 FILE *fp = fopen ("ia64-ic.tbl", "r");
602 char buf[2048];
604 if (fp == NULL)
605 fail (_("can't find ia64-ic.tbl for reading\n"));
607 /* Discard first line. */
608 fgets (buf, sizeof(buf), fp);
610 while (!feof (fp))
612 int iclass;
613 char *name;
614 char *tmp;
616 if (fgets (buf, sizeof (buf), fp) == NULL)
617 break;
619 while (ISSPACE (buf[strlen (buf) - 1]))
620 buf[strlen (buf) - 1] = '\0';
622 name = tmp = buf;
623 while (*tmp != ';')
625 ++tmp;
626 if (tmp == buf + sizeof (buf))
627 abort ();
629 *tmp++ = '\0';
631 iclass = fetch_insn_class (name, 1);
632 ics[iclass]->is_class = 1;
634 if (strcmp (name, "none") == 0)
636 ics[iclass]->is_class = 0;
637 ics[iclass]->terminal_resolved = 1;
638 continue;
641 /* For this class, record all sub-classes. */
642 while (*tmp)
644 char *subname;
645 int sub;
647 while (*tmp && ISSPACE (*tmp))
649 ++tmp;
650 if (tmp == buf + sizeof (buf))
651 abort ();
653 subname = tmp;
654 while (*tmp && *tmp != ',')
656 ++tmp;
657 if (tmp == buf + sizeof (buf))
658 abort ();
660 if (*tmp == ',')
661 *tmp++ = '\0';
663 ics[iclass]->subs = (int *)
664 xrealloc ((void *)ics[iclass]->subs,
665 (ics[iclass]->nsubs + 1) * sizeof (int));
667 sub = fetch_insn_class (subname, 1);
668 ics[iclass]->subs = (int *)
669 xrealloc (ics[iclass]->subs, (ics[iclass]->nsubs + 1) * sizeof (int));
670 ics[iclass]->subs[ics[iclass]->nsubs++] = sub;
673 /* Make sure classes come before terminals. */
674 qsort ((void *)ics[iclass]->subs,
675 ics[iclass]->nsubs, sizeof(int), sub_compare);
677 fclose (fp);
679 if (debug)
680 printf ("%d classes\n", iclen);
683 /* Extract the insn classes from the given line. */
684 static void
685 parse_resource_users (ref, usersp, nusersp, notesp)
686 const char *ref;
687 int **usersp;
688 int *nusersp;
689 int **notesp;
691 int c;
692 char *line = xstrdup (ref);
693 char *tmp = line;
694 int *users = *usersp;
695 int count = *nusersp;
696 int *notes = *notesp;
698 c = *tmp;
699 while (c != 0)
701 char *notestr;
702 int note;
703 char *xsect;
704 int iclass;
705 int create = 0;
706 char *name;
708 while (ISSPACE (*tmp))
709 ++tmp;
710 name = tmp;
711 while (*tmp && *tmp != ',')
712 ++tmp;
713 c = *tmp;
714 *tmp++ = '\0';
716 xsect = strchr (name, '\\');
717 if ((notestr = strstr (name, "+")) != NULL)
719 char *nextnotestr;
721 note = atoi (notestr + 1);
722 if ((nextnotestr = strchr (notestr + 1, '+')) != NULL)
724 /* Note 13 always implies note 1. */
725 if (strcmp (notestr, "+1+13") == 0)
726 note = 13;
727 else if (!xsect || nextnotestr < xsect)
728 warn (_("multiple note %s not handled\n"), notestr);
730 if (!xsect)
731 *notestr = '\0';
733 else
734 note = 0;
736 /* All classes are created when the insn class table is parsed;
737 Individual instructions might not appear until the dependency tables
738 are read. Only create new classes if it's *not* an insn class,
739 or if it's a composite class (which wouldn't necessarily be in the IC
740 table). */
741 if (strncmp (name, "IC:", 3) != 0 || xsect != NULL)
742 create = 1;
744 iclass = fetch_insn_class (name, create);
745 if (iclass != -1)
747 users = (int *)
748 xrealloc ((void *) users,(count + 1) * sizeof (int));
749 notes = (int *)
750 xrealloc ((void *) notes,(count + 1) * sizeof (int));
751 notes[count] = note;
752 users[count++] = iclass;
753 mark_used (ics[iclass], 0);
755 else if (debug)
756 printf("Class %s not found\n", name);
758 /* Update the return values. */
759 *usersp = users;
760 *nusersp = count;
761 *notesp = notes;
763 free (line);
766 static int
767 parse_semantics (char *sem)
769 if (strcmp (sem, "none") == 0)
770 return IA64_DVS_NONE;
771 else if (strcmp (sem, "implied") == 0)
772 return IA64_DVS_IMPLIED;
773 else if (strcmp (sem, "impliedF") == 0)
774 return IA64_DVS_IMPLIEDF;
775 else if (strcmp (sem, "data") == 0)
776 return IA64_DVS_DATA;
777 else if (strcmp (sem, "instr") == 0)
778 return IA64_DVS_INSTR;
779 else if (strcmp (sem, "specific") == 0)
780 return IA64_DVS_SPECIFIC;
781 else if (strcmp (sem, "stop") == 0)
782 return IA64_DVS_STOP;
783 else
784 return IA64_DVS_OTHER;
787 static void
788 add_dep (const char *name, const char *chk, const char *reg,
789 int semantics, int mode, char *extra, int flag)
791 struct rdep *rs;
793 rs = insert_resource (name, mode);
795 parse_resource_users (chk, &rs->chks, &rs->nchks, &rs->chknotes);
796 parse_resource_users (reg, &rs->regs, &rs->nregs, &rs->regnotes);
798 rs->semantics = semantics;
799 rs->extra = extra;
800 rs->waw_special = flag;
803 static void
804 load_depfile (const char *filename, enum ia64_dependency_mode mode)
806 FILE *fp = fopen (filename, "r");
807 char buf[1024];
809 if (fp == NULL)
810 fail (_("can't find %s for reading\n"), filename);
812 fgets (buf, sizeof(buf), fp);
813 while (!feof (fp))
815 char *name, *tmp;
816 int semantics;
817 char *extra;
818 char *regp, *chkp;
820 if (fgets (buf, sizeof(buf), fp) == NULL)
821 break;
823 while (ISSPACE (buf[strlen (buf) - 1]))
824 buf[strlen (buf) - 1] = '\0';
826 name = tmp = buf;
827 while (*tmp != ';')
828 ++tmp;
829 *tmp++ = '\0';
831 while (ISSPACE (*tmp))
832 ++tmp;
833 regp = tmp;
834 tmp = strchr (tmp, ';');
835 if (!tmp)
836 abort ();
837 *tmp++ = 0;
838 while (ISSPACE (*tmp))
839 ++tmp;
840 chkp = tmp;
841 tmp = strchr (tmp, ';');
842 if (!tmp)
843 abort ();
844 *tmp++ = 0;
845 while (ISSPACE (*tmp))
846 ++tmp;
847 semantics = parse_semantics (tmp);
848 extra = semantics == IA64_DVS_OTHER ? xstrdup (tmp) : NULL;
850 /* For WAW entries, if the chks and regs differ, we need to enter the
851 entries in both positions so that the tables will be parsed properly,
852 without a lot of extra work. */
853 if (mode == IA64_DV_WAW && strcmp (regp, chkp) != 0)
855 add_dep (name, chkp, regp, semantics, mode, extra, 0);
856 add_dep (name, regp, chkp, semantics, mode, extra, 1);
858 else
860 add_dep (name, chkp, regp, semantics, mode, extra, 0);
863 fclose (fp);
866 static void
867 load_dependencies (void)
869 load_depfile ("ia64-raw.tbl", IA64_DV_RAW);
870 load_depfile ("ia64-waw.tbl", IA64_DV_WAW);
871 load_depfile ("ia64-war.tbl", IA64_DV_WAR);
873 if (debug)
874 printf ("%d RAW/WAW/WAR dependencies\n", rdepslen);
877 /* Is the given operand an indirect register file operand? */
878 static int
879 irf_operand (int op, const char *field)
881 if (!field)
883 return op == IA64_OPND_RR_R3 || op == IA64_OPND_DBR_R3
884 || op == IA64_OPND_IBR_R3 || op == IA64_OPND_PKR_R3
885 || op == IA64_OPND_PMC_R3 || op == IA64_OPND_PMD_R3
886 || op == IA64_OPND_MSR_R3 || op == IA64_OPND_CPUID_R3;
888 else
890 return ((op == IA64_OPND_RR_R3 && strstr (field, "rr"))
891 || (op == IA64_OPND_DBR_R3 && strstr (field, "dbr"))
892 || (op == IA64_OPND_IBR_R3 && strstr (field, "ibr"))
893 || (op == IA64_OPND_PKR_R3 && strstr (field, "pkr"))
894 || (op == IA64_OPND_PMC_R3 && strstr (field, "pmc"))
895 || (op == IA64_OPND_PMD_R3 && strstr (field, "pmd"))
896 || (op == IA64_OPND_MSR_R3 && strstr (field, "msr"))
897 || (op == IA64_OPND_CPUID_R3 && strstr (field, "cpuid")));
901 /* Handle mov_ar, mov_br, mov_cr, mov_indirect, mov_ip, mov_pr, mov_psr, and
902 mov_um insn classes. */
903 static int
904 in_iclass_mov_x (struct ia64_opcode *idesc, struct iclass *ic,
905 const char *format, const char *field)
907 int plain_mov = strcmp (idesc->name, "mov") == 0;
909 if (!format)
910 return 0;
912 switch (ic->name[4])
914 default:
915 abort ();
916 case 'a':
918 int i = strcmp (idesc->name, "mov.i") == 0;
919 int m = strcmp (idesc->name, "mov.m") == 0;
920 int i2627 = i && idesc->operands[0] == IA64_OPND_AR3;
921 int i28 = i && idesc->operands[1] == IA64_OPND_AR3;
922 int m2930 = m && idesc->operands[0] == IA64_OPND_AR3;
923 int m31 = m && idesc->operands[1] == IA64_OPND_AR3;
924 int pseudo0 = plain_mov && idesc->operands[1] == IA64_OPND_AR3;
925 int pseudo1 = plain_mov && idesc->operands[0] == IA64_OPND_AR3;
927 /* IC:mov ar */
928 if (i2627)
929 return strstr (format, "I26") || strstr (format, "I27");
930 if (i28)
931 return strstr (format, "I28") != NULL;
932 if (m2930)
933 return strstr (format, "M29") || strstr (format, "M30");
934 if (m31)
935 return strstr (format, "M31") != NULL;
936 if (pseudo0 || pseudo1)
937 return 1;
939 break;
940 case 'b':
942 int i21 = idesc->operands[0] == IA64_OPND_B1;
943 int i22 = plain_mov && idesc->operands[1] == IA64_OPND_B2;
944 if (i22)
945 return strstr (format, "I22") != NULL;
946 if (i21)
947 return strstr (format, "I21") != NULL;
949 break;
950 case 'c':
952 int m32 = plain_mov && idesc->operands[0] == IA64_OPND_CR3;
953 int m33 = plain_mov && idesc->operands[1] == IA64_OPND_CR3;
954 if (m32)
955 return strstr (format, "M32") != NULL;
956 if (m33)
957 return strstr (format, "M33") != NULL;
959 break;
960 case 'i':
961 if (ic->name[5] == 'n')
963 int m42 = plain_mov && irf_operand (idesc->operands[0], field);
964 int m43 = plain_mov && irf_operand (idesc->operands[1], field);
965 if (m42)
966 return strstr (format, "M42") != NULL;
967 if (m43)
968 return strstr (format, "M43") != NULL;
970 else if (ic->name[5] == 'p')
972 return idesc->operands[1] == IA64_OPND_IP;
974 else
975 abort ();
976 break;
977 case 'p':
978 if (ic->name[5] == 'r')
980 int i25 = plain_mov && idesc->operands[1] == IA64_OPND_PR;
981 int i23 = plain_mov && idesc->operands[0] == IA64_OPND_PR;
982 int i24 = plain_mov && idesc->operands[0] == IA64_OPND_PR_ROT;
983 if (i23)
984 return strstr (format, "I23") != NULL;
985 if (i24)
986 return strstr (format, "I24") != NULL;
987 if (i25)
988 return strstr (format, "I25") != NULL;
990 else if (ic->name[5] == 's')
992 int m35 = plain_mov && idesc->operands[0] == IA64_OPND_PSR_L;
993 int m36 = plain_mov && idesc->operands[1] == IA64_OPND_PSR;
994 if (m35)
995 return strstr (format, "M35") != NULL;
996 if (m36)
997 return strstr (format, "M36") != NULL;
999 else
1000 abort ();
1001 break;
1002 case 'u':
1004 int m35 = plain_mov && idesc->operands[0] == IA64_OPND_PSR_UM;
1005 int m36 = plain_mov && idesc->operands[1] == IA64_OPND_PSR_UM;
1006 if (m35)
1007 return strstr (format, "M35") != NULL;
1008 if (m36)
1009 return strstr (format, "M36") != NULL;
1011 break;
1013 return 0;
1016 /* Is the given opcode in the given insn class? */
1017 static int
1018 in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
1019 const char *format, const char *field, int *notep)
1021 int i;
1022 int resolved = 0;
1024 if (ic->comment)
1026 if (!strncmp (ic->comment, "Format", 6))
1028 /* Assume that the first format seen is the most restrictive, and
1029 only keep a later one if it looks like it's more restrictive. */
1030 if (format)
1032 if (strlen (ic->comment) < strlen (format))
1034 warn (_("most recent format '%s'\nappears more restrictive than '%s'\n"),
1035 ic->comment, format);
1036 format = ic->comment;
1039 else
1040 format = ic->comment;
1042 else if (!strncmp (ic->comment, "Field", 5))
1044 if (field)
1045 warn (_("overlapping field %s->%s\n"),
1046 ic->comment, field);
1047 field = ic->comment;
1051 /* An insn class matches anything that is the same followed by completers,
1052 except when the absence and presence of completers constitutes different
1053 instructions. */
1054 if (ic->nsubs == 0 && ic->nxsubs == 0)
1056 int is_mov = strncmp (idesc->name, "mov", 3) == 0;
1057 int plain_mov = strcmp (idesc->name, "mov") == 0;
1058 int len = strlen(ic->name);
1060 resolved = ((strncmp (ic->name, idesc->name, len) == 0)
1061 && (idesc->name[len] == '\0'
1062 || idesc->name[len] == '.'));
1064 /* All break, nop, and hint variations must match exactly. */
1065 if (resolved &&
1066 (strcmp (ic->name, "break") == 0
1067 || strcmp (ic->name, "nop") == 0
1068 || strcmp (ic->name, "hint") == 0))
1069 resolved = strcmp (ic->name, idesc->name) == 0;
1071 /* Assume restrictions in the FORMAT/FIELD negate resolution,
1072 unless specifically allowed by clauses in this block. */
1073 if (resolved && field)
1075 /* Check Field(sf)==sN against opcode sN. */
1076 if (strstr(field, "(sf)==") != NULL)
1078 char *sf;
1080 if ((sf = strstr (idesc->name, ".s")) != 0)
1081 resolved = strcmp (sf + 1, strstr (field, "==") + 2) == 0;
1083 /* Check Field(lftype)==XXX. */
1084 else if (strstr (field, "(lftype)") != NULL)
1086 if (strstr (idesc->name, "fault") != NULL)
1087 resolved = strstr (field, "fault") != NULL;
1088 else
1089 resolved = strstr (field, "fault") == NULL;
1091 /* Handle Field(ctype)==XXX. */
1092 else if (strstr (field, "(ctype)") != NULL)
1094 if (strstr (idesc->name, "or.andcm"))
1095 resolved = strstr (field, "or.andcm") != NULL;
1096 else if (strstr (idesc->name, "and.orcm"))
1097 resolved = strstr (field, "and.orcm") != NULL;
1098 else if (strstr (idesc->name, "orcm"))
1099 resolved = strstr (field, "or orcm") != NULL;
1100 else if (strstr (idesc->name, "or"))
1101 resolved = strstr (field, "or orcm") != NULL;
1102 else if (strstr (idesc->name, "andcm"))
1103 resolved = strstr (field, "and andcm") != NULL;
1104 else if (strstr (idesc->name, "and"))
1105 resolved = strstr (field, "and andcm") != NULL;
1106 else if (strstr (idesc->name, "unc"))
1107 resolved = strstr (field, "unc") != NULL;
1108 else
1109 resolved = strcmp (field, "Field(ctype)==") == 0;
1113 if (resolved && format)
1115 if (strncmp (idesc->name, "dep", 3) == 0
1116 && strstr (format, "I13") != NULL)
1117 resolved = idesc->operands[1] == IA64_OPND_IMM8;
1118 else if (strncmp (idesc->name, "chk", 3) == 0
1119 && strstr (format, "M21") != NULL)
1120 resolved = idesc->operands[0] == IA64_OPND_F2;
1121 else if (strncmp (idesc->name, "lfetch", 6) == 0)
1122 resolved = (strstr (format, "M14 M15") != NULL
1123 && (idesc->operands[1] == IA64_OPND_R2
1124 || idesc->operands[1] == IA64_OPND_IMM9b));
1125 else if (strncmp (idesc->name, "br.call", 7) == 0
1126 && strstr (format, "B5") != NULL)
1127 resolved = idesc->operands[1] == IA64_OPND_B2;
1128 else if (strncmp (idesc->name, "br.call", 7) == 0
1129 && strstr (format, "B3") != NULL)
1130 resolved = idesc->operands[1] == IA64_OPND_TGT25c;
1131 else if (strncmp (idesc->name, "brp", 3) == 0
1132 && strstr (format, "B7") != NULL)
1133 resolved = idesc->operands[0] == IA64_OPND_B2;
1134 else if (strcmp (ic->name, "invala") == 0)
1135 resolved = strcmp (idesc->name, ic->name) == 0;
1136 else if (strncmp (idesc->name, "st", 2) == 0
1137 && strstr (format, "M5") != NULL)
1138 resolved = idesc->flags & IA64_OPCODE_POSTINC;
1139 else
1140 resolved = 0;
1143 /* Misc brl variations ('.cond' is optional);
1144 plain brl matches brl.cond. */
1145 if (!resolved
1146 && (strcmp (idesc->name, "brl") == 0
1147 || strncmp (idesc->name, "brl.", 4) == 0)
1148 && strcmp (ic->name, "brl.cond") == 0)
1150 resolved = 1;
1153 /* Misc br variations ('.cond' is optional). */
1154 if (!resolved
1155 && (strcmp (idesc->name, "br") == 0
1156 || strncmp (idesc->name, "br.", 3) == 0)
1157 && strcmp (ic->name, "br.cond") == 0)
1159 if (format)
1160 resolved = (strstr (format, "B4") != NULL
1161 && idesc->operands[0] == IA64_OPND_B2)
1162 || (strstr (format, "B1") != NULL
1163 && idesc->operands[0] == IA64_OPND_TGT25c);
1164 else
1165 resolved = 1;
1168 /* probe variations. */
1169 if (!resolved && strncmp (idesc->name, "probe", 5) == 0)
1171 resolved = strcmp (ic->name, "probe") == 0
1172 && !((strstr (idesc->name, "fault") != NULL)
1173 ^ (format && strstr (format, "M40") != NULL));
1176 /* mov variations. */
1177 if (!resolved && is_mov)
1179 if (plain_mov)
1181 /* mov alias for fmerge. */
1182 if (strcmp (ic->name, "fmerge") == 0)
1184 resolved = idesc->operands[0] == IA64_OPND_F1
1185 && idesc->operands[1] == IA64_OPND_F3;
1187 /* mov alias for adds (r3 or imm14). */
1188 else if (strcmp (ic->name, "adds") == 0)
1190 resolved = (idesc->operands[0] == IA64_OPND_R1
1191 && (idesc->operands[1] == IA64_OPND_R3
1192 || (idesc->operands[1] == IA64_OPND_IMM14)));
1194 /* mov alias for addl. */
1195 else if (strcmp (ic->name, "addl") == 0)
1197 resolved = idesc->operands[0] == IA64_OPND_R1
1198 && idesc->operands[1] == IA64_OPND_IMM22;
1202 /* Some variants of mov and mov.[im]. */
1203 if (!resolved && strncmp (ic->name, "mov_", 4) == 0)
1204 resolved = in_iclass_mov_x (idesc, ic, format, field);
1207 /* Keep track of this so we can flag any insn classes which aren't
1208 mapped onto at least one real insn. */
1209 if (resolved)
1210 ic->terminal_resolved = 1;
1212 else for (i = 0; i < ic->nsubs; i++)
1214 if (in_iclass (idesc, ics[ic->subs[i]], format, field, notep))
1216 int j;
1218 for (j = 0; j < ic->nxsubs; j++)
1219 if (in_iclass (idesc, ics[ic->xsubs[j]], NULL, NULL, NULL))
1220 return 0;
1222 if (debug > 1)
1223 printf ("%s is in IC %s\n", idesc->name, ic->name);
1225 resolved = 1;
1226 break;
1230 /* If it's in this IC, add the IC note (if any) to the insn. */
1231 if (resolved)
1233 if (ic->note && notep)
1235 if (*notep && *notep != ic->note)
1236 warn (_("overwriting note %d with note %d (IC:%s)\n"),
1237 *notep, ic->note, ic->name);
1239 *notep = ic->note;
1243 return resolved;
1247 static int
1248 lookup_regindex (const char *name, int specifier)
1250 switch (specifier)
1252 case IA64_RS_ARX:
1253 if (strstr (name, "[RSC]"))
1254 return 16;
1255 if (strstr (name, "[BSP]"))
1256 return 17;
1257 else if (strstr (name, "[BSPSTORE]"))
1258 return 18;
1259 else if (strstr (name, "[RNAT]"))
1260 return 19;
1261 else if (strstr (name, "[FCR]"))
1262 return 21;
1263 else if (strstr (name, "[EFLAG]"))
1264 return 24;
1265 else if (strstr (name, "[CSD]"))
1266 return 25;
1267 else if (strstr (name, "[SSD]"))
1268 return 26;
1269 else if (strstr (name, "[CFLG]"))
1270 return 27;
1271 else if (strstr (name, "[FSR]"))
1272 return 28;
1273 else if (strstr (name, "[FIR]"))
1274 return 29;
1275 else if (strstr (name, "[FDR]"))
1276 return 30;
1277 else if (strstr (name, "[CCV]"))
1278 return 32;
1279 else if (strstr (name, "[ITC]"))
1280 return 44;
1281 else if (strstr (name, "[PFS]"))
1282 return 64;
1283 else if (strstr (name, "[LC]"))
1284 return 65;
1285 else if (strstr (name, "[EC]"))
1286 return 66;
1287 abort ();
1288 case IA64_RS_CRX:
1289 if (strstr (name, "[DCR]"))
1290 return 0;
1291 else if (strstr (name, "[ITM]"))
1292 return 1;
1293 else if (strstr (name, "[IVA]"))
1294 return 2;
1295 else if (strstr (name, "[PTA]"))
1296 return 8;
1297 else if (strstr (name, "[GPTA]"))
1298 return 9;
1299 else if (strstr (name, "[IPSR]"))
1300 return 16;
1301 else if (strstr (name, "[ISR]"))
1302 return 17;
1303 else if (strstr (name, "[IIP]"))
1304 return 19;
1305 else if (strstr (name, "[IFA]"))
1306 return 20;
1307 else if (strstr (name, "[ITIR]"))
1308 return 21;
1309 else if (strstr (name, "[IIPA]"))
1310 return 22;
1311 else if (strstr (name, "[IFS]"))
1312 return 23;
1313 else if (strstr (name, "[IIM]"))
1314 return 24;
1315 else if (strstr (name, "[IHA]"))
1316 return 25;
1317 else if (strstr (name, "[LID]"))
1318 return 64;
1319 else if (strstr (name, "[IVR]"))
1320 return 65;
1321 else if (strstr (name, "[TPR]"))
1322 return 66;
1323 else if (strstr (name, "[EOI]"))
1324 return 67;
1325 else if (strstr (name, "[ITV]"))
1326 return 72;
1327 else if (strstr (name, "[PMV]"))
1328 return 73;
1329 else if (strstr (name, "[CMCV]"))
1330 return 74;
1331 abort ();
1332 case IA64_RS_PSR:
1333 if (strstr (name, ".be"))
1334 return 1;
1335 else if (strstr (name, ".up"))
1336 return 2;
1337 else if (strstr (name, ".ac"))
1338 return 3;
1339 else if (strstr (name, ".mfl"))
1340 return 4;
1341 else if (strstr (name, ".mfh"))
1342 return 5;
1343 else if (strstr (name, ".ic"))
1344 return 13;
1345 else if (strstr (name, ".i"))
1346 return 14;
1347 else if (strstr (name, ".pk"))
1348 return 15;
1349 else if (strstr (name, ".dt"))
1350 return 17;
1351 else if (strstr (name, ".dfl"))
1352 return 18;
1353 else if (strstr (name, ".dfh"))
1354 return 19;
1355 else if (strstr (name, ".sp"))
1356 return 20;
1357 else if (strstr (name, ".pp"))
1358 return 21;
1359 else if (strstr (name, ".di"))
1360 return 22;
1361 else if (strstr (name, ".si"))
1362 return 23;
1363 else if (strstr (name, ".db"))
1364 return 24;
1365 else if (strstr (name, ".lp"))
1366 return 25;
1367 else if (strstr (name, ".tb"))
1368 return 26;
1369 else if (strstr (name, ".rt"))
1370 return 27;
1371 else if (strstr (name, ".cpl"))
1372 return 32;
1373 else if (strstr (name, ".rs"))
1374 return 34;
1375 else if (strstr (name, ".mc"))
1376 return 35;
1377 else if (strstr (name, ".it"))
1378 return 36;
1379 else if (strstr (name, ".id"))
1380 return 37;
1381 else if (strstr (name, ".da"))
1382 return 38;
1383 else if (strstr (name, ".dd"))
1384 return 39;
1385 else if (strstr (name, ".ss"))
1386 return 40;
1387 else if (strstr (name, ".ri"))
1388 return 41;
1389 else if (strstr (name, ".ed"))
1390 return 43;
1391 else if (strstr (name, ".bn"))
1392 return 44;
1393 else if (strstr (name, ".ia"))
1394 return 45;
1395 else
1396 abort ();
1397 default:
1398 break;
1400 return REG_NONE;
1403 static int
1404 lookup_specifier (const char *name)
1406 if (strchr (name, '%'))
1408 if (strstr (name, "AR[K%]") != NULL)
1409 return IA64_RS_AR_K;
1410 if (strstr (name, "AR[UNAT]") != NULL)
1411 return IA64_RS_AR_UNAT;
1412 if (strstr (name, "AR%, % in 8") != NULL)
1413 return IA64_RS_AR;
1414 if (strstr (name, "AR%, % in 48") != NULL)
1415 return IA64_RS_ARb;
1416 if (strstr (name, "BR%") != NULL)
1417 return IA64_RS_BR;
1418 if (strstr (name, "CR[IRR%]") != NULL)
1419 return IA64_RS_CR_IRR;
1420 if (strstr (name, "CR[LRR%]") != NULL)
1421 return IA64_RS_CR_LRR;
1422 if (strstr (name, "CR%") != NULL)
1423 return IA64_RS_CR;
1424 if (strstr (name, "FR%, % in 0") != NULL)
1425 return IA64_RS_FR;
1426 if (strstr (name, "FR%, % in 2") != NULL)
1427 return IA64_RS_FRb;
1428 if (strstr (name, "GR%") != NULL)
1429 return IA64_RS_GR;
1430 if (strstr (name, "PR%, % in 1 ") != NULL)
1431 return IA64_RS_PR;
1432 if (strstr (name, "PR%, % in 16 ") != NULL)
1433 return IA64_RS_PRr;
1435 warn (_("don't know how to specify %% dependency %s\n"),
1436 name);
1438 else if (strchr (name, '#'))
1440 if (strstr (name, "CPUID#") != NULL)
1441 return IA64_RS_CPUID;
1442 if (strstr (name, "DBR#") != NULL)
1443 return IA64_RS_DBR;
1444 if (strstr (name, "IBR#") != NULL)
1445 return IA64_RS_IBR;
1446 if (strstr (name, "MSR#") != NULL)
1447 return IA64_RS_MSR;
1448 if (strstr (name, "PKR#") != NULL)
1449 return IA64_RS_PKR;
1450 if (strstr (name, "PMC#") != NULL)
1451 return IA64_RS_PMC;
1452 if (strstr (name, "PMD#") != NULL)
1453 return IA64_RS_PMD;
1454 if (strstr (name, "RR#") != NULL)
1455 return IA64_RS_RR;
1457 warn (_("Don't know how to specify # dependency %s\n"),
1458 name);
1460 else if (strncmp (name, "AR[FPSR]", 8) == 0)
1461 return IA64_RS_AR_FPSR;
1462 else if (strncmp (name, "AR[", 3) == 0)
1463 return IA64_RS_ARX;
1464 else if (strncmp (name, "CR[", 3) == 0)
1465 return IA64_RS_CRX;
1466 else if (strncmp (name, "PSR.", 4) == 0)
1467 return IA64_RS_PSR;
1468 else if (strcmp (name, "InService*") == 0)
1469 return IA64_RS_INSERVICE;
1470 else if (strcmp (name, "GR0") == 0)
1471 return IA64_RS_GR0;
1472 else if (strcmp (name, "CFM") == 0)
1473 return IA64_RS_CFM;
1474 else if (strcmp (name, "PR63") == 0)
1475 return IA64_RS_PR63;
1476 else if (strcmp (name, "RSE") == 0)
1477 return IA64_RS_RSE;
1479 return IA64_RS_ANY;
1482 static void
1483 print_dependency_table ()
1485 int i, j;
1487 if (debug)
1489 for (i=0;i < iclen;i++)
1491 if (ics[i]->is_class)
1493 if (!ics[i]->nsubs)
1495 if (ics[i]->comment)
1496 warn (_("IC:%s [%s] has no terminals or sub-classes\n"),
1497 ics[i]->name, ics[i]->comment);
1498 else
1499 warn (_("IC:%s has no terminals or sub-classes\n"),
1500 ics[i]->name);
1503 else
1505 if (!ics[i]->terminal_resolved && !ics[i]->orphan)
1507 if (ics[i]->comment)
1508 warn (_("no insns mapped directly to terminal IC %s [%s]"),
1509 ics[i]->name, ics[i]->comment);
1510 else
1511 warn (_("no insns mapped directly to terminal IC %s\n"),
1512 ics[i]->name);
1517 for (i = 0; i < iclen; i++)
1519 if (ics[i]->orphan)
1521 mark_used (ics[i], 1);
1522 warn (_("class %s is defined but not used\n"),
1523 ics[i]->name);
1527 if (debug > 1)
1528 for (i = 0; i < rdepslen; i++)
1530 static const char *mode_str[] = { "RAW", "WAW", "WAR" };
1532 if (rdeps[i]->total_chks == 0)
1533 warn (_("Warning: rsrc %s (%s) has no chks%s\n"),
1534 rdeps[i]->name, mode_str[rdeps[i]->mode],
1535 rdeps[i]->total_regs ? "" : " or regs");
1536 else if (rdeps[i]->total_regs == 0)
1537 warn (_("rsrc %s (%s) has no regs\n"),
1538 rdeps[i]->name, mode_str[rdeps[i]->mode]);
1542 /* The dependencies themselves. */
1543 printf ("static const struct ia64_dependency\ndependencies[] = {\n");
1544 for (i = 0; i < rdepslen; i++)
1546 /* '%', '#', AR[], CR[], or PSR. indicates we need to specify the actual
1547 resource used. */
1548 int specifier = lookup_specifier (rdeps[i]->name);
1549 int regindex = lookup_regindex (rdeps[i]->name, specifier);
1551 printf (" { \"%s\", %d, %d, %d, %d, ",
1552 rdeps[i]->name, specifier,
1553 (int)rdeps[i]->mode, (int)rdeps[i]->semantics, regindex);
1554 if (rdeps[i]->semantics == IA64_DVS_OTHER)
1555 printf ("\"%s\", ", rdeps[i]->extra);
1556 else
1557 printf ("NULL, ");
1558 printf("},\n");
1560 printf ("};\n\n");
1562 /* And dependency lists. */
1563 for (i=0;i < dlistlen;i++)
1565 int len = 2;
1566 printf ("static const short dep%d[] = {\n ", i);
1567 for (j=0;j < dlists[i]->len; j++)
1569 len += printf ("%d, ", dlists[i]->deps[j]);
1570 if (len > 75)
1572 printf("\n ");
1573 len = 2;
1576 printf ("\n};\n\n");
1579 /* And opcode dependency list. */
1580 printf ("#define NELS(X) (sizeof(X)/sizeof(X[0]))\n");
1581 printf ("static const struct ia64_opcode_dependency\n");
1582 printf ("op_dependencies[] = {\n");
1583 for (i = 0; i < opdeplen; i++)
1585 printf (" { ");
1586 if (opdeps[i]->chk == -1)
1587 printf ("0, NULL, ");
1588 else
1589 printf ("NELS(dep%d), dep%d, ", opdeps[i]->chk, opdeps[i]->chk);
1590 if (opdeps[i]->reg == -1)
1591 printf ("0, NULL, ");
1592 else
1593 printf ("NELS(dep%d), dep%d, ", opdeps[i]->reg, opdeps[i]->reg);
1594 printf ("},\n");
1596 printf ("};\n\n");
1600 /* Add STR to the string table. */
1601 static struct string_entry *
1602 insert_string (char *str)
1604 int start = 0, end = strtablen;
1605 int i, x;
1607 if (strtablen == strtabtotlen)
1609 strtabtotlen += 20;
1610 string_table = (struct string_entry **)
1611 xrealloc (string_table,
1612 sizeof (struct string_entry **) * strtabtotlen);
1615 if (strtablen == 0)
1617 strtablen = 1;
1618 string_table[0] = tmalloc (struct string_entry);
1619 string_table[0]->s = xstrdup (str);
1620 string_table[0]->num = 0;
1621 return string_table[0];
1624 if (strcmp (str, string_table[strtablen - 1]->s) > 0)
1625 i = end;
1626 else if (strcmp (str, string_table[0]->s) < 0)
1627 i = 0;
1628 else
1630 while (1)
1632 int c;
1634 i = (start + end) / 2;
1635 c = strcmp (str, string_table[i]->s);
1637 if (c < 0)
1638 end = i - 1;
1639 else if (c == 0)
1640 return string_table[i];
1641 else
1642 start = i + 1;
1644 if (start > end)
1645 break;
1649 for (; i > 0 && i < strtablen; i--)
1650 if (strcmp (str, string_table[i - 1]->s) > 0)
1651 break;
1653 for (; i < strtablen; i++)
1654 if (strcmp (str, string_table[i]->s) < 0)
1655 break;
1657 for (x = strtablen - 1; x >= i; x--)
1659 string_table[x + 1] = string_table[x];
1660 string_table[x + 1]->num = x + 1;
1663 string_table[i] = tmalloc (struct string_entry);
1664 string_table[i]->s = xstrdup (str);
1665 string_table[i]->num = i;
1666 strtablen++;
1668 return string_table[i];
1671 static struct bittree *
1672 make_bittree_entry (void)
1674 struct bittree *res = tmalloc (struct bittree);
1676 res->disent = NULL;
1677 res->bits[0] = NULL;
1678 res->bits[1] = NULL;
1679 res->bits[2] = NULL;
1680 res->skip_flag = 0;
1681 res->bits_to_skip = 0;
1682 return res;
1686 static struct disent *
1687 add_dis_table_ent (which, insn, order, completer_index)
1688 struct disent *which;
1689 int insn;
1690 int order;
1691 int completer_index;
1693 int ci = 0;
1694 struct disent *ent;
1696 if (which != NULL)
1698 ent = which;
1700 ent->nextcnt++;
1701 while (ent->nexte != NULL)
1702 ent = ent->nexte;
1704 ent = (ent->nexte = tmalloc (struct disent));
1706 else
1708 ent = tmalloc (struct disent);
1709 ent->next_ent = disinsntable;
1710 disinsntable = ent;
1711 which = ent;
1713 ent->nextcnt = 0;
1714 ent->nexte = NULL;
1715 ent->insn = insn;
1716 ent->priority = order;
1718 while (completer_index != 1)
1720 ci = (ci << 1) | (completer_index & 1);
1721 completer_index >>= 1;
1723 ent->completer_index = ci;
1724 return which;
1727 static void
1728 finish_distable ()
1730 struct disent *ent = disinsntable;
1731 struct disent *prev = ent;
1733 ent->ournum = 32768;
1734 while ((ent = ent->next_ent) != NULL)
1736 ent->ournum = prev->ournum + prev->nextcnt + 1;
1737 prev = ent;
1741 static void
1742 insert_bit_table_ent (curr_ent, bit, opcode, mask,
1743 opcodenum, order, completer_index)
1744 struct bittree *curr_ent;
1745 int bit;
1746 ia64_insn opcode;
1747 ia64_insn mask;
1748 int opcodenum;
1749 int order;
1750 int completer_index;
1752 ia64_insn m;
1753 int b;
1754 struct bittree *next;
1756 if (bit == -1)
1758 struct disent *nent = add_dis_table_ent (curr_ent->disent,
1759 opcodenum, order,
1760 completer_index);
1761 curr_ent->disent = nent;
1762 return;
1765 m = ((ia64_insn) 1) << bit;
1767 if (mask & m)
1768 b = (opcode & m) ? 1 : 0;
1769 else
1770 b = 2;
1772 next = curr_ent->bits[b];
1773 if (next == NULL)
1775 next = make_bittree_entry ();
1776 curr_ent->bits[b] = next;
1778 insert_bit_table_ent (next, bit - 1, opcode, mask, opcodenum, order,
1779 completer_index);
1782 static void
1783 add_dis_entry (first, opcode, mask, opcodenum, ent, completer_index)
1784 struct bittree *first;
1785 ia64_insn opcode;
1786 ia64_insn mask;
1787 int opcodenum;
1788 struct completer_entry *ent;
1789 int completer_index;
1791 if (completer_index & (1 << 20))
1792 abort ();
1794 while (ent != NULL)
1796 ia64_insn newopcode = (opcode & (~ ent->mask)) | ent->bits;
1797 add_dis_entry (first, newopcode, mask, opcodenum, ent->addl_entries,
1798 (completer_index << 1) | 1);
1800 if (ent->is_terminal)
1802 insert_bit_table_ent (bittree, 40, newopcode, mask,
1803 opcodenum, opcode_count - ent->order - 1,
1804 (completer_index << 1) | 1);
1806 completer_index <<= 1;
1807 ent = ent->alternative;
1811 /* This optimization pass combines multiple "don't care" nodes. */
1812 static void
1813 compact_distree (ent)
1814 struct bittree *ent;
1816 #define IS_SKIP(ent) \
1817 ((ent->bits[2] !=NULL) \
1818 && (ent->bits[0] == NULL && ent->bits[1] == NULL && ent->skip_flag == 0))
1820 int bitcnt = 0;
1821 struct bittree *nent = ent;
1822 int x;
1824 while (IS_SKIP (nent))
1826 bitcnt++;
1827 nent = nent->bits[2];
1830 if (bitcnt)
1832 struct bittree *next = ent->bits[2];
1834 ent->bits[0] = nent->bits[0];
1835 ent->bits[1] = nent->bits[1];
1836 ent->bits[2] = nent->bits[2];
1837 ent->disent = nent->disent;
1838 ent->skip_flag = 1;
1839 ent->bits_to_skip = bitcnt;
1840 while (next != nent)
1842 struct bittree *b = next;
1843 next = next->bits[2];
1844 free (b);
1846 free (nent);
1849 for (x = 0; x < 3; x++)
1851 struct bittree *i = ent->bits[x];
1853 if (i != NULL)
1854 compact_distree (i);
1858 static unsigned char *insn_list;
1859 static int insn_list_len = 0;
1860 static int tot_insn_list_len = 0;
1862 /* Generate the disassembler state machine corresponding to the tree
1863 in ENT. */
1864 static void
1865 gen_dis_table (ent)
1866 struct bittree *ent;
1868 int x;
1869 int our_offset = insn_list_len;
1870 int bitsused = 5;
1871 int totbits = bitsused;
1872 int needed_bytes;
1873 int zero_count = 0;
1874 int zero_dest = 0; /* Initialize this with 0 to keep gcc quiet... */
1876 /* If this is a terminal entry, there's no point in skipping any
1877 bits. */
1878 if (ent->skip_flag && ent->bits[0] == NULL && ent->bits[1] == NULL &&
1879 ent->bits[2] == NULL)
1881 if (ent->disent == NULL)
1882 abort ();
1883 else
1884 ent->skip_flag = 0;
1887 /* Calculate the amount of space needed for this entry, or at least
1888 a conservatively large approximation. */
1889 if (ent->skip_flag)
1890 totbits += 5;
1892 for (x = 1; x < 3; x++)
1893 if (ent->bits[x] != NULL)
1894 totbits += 16;
1896 if (ent->disent != NULL)
1898 if (ent->bits[2] != NULL)
1899 abort ();
1901 totbits += 16;
1904 /* Now allocate the space. */
1905 needed_bytes = (totbits + 7) / 8;
1906 if ((needed_bytes + insn_list_len) > tot_insn_list_len)
1908 tot_insn_list_len += 256;
1909 insn_list = (char *) xrealloc (insn_list, tot_insn_list_len);
1911 our_offset = insn_list_len;
1912 insn_list_len += needed_bytes;
1913 memset (insn_list + our_offset, 0, needed_bytes);
1915 /* Encode the skip entry by setting bit 6 set in the state op field,
1916 and store the # of bits to skip immediately after. */
1917 if (ent->skip_flag)
1919 bitsused += 5;
1920 insn_list[our_offset + 0] |= 0x40 | ((ent->bits_to_skip >> 2) & 0xf);
1921 insn_list[our_offset + 1] |= ((ent->bits_to_skip & 3) << 6);
1924 #define IS_ONLY_IFZERO(ENT) \
1925 ((ENT)->bits[0] != NULL && (ENT)->bits[1] == NULL && (ENT)->bits[2] == NULL \
1926 && (ENT)->disent == NULL && (ENT)->skip_flag == 0)
1928 /* Store an "if (bit is zero)" instruction by setting bit 7 in the
1929 state op field. */
1930 if (ent->bits[0] != NULL)
1932 struct bittree *nent = ent->bits[0];
1933 zero_count = 0;
1935 insn_list[our_offset] |= 0x80;
1937 /* We can encode sequences of multiple "if (bit is zero)" tests
1938 by storing the # of zero bits to check in the lower 3 bits of
1939 the instruction. However, this only applies if the state
1940 solely tests for a zero bit. */
1942 if (IS_ONLY_IFZERO (ent))
1944 while (IS_ONLY_IFZERO (nent) && zero_count < 7)
1946 nent = nent->bits[0];
1947 zero_count++;
1950 insn_list[our_offset + 0] |= zero_count;
1952 zero_dest = insn_list_len;
1953 gen_dis_table (nent);
1956 /* Now store the remaining tests. We also handle a sole "termination
1957 entry" by storing it as an "any bit" test. */
1959 for (x = 1; x < 3; x++)
1961 if (ent->bits[x] != NULL || (x == 2 && ent->disent != NULL))
1963 struct bittree *i = ent->bits[x];
1964 int idest;
1965 int currbits = 15;
1967 if (i != NULL)
1969 /* If the instruction being branched to only consists of
1970 a termination entry, use the termination entry as the
1971 place to branch to instead. */
1972 if (i->bits[0] == NULL && i->bits[1] == NULL
1973 && i->bits[2] == NULL && i->disent != NULL)
1975 idest = i->disent->ournum;
1976 i = NULL;
1978 else
1979 idest = insn_list_len - our_offset;
1981 else
1982 idest = ent->disent->ournum;
1984 /* If the destination offset for the if (bit is 1) test is less
1985 than 256 bytes away, we can store it as 8-bits instead of 16;
1986 the instruction has bit 5 set for the 16-bit address, and bit
1987 4 for the 8-bit address. Since we've already allocated 16
1988 bits for the address we need to deallocate the space.
1990 Note that branchings within the table are relative, and
1991 there are no branches that branch past our instruction yet
1992 so we do not need to adjust any other offsets. */
1993 if (x == 1)
1995 if (idest <= 256)
1997 int start = our_offset + bitsused / 8 + 1;
1999 memmove (insn_list + start,
2000 insn_list + start + 1,
2001 insn_list_len - (start + 1));
2002 currbits = 7;
2003 totbits -= 8;
2004 needed_bytes--;
2005 insn_list_len--;
2006 insn_list[our_offset] |= 0x10;
2007 idest--;
2009 else
2010 insn_list[our_offset] |= 0x20;
2012 else
2014 /* An instruction which solely consists of a termination
2015 marker and whose disassembly name index is < 4096
2016 can be stored in 16 bits. The encoding is slightly
2017 odd; the upper 4 bits of the instruction are 0x3, and
2018 bit 3 loses its normal meaning. */
2020 if (ent->bits[0] == NULL && ent->bits[1] == NULL
2021 && ent->bits[2] == NULL && ent->skip_flag == 0
2022 && ent->disent != NULL
2023 && ent->disent->ournum < (32768 + 4096))
2025 int start = our_offset + bitsused / 8 + 1;
2027 memmove (insn_list + start,
2028 insn_list + start + 1,
2029 insn_list_len - (start + 1));
2030 currbits = 11;
2031 totbits -= 5;
2032 bitsused--;
2033 needed_bytes--;
2034 insn_list_len--;
2035 insn_list[our_offset] |= 0x30;
2036 idest &= ~32768;
2038 else
2039 insn_list[our_offset] |= 0x08;
2042 if (debug)
2044 int id = idest;
2046 if (i == NULL)
2047 id |= 32768;
2048 else if (! (id & 32768))
2049 id += our_offset;
2051 if (x == 1)
2052 printf ("%d: if (1) goto %d\n", our_offset, id);
2053 else
2054 printf ("%d: try %d\n", our_offset, id);
2057 /* Store the address of the entry being branched to. */
2058 while (currbits >= 0)
2060 char *byte = insn_list + our_offset + bitsused / 8;
2062 if (idest & (1 << currbits))
2063 *byte |= (1 << (7 - (bitsused % 8)));
2065 bitsused++;
2066 currbits--;
2069 /* Now generate the states for the entry being branched to. */
2070 if (i != NULL)
2071 gen_dis_table (i);
2075 if (debug)
2077 if (ent->skip_flag)
2078 printf ("%d: skipping %d\n", our_offset, ent->bits_to_skip);
2080 if (ent->bits[0] != NULL)
2081 printf ("%d: if (0:%d) goto %d\n", our_offset, zero_count + 1,
2082 zero_dest);
2085 if (bitsused != totbits)
2086 abort ();
2089 static void
2090 print_dis_table (void)
2092 int x;
2093 struct disent *cent = disinsntable;
2095 printf ("static const char dis_table[] = {\n");
2096 for (x = 0; x < insn_list_len; x++)
2098 if ((x > 0) && ((x % 12) == 0))
2099 printf ("\n");
2101 printf ("0x%02x, ", insn_list[x]);
2103 printf ("\n};\n\n");
2105 printf ("static const struct ia64_dis_names ia64_dis_names[] = {\n");
2106 while (cent != NULL)
2108 struct disent *ent = cent;
2110 while (ent != NULL)
2112 printf ("{ 0x%x, %d, %d, %d },\n", ent->completer_index,
2113 ent->insn, (ent->nexte != NULL ? 1 : 0),
2114 ent->priority);
2115 ent = ent->nexte;
2117 cent = cent->next_ent;
2119 printf ("};\n\n");
2122 static void
2123 generate_disassembler (void)
2125 int i;
2127 bittree = make_bittree_entry ();
2129 for (i = 0; i < otlen; i++)
2131 struct main_entry *ptr = ordered_table[i];
2133 if (ptr->opcode->type != IA64_TYPE_DYN)
2134 add_dis_entry (bittree,
2135 ptr->opcode->opcode, ptr->opcode->mask,
2136 ptr->main_index,
2137 ptr->completers, 1);
2140 compact_distree (bittree);
2141 finish_distable ();
2142 gen_dis_table (bittree);
2144 print_dis_table ();
2147 static void
2148 print_string_table (void)
2150 int x;
2151 char lbuf[80], buf[80];
2152 int blen = 0;
2154 printf ("static const char * const ia64_strings[] = {\n");
2155 lbuf[0] = '\0';
2157 for (x = 0; x < strtablen; x++)
2159 int len;
2161 if (strlen (string_table[x]->s) > 75)
2162 abort ();
2164 sprintf (buf, " \"%s\",", string_table[x]->s);
2165 len = strlen (buf);
2167 if ((blen + len) > 75)
2169 printf (" %s\n", lbuf);
2170 lbuf[0] = '\0';
2171 blen = 0;
2173 strcat (lbuf, buf);
2174 blen += len;
2177 if (blen > 0)
2178 printf (" %s\n", lbuf);
2180 printf ("};\n\n");
2183 static struct completer_entry **glist;
2184 static int glistlen = 0;
2185 static int glisttotlen = 0;
2187 /* If the completer trees ENT1 and ENT2 are equal, return 1. */
2189 static int
2190 completer_entries_eq (ent1, ent2)
2191 struct completer_entry *ent1, *ent2;
2193 while (ent1 != NULL && ent2 != NULL)
2195 if (ent1->name->num != ent2->name->num
2196 || ent1->bits != ent2->bits
2197 || ent1->mask != ent2->mask
2198 || ent1->is_terminal != ent2->is_terminal
2199 || ent1->dependencies != ent2->dependencies
2200 || ent1->order != ent2->order)
2201 return 0;
2203 if (! completer_entries_eq (ent1->addl_entries, ent2->addl_entries))
2204 return 0;
2206 ent1 = ent1->alternative;
2207 ent2 = ent2->alternative;
2210 return ent1 == ent2;
2213 /* Insert ENT into the global list of completers and return it. If an
2214 equivalent entry (according to completer_entries_eq) already exists,
2215 it is returned instead. */
2216 static struct completer_entry *
2217 insert_gclist (struct completer_entry *ent)
2219 if (ent != NULL)
2221 int i;
2222 int x;
2223 int start = 0, end;
2225 ent->addl_entries = insert_gclist (ent->addl_entries);
2226 ent->alternative = insert_gclist (ent->alternative);
2228 i = glistlen / 2;
2229 end = glistlen;
2231 if (glisttotlen == glistlen)
2233 glisttotlen += 20;
2234 glist = (struct completer_entry **)
2235 xrealloc (glist, sizeof (struct completer_entry *) * glisttotlen);
2238 if (glistlen == 0)
2240 glist[0] = ent;
2241 glistlen = 1;
2242 return ent;
2245 if (ent->name->num < glist[0]->name->num)
2246 i = 0;
2247 else if (ent->name->num > glist[end - 1]->name->num)
2248 i = end;
2249 else
2251 int c;
2253 while (1)
2255 i = (start + end) / 2;
2256 c = ent->name->num - glist[i]->name->num;
2258 if (c < 0)
2259 end = i - 1;
2260 else if (c == 0)
2262 while (i > 0
2263 && ent->name->num == glist[i - 1]->name->num)
2264 i--;
2266 break;
2268 else
2269 start = i + 1;
2271 if (start > end)
2272 break;
2275 if (c == 0)
2277 while (i < glistlen)
2279 if (ent->name->num != glist[i]->name->num)
2280 break;
2282 if (completer_entries_eq (ent, glist[i]))
2283 return glist[i];
2285 i++;
2290 for (; i > 0 && i < glistlen; i--)
2291 if (ent->name->num >= glist[i - 1]->name->num)
2292 break;
2294 for (; i < glistlen; i++)
2295 if (ent->name->num < glist[i]->name->num)
2296 break;
2298 for (x = glistlen - 1; x >= i; x--)
2299 glist[x + 1] = glist[x];
2301 glist[i] = ent;
2302 glistlen++;
2304 return ent;
2307 static int
2308 get_prefix_len (name)
2309 const char *name;
2311 char *c;
2313 if (name[0] == '\0')
2314 return 0;
2316 c = strchr (name, '.');
2317 if (c != NULL)
2318 return c - name;
2319 else
2320 return strlen (name);
2323 static void
2324 compute_completer_bits (ment, ent)
2325 struct main_entry *ment;
2326 struct completer_entry *ent;
2328 while (ent != NULL)
2330 compute_completer_bits (ment, ent->addl_entries);
2332 if (ent->is_terminal)
2334 ia64_insn mask = 0;
2335 ia64_insn our_bits = ent->bits;
2336 struct completer_entry *p = ent->parent;
2337 ia64_insn p_bits;
2338 int x;
2340 while (p != NULL && ! p->is_terminal)
2341 p = p->parent;
2343 if (p != NULL)
2344 p_bits = p->bits;
2345 else
2346 p_bits = ment->opcode->opcode;
2348 for (x = 0; x < 64; x++)
2350 ia64_insn m = ((ia64_insn) 1) << x;
2352 if ((p_bits & m) != (our_bits & m))
2353 mask |= m;
2354 else
2355 our_bits &= ~m;
2357 ent->bits = our_bits;
2358 ent->mask = mask;
2360 else
2362 ent->bits = 0;
2363 ent->mask = 0;
2366 ent = ent->alternative;
2370 /* Find identical completer trees that are used in different
2371 instructions and collapse their entries. */
2372 static void
2373 collapse_redundant_completers (void)
2375 struct main_entry *ptr;
2376 int x;
2378 for (ptr = maintable; ptr != NULL; ptr = ptr->next)
2380 if (ptr->completers == NULL)
2381 abort ();
2383 compute_completer_bits (ptr, ptr->completers);
2384 ptr->completers = insert_gclist (ptr->completers);
2387 /* The table has been finalized, now number the indexes. */
2388 for (x = 0; x < glistlen; x++)
2389 glist[x]->num = x;
2393 /* Attach two lists of dependencies to each opcode.
2394 1) all resources which, when already marked in use, conflict with this
2395 opcode (chks)
2396 2) all resources which must be marked in use when this opcode is used
2397 (regs). */
2398 static int
2399 insert_opcode_dependencies (opc, cmp)
2400 struct ia64_opcode *opc;
2401 struct completer_entry *cmp ATTRIBUTE_UNUSED;
2403 /* Note all resources which point to this opcode. rfi has the most chks
2404 (79) and cmpxchng has the most regs (54) so 100 here should be enough. */
2405 int i;
2406 int nregs = 0;
2407 unsigned short regs[256];
2408 int nchks = 0;
2409 unsigned short chks[256];
2410 /* Flag insns for which no class matched; there should be none. */
2411 int no_class_found = 1;
2413 for (i = 0; i < rdepslen; i++)
2415 struct rdep *rs = rdeps[i];
2416 int j;
2418 if (strcmp (opc->name, "cmp.eq.and") == 0
2419 && strncmp (rs->name, "PR%", 3) == 0
2420 && rs->mode == 1)
2421 no_class_found = 99;
2423 for (j=0; j < rs->nregs;j++)
2425 int ic_note = 0;
2427 if (in_iclass (opc, ics[rs->regs[j]], NULL, NULL, &ic_note))
2429 /* We can ignore ic_note 11 for non PR resources. */
2430 if (ic_note == 11 && strncmp (rs->name, "PR", 2) != 0)
2431 ic_note = 0;
2433 if (ic_note != 0 && rs->regnotes[j] != 0
2434 && ic_note != rs->regnotes[j]
2435 && !(ic_note == 11 && rs->regnotes[j] == 1))
2436 warn (_("IC note %d in opcode %s (IC:%s) conflicts with resource %s note %d\n"),
2437 ic_note, opc->name, ics[rs->regs[j]]->name,
2438 rs->name, rs->regnotes[j]);
2439 /* Instruction class notes override resource notes.
2440 So far, only note 11 applies to an IC instead of a resource,
2441 and note 11 implies note 1. */
2442 if (ic_note)
2443 regs[nregs++] = RDEP(ic_note, i);
2444 else
2445 regs[nregs++] = RDEP(rs->regnotes[j], i);
2446 no_class_found = 0;
2447 ++rs->total_regs;
2451 for (j = 0; j < rs->nchks; j++)
2453 int ic_note = 0;
2455 if (in_iclass (opc, ics[rs->chks[j]], NULL, NULL, &ic_note))
2457 /* We can ignore ic_note 11 for non PR resources. */
2458 if (ic_note == 11 && strncmp (rs->name, "PR", 2) != 0)
2459 ic_note = 0;
2461 if (ic_note != 0 && rs->chknotes[j] != 0
2462 && ic_note != rs->chknotes[j]
2463 && !(ic_note == 11 && rs->chknotes[j] == 1))
2464 warn (_("IC note %d for opcode %s (IC:%s) conflicts with resource %s note %d\n"),
2465 ic_note, opc->name, ics[rs->chks[j]]->name,
2466 rs->name, rs->chknotes[j]);
2467 if (ic_note)
2468 chks[nchks++] = RDEP(ic_note, i);
2469 else
2470 chks[nchks++] = RDEP(rs->chknotes[j], i);
2471 no_class_found = 0;
2472 ++rs->total_chks;
2477 if (no_class_found)
2478 warn (_("opcode %s has no class (ops %d %d %d)\n"),
2479 opc->name,
2480 opc->operands[0], opc->operands[1], opc->operands[2]);
2482 return insert_dependencies (nchks, chks, nregs, regs);
2485 static void
2486 insert_completer_entry (opc, tabent, order)
2487 struct ia64_opcode *opc;
2488 struct main_entry *tabent;
2489 int order;
2491 struct completer_entry **ptr = &tabent->completers;
2492 struct completer_entry *parent = NULL;
2493 char pcopy[129], *prefix;
2494 int at_end = 0;
2496 if (strlen (opc->name) > 128)
2497 abort ();
2499 strcpy (pcopy, opc->name);
2500 prefix = pcopy + get_prefix_len (pcopy);
2502 if (prefix[0] != '\0')
2503 prefix++;
2505 while (! at_end)
2507 int need_new_ent = 1;
2508 int plen = get_prefix_len (prefix);
2509 struct string_entry *sent;
2511 at_end = (prefix[plen] == '\0');
2512 prefix[plen] = '\0';
2513 sent = insert_string (prefix);
2515 while (*ptr != NULL)
2517 int cmpres = sent->num - (*ptr)->name->num;
2519 if (cmpres == 0)
2521 need_new_ent = 0;
2522 break;
2524 else
2525 ptr = &((*ptr)->alternative);
2528 if (need_new_ent)
2530 struct completer_entry *nent = tmalloc (struct completer_entry);
2532 nent->name = sent;
2533 nent->parent = parent;
2534 nent->addl_entries = NULL;
2535 nent->alternative = *ptr;
2536 *ptr = nent;
2537 nent->is_terminal = 0;
2538 nent->dependencies = -1;
2541 if (! at_end)
2543 parent = *ptr;
2544 ptr = &((*ptr)->addl_entries);
2545 prefix += plen + 1;
2549 if ((*ptr)->is_terminal)
2550 abort ();
2552 (*ptr)->is_terminal = 1;
2553 (*ptr)->mask = (ia64_insn)-1;
2554 (*ptr)->bits = opc->opcode;
2555 (*ptr)->dependencies = insert_opcode_dependencies (opc, *ptr);
2556 (*ptr)->order = order;
2559 static void
2560 print_completer_entry (ent)
2561 struct completer_entry *ent;
2563 int moffset = 0;
2564 ia64_insn mask = ent->mask, bits = ent->bits;
2566 if (mask != 0)
2568 while (! (mask & 1))
2570 moffset++;
2571 mask = mask >> 1;
2572 bits = bits >> 1;
2575 if (bits & 0xffffffff00000000LL)
2576 abort ();
2579 printf (" { 0x%x, 0x%x, %d, %d, %d, %d, %d, %d },\n",
2580 (int)bits,
2581 (int)mask,
2582 ent->name->num,
2583 ent->alternative != NULL ? ent->alternative->num : -1,
2584 ent->addl_entries != NULL ? ent->addl_entries->num : -1,
2585 moffset,
2586 ent->is_terminal ? 1 : 0,
2587 ent->dependencies);
2590 static void
2591 print_completer_table ()
2593 int x;
2595 printf ("static const struct ia64_completer_table\ncompleter_table[] = {\n");
2596 for (x = 0; x < glistlen; x++)
2597 print_completer_entry (glist[x]);
2598 printf ("};\n\n");
2601 static int
2602 opcodes_eq (opc1, opc2)
2603 struct ia64_opcode *opc1;
2604 struct ia64_opcode *opc2;
2606 int x;
2607 int plen1, plen2;
2609 if ((opc1->mask != opc2->mask) || (opc1->type != opc2->type)
2610 || (opc1->num_outputs != opc2->num_outputs)
2611 || (opc1->flags != opc2->flags))
2612 return 0;
2614 for (x = 0; x < 5; x++)
2615 if (opc1->operands[x] != opc2->operands[x])
2616 return 0;
2618 plen1 = get_prefix_len (opc1->name);
2619 plen2 = get_prefix_len (opc2->name);
2621 if (plen1 == plen2 && (memcmp (opc1->name, opc2->name, plen1) == 0))
2622 return 1;
2624 return 0;
2627 static void
2628 add_opcode_entry (opc)
2629 struct ia64_opcode *opc;
2631 struct main_entry **place;
2632 struct string_entry *name;
2633 char prefix[129];
2634 int found_it = 0;
2636 if (strlen (opc->name) > 128)
2637 abort ();
2639 place = &maintable;
2640 strcpy (prefix, opc->name);
2641 prefix[get_prefix_len (prefix)] = '\0';
2642 name = insert_string (prefix);
2644 /* Walk the list of opcode table entries. If it's a new
2645 instruction, allocate and fill in a new entry. Note
2646 the main table is alphabetical by opcode name. */
2648 while (*place != NULL)
2650 if ((*place)->name->num == name->num
2651 && opcodes_eq ((*place)->opcode, opc))
2653 found_it = 1;
2654 break;
2656 if ((*place)->name->num > name->num)
2657 break;
2659 place = &((*place)->next);
2661 if (! found_it)
2663 struct main_entry *nent = tmalloc (struct main_entry);
2665 nent->name = name;
2666 nent->opcode = opc;
2667 nent->next = *place;
2668 nent->completers = 0;
2669 *place = nent;
2671 if (otlen == ottotlen)
2673 ottotlen += 20;
2674 ordered_table = (struct main_entry **)
2675 xrealloc (ordered_table, sizeof (struct main_entry *) * ottotlen);
2677 ordered_table[otlen++] = nent;
2680 insert_completer_entry (opc, *place, opcode_count++);
2683 static void
2684 print_main_table (void)
2686 struct main_entry *ptr = maintable;
2687 int index = 0;
2689 printf ("static const struct ia64_main_table\nmain_table[] = {\n");
2690 while (ptr != NULL)
2692 printf (" { %d, %d, %d, 0x",
2693 ptr->name->num,
2694 ptr->opcode->type,
2695 ptr->opcode->num_outputs);
2696 fprintf_vma (stdout, ptr->opcode->opcode);
2697 printf ("ull, 0x");
2698 fprintf_vma (stdout, ptr->opcode->mask);
2699 printf ("ull, { %d, %d, %d, %d, %d }, 0x%x, %d, },\n",
2700 ptr->opcode->operands[0],
2701 ptr->opcode->operands[1],
2702 ptr->opcode->operands[2],
2703 ptr->opcode->operands[3],
2704 ptr->opcode->operands[4],
2705 ptr->opcode->flags,
2706 ptr->completers->num);
2708 ptr->main_index = index++;
2710 ptr = ptr->next;
2712 printf ("};\n\n");
2715 static void
2716 shrink (table)
2717 struct ia64_opcode *table;
2719 int curr_opcode;
2721 for (curr_opcode = 0; table[curr_opcode].name != NULL; curr_opcode++)
2722 add_opcode_entry (table + curr_opcode);
2726 /* Program options. */
2727 #define OPTION_SRCDIR 200
2729 struct option long_options[] =
2731 {"srcdir", required_argument, NULL, OPTION_SRCDIR},
2732 {"debug", no_argument, NULL, 'd'},
2733 {"version", no_argument, NULL, 'V'},
2734 {"help", no_argument, NULL, 'h'},
2735 {0, no_argument, NULL, 0}
2738 static void
2739 print_version (void)
2741 printf ("%s: version 1.0\n", program_name);
2742 xexit (0);
2745 static void
2746 usage (FILE * stream, int status)
2748 fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
2749 program_name);
2750 xexit (status);
2754 main (int argc, char **argv)
2756 extern int chdir (char *);
2757 char *srcdir = NULL;
2758 int c;
2760 program_name = *argv;
2761 xmalloc_set_program_name (program_name);
2763 while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
2764 switch (c)
2766 case OPTION_SRCDIR:
2767 srcdir = optarg;
2768 break;
2769 case 'V':
2770 case 'v':
2771 print_version ();
2772 break;
2773 case 'd':
2774 debug = 1;
2775 break;
2776 case 'h':
2777 case '?':
2778 usage (stderr, 0);
2779 default:
2780 case 0:
2781 break;
2784 if (optind != argc)
2785 usage (stdout, 1);
2787 if (srcdir != NULL)
2788 if (chdir (srcdir) != 0)
2789 fail (_("unable to change directory to \"%s\", errno = %s\n"),
2790 srcdir, strerror (errno));
2792 load_insn_classes ();
2793 load_dependencies ();
2795 shrink (ia64_opcodes_a);
2796 shrink (ia64_opcodes_b);
2797 shrink (ia64_opcodes_f);
2798 shrink (ia64_opcodes_i);
2799 shrink (ia64_opcodes_m);
2800 shrink (ia64_opcodes_x);
2801 shrink (ia64_opcodes_d);
2803 collapse_redundant_completers ();
2805 printf ("/* This file is automatically generated by ia64-gen. Do not edit! */\n");
2806 print_string_table ();
2807 print_dependency_table ();
2808 print_completer_table ();
2809 print_main_table ();
2811 generate_disassembler ();
2813 exit (0);