1 /* ia64-gen.c -- Generate a shrunk set of opcode tables 2 Copyright 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012 3 Free Software Foundation, Inc. 4 Written by Bob Manson, Cygnus Solutions, <manson@cygnus.com> 5 6 This file is part of the GNU opcodes library. 7 8 This library is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 It is distributed in the hope that it will be useful, but WITHOUT 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 16 License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this file; see the file COPYING. If not, write to the 20 Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 21 02110-1301, USA. */ 22 23 24 /* While the ia64-opc-* set of opcode tables are easy to maintain, 25 they waste a tremendous amount of space. ia64-gen rearranges the 26 instructions into a directed acyclic graph (DAG) of instruction opcodes and 27 their possible completers, as well as compacting the set of strings used. 28 29 The disassembler table consists of a state machine that does 30 branching based on the bits of the opcode being disassembled. The 31 state encodings have been chosen to minimize the amount of space 32 required. 33 34 The resource table is constructed based on some text dependency tables, 35 which are also easier to maintain than the final representation. */ 36 37 #include "sysdep.h" 38 #include <stdio.h> 39 #include <stdarg.h> 40 #include <errno.h> 41 42 #include "libiberty.h" 43 #include "safe-ctype.h" 44 #include "getopt.h" 45 #include "ia64-opc.h" 46 #include "ia64-opc-a.c" 47 #include "ia64-opc-i.c" 48 #include "ia64-opc-m.c" 49 #include "ia64-opc-b.c" 50 #include "ia64-opc-f.c" 51 #include "ia64-opc-x.c" 52 #include "ia64-opc-d.c" 53 54 #include <libintl.h> 55 #define _(String) gettext (String) 56 57 /* This is a copy of fprintf_vma from bfd/bfd-in2.h. We have to use this 58 always, because we might be compiled without BFD64 defined, if configured 59 for a 32-bit target and --enable-targets=all is used. This will work for 60 both 32-bit and 64-bit hosts. */ 61 #define _opcode_int64_low(x) ((unsigned long) (((x) & 0xffffffff))) 62 #define _opcode_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff)) 63 #define opcode_fprintf_vma(s,x) \ 64 fprintf ((s), "%08lx%08lx", _opcode_int64_high (x), _opcode_int64_low (x)) 65 66 const char * program_name = NULL; 67 int debug = 0; 68 69 #define NELEMS(a) (sizeof (a) / sizeof ((a)[0])) 70 #define tmalloc(X) (X *) xmalloc (sizeof (X)) 71 72 typedef unsigned long long ci_t; 73 /* The main opcode table entry. Each entry is a unique combination of 74 name and flags (no two entries in the table compare as being equal 75 via opcodes_eq). */ 76 struct main_entry 77 { 78 /* The base name of this opcode. The names of its completers are 79 appended to it to generate the full instruction name. */ 80 struct string_entry *name; 81 /* The base opcode entry. Which one to use is a fairly arbitrary choice; 82 it uses the first one passed to add_opcode_entry. */ 83 struct ia64_opcode *opcode; 84 /* The list of completers that can be applied to this opcode. */ 85 struct completer_entry *completers; 86 /* Next entry in the chain. */ 87 struct main_entry *next; 88 /* Index in the main table. */ 89 int main_index; 90 } *maintable, **ordered_table; 91 92 int otlen = 0; 93 int ottotlen = 0; 94 int opcode_count = 0; 95 96 /* The set of possible completers for an opcode. */ 97 struct completer_entry 98 { 99 /* This entry's index in the ia64_completer_table[] array. */ 100 int num; 101 102 /* The name of the completer. */ 103 struct string_entry *name; 104 105 /* This entry's parent. */ 106 struct completer_entry *parent; 107 108 /* Set if this is a terminal completer (occurs at the end of an 109 opcode). */ 110 int is_terminal; 111 112 /* An alternative completer. */ 113 struct completer_entry *alternative; 114 115 /* Additional completers that can be appended to this one. */ 116 struct completer_entry *addl_entries; 117 118 /* Before compute_completer_bits () is invoked, this contains the actual 119 instruction opcode for this combination of opcode and completers. 120 Afterwards, it contains those bits that are different from its 121 parent opcode. */ 122 ia64_insn bits; 123 124 /* Bits set to 1 correspond to those bits in this completer's opcode 125 that are different from its parent completer's opcode (or from 126 the base opcode if the entry is the root of the opcode's completer 127 list). This field is filled in by compute_completer_bits (). */ 128 ia64_insn mask; 129 130 /* Index into the opcode dependency list, or -1 if none. */ 131 int dependencies; 132 133 /* Remember the order encountered in the opcode tables. */ 134 int order; 135 }; 136 137 /* One entry in the disassembler name table. */ 138 struct disent 139 { 140 /* The index into the ia64_name_dis array for this entry. */ 141 int ournum; 142 143 /* The index into the main_table[] array. */ 144 int insn; 145 146 /* The disassmbly priority of this entry. */ 147 int priority; 148 149 /* The completer_index value for this entry. */ 150 ci_t completer_index; 151 152 /* How many other entries share this decode. */ 153 int nextcnt; 154 155 /* The next entry sharing the same decode. */ 156 struct disent *nexte; 157 158 /* The next entry in the name list. */ 159 struct disent *next_ent; 160 } *disinsntable = NULL; 161 162 /* A state machine that will eventually be used to generate the 163 disassembler table. */ 164 struct bittree 165 { 166 struct disent *disent; 167 struct bittree *bits[3]; /* 0, 1, and X (don't care). */ 168 int bits_to_skip; 169 int skip_flag; 170 } *bittree; 171 172 /* The string table contains all opcodes and completers sorted in 173 alphabetical order. */ 174 175 /* One entry in the string table. */ 176 struct string_entry 177 { 178 /* The index in the ia64_strings[] array for this entry. */ 179 int num; 180 /* And the string. */ 181 char *s; 182 } **string_table = NULL; 183 184 int strtablen = 0; 185 int strtabtotlen = 0; 186 187 188 /* Resource dependency entries. */ 189 struct rdep 190 { 191 char *name; /* Resource name. */ 192 unsigned 193 mode:2, /* RAW, WAW, or WAR. */ 194 semantics:3; /* Dependency semantics. */ 195 char *extra; /* Additional semantics info. */ 196 int nchks; 197 int total_chks; /* Total #of terminal insns. */ 198 int *chks; /* Insn classes which read (RAW), write 199 (WAW), or write (WAR) this rsrc. */ 200 int *chknotes; /* Dependency notes for each class. */ 201 int nregs; 202 int total_regs; /* Total #of terminal insns. */ 203 int *regs; /* Insn class which write (RAW), write2 204 (WAW), or read (WAR) this rsrc. */ 205 int *regnotes; /* Dependency notes for each class. */ 206 207 int waw_special; /* Special WAW dependency note. */ 208 } **rdeps = NULL; 209 210 static int rdepslen = 0; 211 static int rdepstotlen = 0; 212 213 /* Array of all instruction classes. */ 214 struct iclass 215 { 216 char *name; /* Instruction class name. */ 217 int is_class; /* Is a class, not a terminal. */ 218 int nsubs; 219 int *subs; /* Other classes within this class. */ 220 int nxsubs; 221 int xsubs[4]; /* Exclusions. */ 222 char *comment; /* Optional comment. */ 223 int note; /* Optional note. */ 224 int terminal_resolved; /* Did we match this with anything? */ 225 int orphan; /* Detect class orphans. */ 226 } **ics = NULL; 227 228 static int iclen = 0; 229 static int ictotlen = 0; 230 231 /* An opcode dependency (chk/reg pair of dependency lists). */ 232 struct opdep 233 { 234 int chk; /* index into dlists */ 235 int reg; /* index into dlists */ 236 } **opdeps; 237 238 static int opdeplen = 0; 239 static int opdeptotlen = 0; 240 241 /* A generic list of dependencies w/notes encoded. These may be shared. */ 242 struct deplist 243 { 244 int len; 245 unsigned short *deps; 246 } **dlists; 247 248 static int dlistlen = 0; 249 static int dlisttotlen = 0; 250 251 252 static void fail (const char *, ...) ATTRIBUTE_PRINTF_1; 253 static void warn (const char *, ...) ATTRIBUTE_PRINTF_1; 254 static struct rdep * insert_resource (const char *, enum ia64_dependency_mode); 255 static int deplist_equals (struct deplist *, struct deplist *); 256 static short insert_deplist (int, unsigned short *); 257 static short insert_dependencies (int, unsigned short *, int, unsigned short *); 258 static void mark_used (struct iclass *, int); 259 static int fetch_insn_class (const char *, int); 260 static int sub_compare (const void *, const void *); 261 static void load_insn_classes (void); 262 static void parse_resource_users (const char *, int **, int *, int **); 263 static int parse_semantics (char *); 264 static void add_dep (const char *, const char *, const char *, int, int, char *, int); 265 static void load_depfile (const char *, enum ia64_dependency_mode); 266 static void load_dependencies (void); 267 static int irf_operand (int, const char *); 268 static int in_iclass_mov_x (struct ia64_opcode *, struct iclass *, const char *, const char *); 269 static int in_iclass (struct ia64_opcode *, struct iclass *, const char *, const char *, int *); 270 static int lookup_regindex (const char *, int); 271 static int lookup_specifier (const char *); 272 static void print_dependency_table (void); 273 static struct string_entry * insert_string (char *); 274 static void gen_dis_table (struct bittree *); 275 static void print_dis_table (void); 276 static void generate_disassembler (void); 277 static void print_string_table (void); 278 static int completer_entries_eq (struct completer_entry *, struct completer_entry *); 279 static struct completer_entry * insert_gclist (struct completer_entry *); 280 static int get_prefix_len (const char *); 281 static void compute_completer_bits (struct main_entry *, struct completer_entry *); 282 static void collapse_redundant_completers (void); 283 static int insert_opcode_dependencies (struct ia64_opcode *, struct completer_entry *); 284 static void insert_completer_entry (struct ia64_opcode *, struct main_entry *, int); 285 static void print_completer_entry (struct completer_entry *); 286 static void print_completer_table (void); 287 static int opcodes_eq (struct ia64_opcode *, struct ia64_opcode *); 288 static void add_opcode_entry (struct ia64_opcode *); 289 static void print_main_table (void); 290 static void shrink (struct ia64_opcode *); 291 static void print_version (void); 292 static void usage (FILE *, int); 293 static void finish_distable (void); 294 static void insert_bit_table_ent (struct bittree *, int, ia64_insn, ia64_insn, int, int, ci_t); 295 static void add_dis_entry (struct bittree *, ia64_insn, ia64_insn, int, struct completer_entry *, ci_t); 296 static void compact_distree (struct bittree *); 297 static struct bittree * make_bittree_entry (void); 298 static struct disent * add_dis_table_ent (struct disent *, int, int, ci_t); 299 300 301 static void 302 fail (const char *message, ...) 303 { 304 va_list args; 305 306 va_start (args, message); 307 fprintf (stderr, _("%s: Error: "), program_name); 308 vfprintf (stderr, message, args); 309 va_end (args); 310 xexit (1); 311 } 312 313 static void 314 warn (const char *message, ...) 315 { 316 va_list args; 317 318 va_start (args, message); 319 320 fprintf (stderr, _("%s: Warning: "), program_name); 321 vfprintf (stderr, message, args); 322 va_end (args); 323 } 324 325 /* Add NAME to the resource table, where TYPE is RAW or WAW. */ 326 static struct rdep * 327 insert_resource (const char *name, enum ia64_dependency_mode type) 328 { 329 if (rdepslen == rdepstotlen) 330 { 331 rdepstotlen += 20; 332 rdeps = (struct rdep **) 333 xrealloc (rdeps, sizeof(struct rdep **) * rdepstotlen); 334 } 335 rdeps[rdepslen] = tmalloc(struct rdep); 336 memset((void *)rdeps[rdepslen], 0, sizeof(struct rdep)); 337 rdeps[rdepslen]->name = xstrdup (name); 338 rdeps[rdepslen]->mode = type; 339 rdeps[rdepslen]->waw_special = 0; 340 341 return rdeps[rdepslen++]; 342 } 343 344 /* Are the lists of dependency indexes equivalent? */ 345 static int 346 deplist_equals (struct deplist *d1, struct deplist *d2) 347 { 348 int i; 349 350 if (d1->len != d2->len) 351 return 0; 352 353 for (i = 0; i < d1->len; i++) 354 if (d1->deps[i] != d2->deps[i]) 355 return 0; 356 357 return 1; 358 } 359 360 /* Add the list of dependencies to the list of dependency lists. */ 361 static short 362 insert_deplist (int count, unsigned short *deps) 363 { 364 /* Sort the list, then see if an equivalent list exists already. 365 this results in a much smaller set of dependency lists. */ 366 struct deplist *list; 367 char set[0x10000]; 368 int i; 369 370 memset ((void *)set, 0, sizeof (set)); 371 for (i = 0; i < count; i++) 372 set[deps[i]] = 1; 373 374 count = 0; 375 for (i = 0; i < (int) sizeof (set); i++) 376 if (set[i]) 377 ++count; 378 379 list = tmalloc (struct deplist); 380 list->len = count; 381 list->deps = (unsigned short *) malloc (sizeof (unsigned short) * count); 382 383 for (i = 0, count = 0; i < (int) sizeof (set); i++) 384 if (set[i]) 385 list->deps[count++] = i; 386 387 /* Does this list exist already? */ 388 for (i = 0; i < dlistlen; i++) 389 if (deplist_equals (list, dlists[i])) 390 { 391 free (list->deps); 392 free (list); 393 return i; 394 } 395 396 if (dlistlen == dlisttotlen) 397 { 398 dlisttotlen += 20; 399 dlists = (struct deplist **) 400 xrealloc (dlists, sizeof(struct deplist **) * dlisttotlen); 401 } 402 dlists[dlistlen] = list; 403 404 return dlistlen++; 405 } 406 407 /* Add the given pair of dependency lists to the opcode dependency list. */ 408 static short 409 insert_dependencies (int nchks, unsigned short *chks, 410 int nregs, unsigned short *regs) 411 { 412 struct opdep *pair; 413 int i; 414 int regind = -1; 415 int chkind = -1; 416 417 if (nregs > 0) 418 regind = insert_deplist (nregs, regs); 419 if (nchks > 0) 420 chkind = insert_deplist (nchks, chks); 421 422 for (i = 0; i < opdeplen; i++) 423 if (opdeps[i]->chk == chkind 424 && opdeps[i]->reg == regind) 425 return i; 426 427 pair = tmalloc (struct opdep); 428 pair->chk = chkind; 429 pair->reg = regind; 430 431 if (opdeplen == opdeptotlen) 432 { 433 opdeptotlen += 20; 434 opdeps = (struct opdep **) 435 xrealloc (opdeps, sizeof(struct opdep **) * opdeptotlen); 436 } 437 opdeps[opdeplen] = pair; 438 439 return opdeplen++; 440 } 441 442 static void 443 mark_used (struct iclass *ic, int clear_terminals) 444 { 445 int i; 446 447 ic->orphan = 0; 448 if (clear_terminals) 449 ic->terminal_resolved = 1; 450 451 for (i = 0; i < ic->nsubs; i++) 452 mark_used (ics[ic->subs[i]], clear_terminals); 453 454 for (i = 0; i < ic->nxsubs; i++) 455 mark_used (ics[ic->xsubs[i]], clear_terminals); 456 } 457 458 /* Look up an instruction class; if CREATE make a new one if none found; 459 returns the index into the insn class array. */ 460 static int 461 fetch_insn_class (const char *full_name, int create) 462 { 463 char *name; 464 char *notestr; 465 char *xsect; 466 char *comment; 467 int i, note = 0; 468 int ind; 469 int is_class = 0; 470 471 if (CONST_STRNEQ (full_name, "IC:")) 472 { 473 name = xstrdup (full_name + 3); 474 is_class = 1; 475 } 476 else 477 name = xstrdup (full_name); 478 479 if ((xsect = strchr(name, '\\')) != NULL) 480 is_class = 1; 481 if ((comment = strchr(name, '[')) != NULL) 482 is_class = 1; 483 if ((notestr = strchr(name, '+')) != NULL) 484 is_class = 1; 485 486 /* If it is a composite class, then ignore comments and notes that come after 487 the '\\', since they don't apply to the part we are decoding now. */ 488 if (xsect) 489 { 490 if (comment > xsect) 491 comment = 0; 492 if (notestr > xsect) 493 notestr = 0; 494 } 495 496 if (notestr) 497 { 498 char *nextnotestr; 499 500 note = atoi (notestr + 1); 501 if ((nextnotestr = strchr (notestr + 1, '+')) != NULL) 502 { 503 if (strcmp (notestr, "+1+13") == 0) 504 note = 13; 505 else if (!xsect || nextnotestr < xsect) 506 warn (_("multiple note %s not handled\n"), notestr); 507 } 508 } 509 510 /* If it's a composite class, leave the notes and comments in place so that 511 we have a unique name for the composite class. Otherwise, we remove 512 them. */ 513 if (!xsect) 514 { 515 if (notestr) 516 *notestr = 0; 517 if (comment) 518 *comment = 0; 519 } 520 521 for (i = 0; i < iclen; i++) 522 if (strcmp (name, ics[i]->name) == 0 523 && ((comment == NULL && ics[i]->comment == NULL) 524 || (comment != NULL && ics[i]->comment != NULL 525 && strncmp (ics[i]->comment, comment, 526 strlen (ics[i]->comment)) == 0)) 527 && note == ics[i]->note) 528 return i; 529 530 if (!create) 531 return -1; 532 533 /* Doesn't exist, so make a new one. */ 534 if (iclen == ictotlen) 535 { 536 ictotlen += 20; 537 ics = (struct iclass **) 538 xrealloc (ics, (ictotlen) * sizeof (struct iclass *)); 539 } 540 541 ind = iclen++; 542 ics[ind] = tmalloc (struct iclass); 543 memset ((void *)ics[ind], 0, sizeof (struct iclass)); 544 ics[ind]->name = xstrdup (name); 545 ics[ind]->is_class = is_class; 546 ics[ind]->orphan = 1; 547 548 if (comment) 549 { 550 ics[ind]->comment = xstrdup (comment + 1); 551 ics[ind]->comment[strlen (ics[ind]->comment)-1] = 0; 552 } 553 554 if (notestr) 555 ics[ind]->note = note; 556 557 /* If it's a composite class, there's a comment or note, look for an 558 existing class or terminal with the same name. */ 559 if ((xsect || comment || notestr) && is_class) 560 { 561 /* First, populate with the class we're based on. */ 562 char *subname = name; 563 564 if (xsect) 565 *xsect = 0; 566 else if (comment) 567 *comment = 0; 568 else if (notestr) 569 *notestr = 0; 570 571 ics[ind]->nsubs = 1; 572 ics[ind]->subs = tmalloc(int); 573 ics[ind]->subs[0] = fetch_insn_class (subname, 1);; 574 } 575 576 while (xsect) 577 { 578 char *subname = xsect + 1; 579 580 xsect = strchr (subname, '\\'); 581 if (xsect) 582 *xsect = 0; 583 ics[ind]->xsubs[ics[ind]->nxsubs] = fetch_insn_class (subname,1); 584 ics[ind]->nxsubs++; 585 } 586 free (name); 587 588 return ind; 589 } 590 591 /* For sorting a class's sub-class list only; make sure classes appear before 592 terminals. */ 593 static int 594 sub_compare (const void *e1, const void *e2) 595 { 596 struct iclass *ic1 = ics[*(int *)e1]; 597 struct iclass *ic2 = ics[*(int *)e2]; 598 599 if (ic1->is_class) 600 { 601 if (!ic2->is_class) 602 return -1; 603 } 604 else if (ic2->is_class) 605 return 1; 606 607 return strcmp (ic1->name, ic2->name); 608 } 609 610 static void 611 load_insn_classes (void) 612 { 613 FILE *fp = fopen ("ia64-ic.tbl", "r"); 614 char buf[2048]; 615 616 if (fp == NULL) 617 fail (_("can't find ia64-ic.tbl for reading\n")); 618 619 /* Discard first line. */ 620 fgets (buf, sizeof(buf), fp); 621 622 while (!feof (fp)) 623 { 624 int iclass; 625 char *name; 626 char *tmp; 627 628 if (fgets (buf, sizeof (buf), fp) == NULL) 629 break; 630 631 while (ISSPACE (buf[strlen (buf) - 1])) 632 buf[strlen (buf) - 1] = '\0'; 633 634 name = tmp = buf; 635 while (*tmp != ';') 636 { 637 ++tmp; 638 if (tmp == buf + sizeof (buf)) 639 abort (); 640 } 641 *tmp++ = '\0'; 642 643 iclass = fetch_insn_class (name, 1); 644 ics[iclass]->is_class = 1; 645 646 if (strcmp (name, "none") == 0) 647 { 648 ics[iclass]->is_class = 0; 649 ics[iclass]->terminal_resolved = 1; 650 continue; 651 } 652 653 /* For this class, record all sub-classes. */ 654 while (*tmp) 655 { 656 char *subname; 657 int sub; 658 659 while (*tmp && ISSPACE (*tmp)) 660 { 661 ++tmp; 662 if (tmp == buf + sizeof (buf)) 663 abort (); 664 } 665 subname = tmp; 666 while (*tmp && *tmp != ',') 667 { 668 ++tmp; 669 if (tmp == buf + sizeof (buf)) 670 abort (); 671 } 672 if (*tmp == ',') 673 *tmp++ = '\0'; 674 675 ics[iclass]->subs = (int *) 676 xrealloc ((void *)ics[iclass]->subs, 677 (ics[iclass]->nsubs + 1) * sizeof (int)); 678 679 sub = fetch_insn_class (subname, 1); 680 ics[iclass]->subs = (int *) 681 xrealloc (ics[iclass]->subs, (ics[iclass]->nsubs + 1) * sizeof (int)); 682 ics[iclass]->subs[ics[iclass]->nsubs++] = sub; 683 } 684 685 /* Make sure classes come before terminals. */ 686 qsort ((void *)ics[iclass]->subs, 687 ics[iclass]->nsubs, sizeof(int), sub_compare); 688 } 689 fclose (fp); 690 691 if (debug) 692 printf ("%d classes\n", iclen); 693 } 694 695 /* Extract the insn classes from the given line. */ 696 static void 697 parse_resource_users (const char *ref, int **usersp, int *nusersp, 698 int **notesp) 699 { 700 int c; 701 char *line = xstrdup (ref); 702 char *tmp = line; 703 int *users = *usersp; 704 int count = *nusersp; 705 int *notes = *notesp; 706 707 c = *tmp; 708 while (c != 0) 709 { 710 char *notestr; 711 int note; 712 char *xsect; 713 int iclass; 714 int create = 0; 715 char *name; 716 717 while (ISSPACE (*tmp)) 718 ++tmp; 719 name = tmp; 720 while (*tmp && *tmp != ',') 721 ++tmp; 722 c = *tmp; 723 *tmp++ = '\0'; 724 725 xsect = strchr (name, '\\'); 726 if ((notestr = strstr (name, "+")) != NULL) 727 { 728 char *nextnotestr; 729 730 note = atoi (notestr + 1); 731 if ((nextnotestr = strchr (notestr + 1, '+')) != NULL) 732 { 733 /* Note 13 always implies note 1. */ 734 if (strcmp (notestr, "+1+13") == 0) 735 note = 13; 736 else if (!xsect || nextnotestr < xsect) 737 warn (_("multiple note %s not handled\n"), notestr); 738 } 739 if (!xsect) 740 *notestr = '\0'; 741 } 742 else 743 note = 0; 744 745 /* All classes are created when the insn class table is parsed; 746 Individual instructions might not appear until the dependency tables 747 are read. Only create new classes if it's *not* an insn class, 748 or if it's a composite class (which wouldn't necessarily be in the IC 749 table). */ 750 if (! CONST_STRNEQ (name, "IC:") || xsect != NULL) 751 create = 1; 752 753 iclass = fetch_insn_class (name, create); 754 if (iclass != -1) 755 { 756 users = (int *) 757 xrealloc ((void *) users,(count + 1) * sizeof (int)); 758 notes = (int *) 759 xrealloc ((void *) notes,(count + 1) * sizeof (int)); 760 notes[count] = note; 761 users[count++] = iclass; 762 mark_used (ics[iclass], 0); 763 } 764 else if (debug) 765 printf("Class %s not found\n", name); 766 } 767 /* Update the return values. */ 768 *usersp = users; 769 *nusersp = count; 770 *notesp = notes; 771 772 free (line); 773 } 774 775 static int 776 parse_semantics (char *sem) 777 { 778 if (strcmp (sem, "none") == 0) 779 return IA64_DVS_NONE; 780 else if (strcmp (sem, "implied") == 0) 781 return IA64_DVS_IMPLIED; 782 else if (strcmp (sem, "impliedF") == 0) 783 return IA64_DVS_IMPLIEDF; 784 else if (strcmp (sem, "data") == 0) 785 return IA64_DVS_DATA; 786 else if (strcmp (sem, "instr") == 0) 787 return IA64_DVS_INSTR; 788 else if (strcmp (sem, "specific") == 0) 789 return IA64_DVS_SPECIFIC; 790 else if (strcmp (sem, "stop") == 0) 791 return IA64_DVS_STOP; 792 else 793 return IA64_DVS_OTHER; 794 } 795 796 static void 797 add_dep (const char *name, const char *chk, const char *reg, 798 int semantics, int mode, char *extra, int flag) 799 { 800 struct rdep *rs; 801 802 rs = insert_resource (name, mode); 803 804 parse_resource_users (chk, &rs->chks, &rs->nchks, &rs->chknotes); 805 parse_resource_users (reg, &rs->regs, &rs->nregs, &rs->regnotes); 806 807 rs->semantics = semantics; 808 rs->extra = extra; 809 rs->waw_special = flag; 810 } 811 812 static void 813 load_depfile (const char *filename, enum ia64_dependency_mode mode) 814 { 815 FILE *fp = fopen (filename, "r"); 816 char buf[1024]; 817 818 if (fp == NULL) 819 fail (_("can't find %s for reading\n"), filename); 820 821 fgets (buf, sizeof(buf), fp); 822 while (!feof (fp)) 823 { 824 char *name, *tmp; 825 int semantics; 826 char *extra; 827 char *regp, *chkp; 828 829 if (fgets (buf, sizeof(buf), fp) == NULL) 830 break; 831 832 while (ISSPACE (buf[strlen (buf) - 1])) 833 buf[strlen (buf) - 1] = '\0'; 834 835 name = tmp = buf; 836 while (*tmp != ';') 837 ++tmp; 838 *tmp++ = '\0'; 839 840 while (ISSPACE (*tmp)) 841 ++tmp; 842 regp = tmp; 843 tmp = strchr (tmp, ';'); 844 if (!tmp) 845 abort (); 846 *tmp++ = 0; 847 while (ISSPACE (*tmp)) 848 ++tmp; 849 chkp = tmp; 850 tmp = strchr (tmp, ';'); 851 if (!tmp) 852 abort (); 853 *tmp++ = 0; 854 while (ISSPACE (*tmp)) 855 ++tmp; 856 semantics = parse_semantics (tmp); 857 extra = semantics == IA64_DVS_OTHER ? xstrdup (tmp) : NULL; 858 859 /* For WAW entries, if the chks and regs differ, we need to enter the 860 entries in both positions so that the tables will be parsed properly, 861 without a lot of extra work. */ 862 if (mode == IA64_DV_WAW && strcmp (regp, chkp) != 0) 863 { 864 add_dep (name, chkp, regp, semantics, mode, extra, 0); 865 add_dep (name, regp, chkp, semantics, mode, extra, 1); 866 } 867 else 868 { 869 add_dep (name, chkp, regp, semantics, mode, extra, 0); 870 } 871 } 872 fclose (fp); 873 } 874 875 static void 876 load_dependencies (void) 877 { 878 load_depfile ("ia64-raw.tbl", IA64_DV_RAW); 879 load_depfile ("ia64-waw.tbl", IA64_DV_WAW); 880 load_depfile ("ia64-war.tbl", IA64_DV_WAR); 881 882 if (debug) 883 printf ("%d RAW/WAW/WAR dependencies\n", rdepslen); 884 } 885 886 /* Is the given operand an indirect register file operand? */ 887 static int 888 irf_operand (int op, const char *field) 889 { 890 if (!field) 891 { 892 return op == IA64_OPND_RR_R3 || op == IA64_OPND_DBR_R3 893 || op == IA64_OPND_IBR_R3 || op == IA64_OPND_PKR_R3 894 || op == IA64_OPND_PMC_R3 || op == IA64_OPND_PMD_R3 895 || op == IA64_OPND_MSR_R3 || op == IA64_OPND_CPUID_R3; 896 } 897 else 898 { 899 return ((op == IA64_OPND_RR_R3 && strstr (field, "rr")) 900 || (op == IA64_OPND_DBR_R3 && strstr (field, "dbr")) 901 || (op == IA64_OPND_IBR_R3 && strstr (field, "ibr")) 902 || (op == IA64_OPND_PKR_R3 && strstr (field, "pkr")) 903 || (op == IA64_OPND_PMC_R3 && strstr (field, "pmc")) 904 || (op == IA64_OPND_PMD_R3 && strstr (field, "pmd")) 905 || (op == IA64_OPND_MSR_R3 && strstr (field, "msr")) 906 || (op == IA64_OPND_CPUID_R3 && strstr (field, "cpuid")) 907 || (op == IA64_OPND_DAHR_R3 && strstr (field, "dahr"))); 908 } 909 } 910 911 /* Handle mov_ar, mov_br, mov_cr, move_dahr, mov_indirect, mov_ip, mov_pr, 912 * mov_psr, and mov_um insn classes. */ 913 static int 914 in_iclass_mov_x (struct ia64_opcode *idesc, struct iclass *ic, 915 const char *format, const char *field) 916 { 917 int plain_mov = strcmp (idesc->name, "mov") == 0; 918 919 if (!format) 920 return 0; 921 922 switch (ic->name[4]) 923 { 924 default: 925 abort (); 926 case 'a': 927 { 928 int i = strcmp (idesc->name, "mov.i") == 0; 929 int m = strcmp (idesc->name, "mov.m") == 0; 930 int i2627 = i && idesc->operands[0] == IA64_OPND_AR3; 931 int i28 = i && idesc->operands[1] == IA64_OPND_AR3; 932 int m2930 = m && idesc->operands[0] == IA64_OPND_AR3; 933 int m31 = m && idesc->operands[1] == IA64_OPND_AR3; 934 int pseudo0 = plain_mov && idesc->operands[1] == IA64_OPND_AR3; 935 int pseudo1 = plain_mov && idesc->operands[0] == IA64_OPND_AR3; 936 937 /* IC:mov ar */ 938 if (i2627) 939 return strstr (format, "I26") || strstr (format, "I27"); 940 if (i28) 941 return strstr (format, "I28") != NULL; 942 if (m2930) 943 return strstr (format, "M29") || strstr (format, "M30"); 944 if (m31) 945 return strstr (format, "M31") != NULL; 946 if (pseudo0 || pseudo1) 947 return 1; 948 } 949 break; 950 case 'b': 951 { 952 int i21 = idesc->operands[0] == IA64_OPND_B1; 953 int i22 = plain_mov && idesc->operands[1] == IA64_OPND_B2; 954 if (i22) 955 return strstr (format, "I22") != NULL; 956 if (i21) 957 return strstr (format, "I21") != NULL; 958 } 959 break; 960 case 'c': 961 { 962 int m32 = plain_mov && idesc->operands[0] == IA64_OPND_CR3; 963 int m33 = plain_mov && idesc->operands[1] == IA64_OPND_CR3; 964 if (m32) 965 return strstr (format, "M32") != NULL; 966 if (m33) 967 return strstr (format, "M33") != NULL; 968 } 969 break; 970 case 'd': 971 { 972 int m50 = plain_mov && idesc->operands[0] == IA64_OPND_DAHR3; 973 if (m50) 974 return strstr (format, "M50") != NULL; 975 } 976 break; 977 case 'i': 978 if (ic->name[5] == 'n') 979 { 980 int m42 = plain_mov && irf_operand (idesc->operands[0], field); 981 int m43 = plain_mov && irf_operand (idesc->operands[1], field); 982 if (m42) 983 return strstr (format, "M42") != NULL; 984 if (m43) 985 return strstr (format, "M43") != NULL; 986 } 987 else if (ic->name[5] == 'p') 988 { 989 return idesc->operands[1] == IA64_OPND_IP; 990 } 991 else 992 abort (); 993 break; 994 case 'p': 995 if (ic->name[5] == 'r') 996 { 997 int i25 = plain_mov && idesc->operands[1] == IA64_OPND_PR; 998 int i23 = plain_mov && idesc->operands[0] == IA64_OPND_PR; 999 int i24 = plain_mov && idesc->operands[0] == IA64_OPND_PR_ROT; 1000 if (i23) 1001 return strstr (format, "I23") != NULL; 1002 if (i24) 1003 return strstr (format, "I24") != NULL; 1004 if (i25) 1005 return strstr (format, "I25") != NULL; 1006 } 1007 else if (ic->name[5] == 's') 1008 { 1009 int m35 = plain_mov && idesc->operands[0] == IA64_OPND_PSR_L; 1010 int m36 = plain_mov && idesc->operands[1] == IA64_OPND_PSR; 1011 if (m35) 1012 return strstr (format, "M35") != NULL; 1013 if (m36) 1014 return strstr (format, "M36") != NULL; 1015 } 1016 else 1017 abort (); 1018 break; 1019 case 'u': 1020 { 1021 int m35 = plain_mov && idesc->operands[0] == IA64_OPND_PSR_UM; 1022 int m36 = plain_mov && idesc->operands[1] == IA64_OPND_PSR_UM; 1023 if (m35) 1024 return strstr (format, "M35") != NULL; 1025 if (m36) 1026 return strstr (format, "M36") != NULL; 1027 } 1028 break; 1029 } 1030 return 0; 1031 } 1032 1033 /* Is the given opcode in the given insn class? */ 1034 static int 1035 in_iclass (struct ia64_opcode *idesc, struct iclass *ic, 1036 const char *format, const char *field, int *notep) 1037 { 1038 int i; 1039 int resolved = 0; 1040 1041 if (ic->comment) 1042 { 1043 if (CONST_STRNEQ (ic->comment, "Format")) 1044 { 1045 /* Assume that the first format seen is the most restrictive, and 1046 only keep a later one if it looks like it's more restrictive. */ 1047 if (format) 1048 { 1049 if (strlen (ic->comment) < strlen (format)) 1050 { 1051 warn (_("most recent format '%s'\nappears more restrictive than '%s'\n"), 1052 ic->comment, format); 1053 format = ic->comment; 1054 } 1055 } 1056 else 1057 format = ic->comment; 1058 } 1059 else if (CONST_STRNEQ (ic->comment, "Field")) 1060 { 1061 if (field) 1062 warn (_("overlapping field %s->%s\n"), 1063 ic->comment, field); 1064 field = ic->comment; 1065 } 1066 } 1067 1068 /* An insn class matches anything that is the same followed by completers, 1069 except when the absence and presence of completers constitutes different 1070 instructions. */ 1071 if (ic->nsubs == 0 && ic->nxsubs == 0) 1072 { 1073 int is_mov = CONST_STRNEQ (idesc->name, "mov"); 1074 int plain_mov = strcmp (idesc->name, "mov") == 0; 1075 int len = strlen(ic->name); 1076 1077 resolved = ((strncmp (ic->name, idesc->name, len) == 0) 1078 && (idesc->name[len] == '\0' 1079 || idesc->name[len] == '.')); 1080 1081 /* All break, nop, and hint variations must match exactly. */ 1082 if (resolved && 1083 (strcmp (ic->name, "break") == 0 1084 || strcmp (ic->name, "nop") == 0 1085 || strcmp (ic->name, "hint") == 0)) 1086 resolved = strcmp (ic->name, idesc->name) == 0; 1087 1088 /* Assume restrictions in the FORMAT/FIELD negate resolution, 1089 unless specifically allowed by clauses in this block. */ 1090 if (resolved && field) 1091 { 1092 /* Check Field(sf)==sN against opcode sN. */ 1093 if (strstr(field, "(sf)==") != NULL) 1094 { 1095 char *sf; 1096 1097 if ((sf = strstr (idesc->name, ".s")) != 0) 1098 resolved = strcmp (sf + 1, strstr (field, "==") + 2) == 0; 1099 } 1100 /* Check Field(lftype)==XXX. */ 1101 else if (strstr (field, "(lftype)") != NULL) 1102 { 1103 if (strstr (idesc->name, "fault") != NULL) 1104 resolved = strstr (field, "fault") != NULL; 1105 else 1106 resolved = strstr (field, "fault") == NULL; 1107 } 1108 /* Handle Field(ctype)==XXX. */ 1109 else if (strstr (field, "(ctype)") != NULL) 1110 { 1111 if (strstr (idesc->name, "or.andcm")) 1112 resolved = strstr (field, "or.andcm") != NULL; 1113 else if (strstr (idesc->name, "and.orcm")) 1114 resolved = strstr (field, "and.orcm") != NULL; 1115 else if (strstr (idesc->name, "orcm")) 1116 resolved = strstr (field, "or orcm") != NULL; 1117 else if (strstr (idesc->name, "or")) 1118 resolved = strstr (field, "or orcm") != NULL; 1119 else if (strstr (idesc->name, "andcm")) 1120 resolved = strstr (field, "and andcm") != NULL; 1121 else if (strstr (idesc->name, "and")) 1122 resolved = strstr (field, "and andcm") != NULL; 1123 else if (strstr (idesc->name, "unc")) 1124 resolved = strstr (field, "unc") != NULL; 1125 else 1126 resolved = strcmp (field, "Field(ctype)==") == 0; 1127 } 1128 } 1129 1130 if (resolved && format) 1131 { 1132 if (CONST_STRNEQ (idesc->name, "dep") 1133 && strstr (format, "I13") != NULL) 1134 resolved = idesc->operands[1] == IA64_OPND_IMM8; 1135 else if (CONST_STRNEQ (idesc->name, "chk") 1136 && strstr (format, "M21") != NULL) 1137 resolved = idesc->operands[0] == IA64_OPND_F2; 1138 else if (CONST_STRNEQ (idesc->name, "lfetch")) 1139 resolved = (strstr (format, "M14 M15") != NULL 1140 && (idesc->operands[1] == IA64_OPND_R2 1141 || idesc->operands[1] == IA64_OPND_IMM9b)); 1142 else if (CONST_STRNEQ (idesc->name, "br.call") 1143 && strstr (format, "B5") != NULL) 1144 resolved = idesc->operands[1] == IA64_OPND_B2; 1145 else if (CONST_STRNEQ (idesc->name, "br.call") 1146 && strstr (format, "B3") != NULL) 1147 resolved = idesc->operands[1] == IA64_OPND_TGT25c; 1148 else if (CONST_STRNEQ (idesc->name, "brp") 1149 && strstr (format, "B7") != NULL) 1150 resolved = idesc->operands[0] == IA64_OPND_B2; 1151 else if (strcmp (ic->name, "invala") == 0) 1152 resolved = strcmp (idesc->name, ic->name) == 0; 1153 else if (CONST_STRNEQ (idesc->name, "st") 1154 && (strstr (format, "M5") != NULL 1155 || strstr (format, "M10") != NULL)) 1156 resolved = idesc->flags & IA64_OPCODE_POSTINC; 1157 else if (CONST_STRNEQ (idesc->name, "ld") 1158 && (strstr (format, "M2 M3") != NULL 1159 || strstr (format, "M12") != NULL 1160 || strstr (format, "M7 M8") != NULL)) 1161 resolved = idesc->flags & IA64_OPCODE_POSTINC; 1162 else 1163 resolved = 0; 1164 } 1165 1166 /* Misc brl variations ('.cond' is optional); 1167 plain brl matches brl.cond. */ 1168 if (!resolved 1169 && (strcmp (idesc->name, "brl") == 0 1170 || CONST_STRNEQ (idesc->name, "brl.")) 1171 && strcmp (ic->name, "brl.cond") == 0) 1172 { 1173 resolved = 1; 1174 } 1175 1176 /* Misc br variations ('.cond' is optional). */ 1177 if (!resolved 1178 && (strcmp (idesc->name, "br") == 0 1179 || CONST_STRNEQ (idesc->name, "br.")) 1180 && strcmp (ic->name, "br.cond") == 0) 1181 { 1182 if (format) 1183 resolved = (strstr (format, "B4") != NULL 1184 && idesc->operands[0] == IA64_OPND_B2) 1185 || (strstr (format, "B1") != NULL 1186 && idesc->operands[0] == IA64_OPND_TGT25c); 1187 else 1188 resolved = 1; 1189 } 1190 1191 /* probe variations. */ 1192 if (!resolved && CONST_STRNEQ (idesc->name, "probe")) 1193 { 1194 resolved = strcmp (ic->name, "probe") == 0 1195 && !((strstr (idesc->name, "fault") != NULL) 1196 ^ (format && strstr (format, "M40") != NULL)); 1197 } 1198 1199 /* mov variations. */ 1200 if (!resolved && is_mov) 1201 { 1202 if (plain_mov) 1203 { 1204 /* mov alias for fmerge. */ 1205 if (strcmp (ic->name, "fmerge") == 0) 1206 { 1207 resolved = idesc->operands[0] == IA64_OPND_F1 1208 && idesc->operands[1] == IA64_OPND_F3; 1209 } 1210 /* mov alias for adds (r3 or imm14). */ 1211 else if (strcmp (ic->name, "adds") == 0) 1212 { 1213 resolved = (idesc->operands[0] == IA64_OPND_R1 1214 && (idesc->operands[1] == IA64_OPND_R3 1215 || (idesc->operands[1] == IA64_OPND_IMM14))); 1216 } 1217 /* mov alias for addl. */ 1218 else if (strcmp (ic->name, "addl") == 0) 1219 { 1220 resolved = idesc->operands[0] == IA64_OPND_R1 1221 && idesc->operands[1] == IA64_OPND_IMM22; 1222 } 1223 } 1224 1225 /* Some variants of mov and mov.[im]. */ 1226 if (!resolved && CONST_STRNEQ (ic->name, "mov_")) 1227 resolved = in_iclass_mov_x (idesc, ic, format, field); 1228 } 1229 1230 /* Keep track of this so we can flag any insn classes which aren't 1231 mapped onto at least one real insn. */ 1232 if (resolved) 1233 ic->terminal_resolved = 1; 1234 } 1235 else for (i = 0; i < ic->nsubs; i++) 1236 { 1237 if (in_iclass (idesc, ics[ic->subs[i]], format, field, notep)) 1238 { 1239 int j; 1240 1241 for (j = 0; j < ic->nxsubs; j++) 1242 if (in_iclass (idesc, ics[ic->xsubs[j]], NULL, NULL, NULL)) 1243 return 0; 1244 1245 if (debug > 1) 1246 printf ("%s is in IC %s\n", idesc->name, ic->name); 1247 1248 resolved = 1; 1249 break; 1250 } 1251 } 1252 1253 /* If it's in this IC, add the IC note (if any) to the insn. */ 1254 if (resolved) 1255 { 1256 if (ic->note && notep) 1257 { 1258 if (*notep && *notep != ic->note) 1259 warn (_("overwriting note %d with note %d (IC:%s)\n"), 1260 *notep, ic->note, ic->name); 1261 1262 *notep = ic->note; 1263 } 1264 } 1265 1266 return resolved; 1267 } 1268 1269 1270 static int 1271 lookup_regindex (const char *name, int specifier) 1272 { 1273 switch (specifier) 1274 { 1275 case IA64_RS_ARX: 1276 if (strstr (name, "[RSC]")) 1277 return 16; 1278 if (strstr (name, "[BSP]")) 1279 return 17; 1280 else if (strstr (name, "[BSPSTORE]")) 1281 return 18; 1282 else if (strstr (name, "[RNAT]")) 1283 return 19; 1284 else if (strstr (name, "[FCR]")) 1285 return 21; 1286 else if (strstr (name, "[EFLAG]")) 1287 return 24; 1288 else if (strstr (name, "[CSD]")) 1289 return 25; 1290 else if (strstr (name, "[SSD]")) 1291 return 26; 1292 else if (strstr (name, "[CFLG]")) 1293 return 27; 1294 else if (strstr (name, "[FSR]")) 1295 return 28; 1296 else if (strstr (name, "[FIR]")) 1297 return 29; 1298 else if (strstr (name, "[FDR]")) 1299 return 30; 1300 else if (strstr (name, "[CCV]")) 1301 return 32; 1302 else if (strstr (name, "[ITC]")) 1303 return 44; 1304 else if (strstr (name, "[RUC]")) 1305 return 45; 1306 else if (strstr (name, "[PFS]")) 1307 return 64; 1308 else if (strstr (name, "[LC]")) 1309 return 65; 1310 else if (strstr (name, "[EC]")) 1311 return 66; 1312 abort (); 1313 case IA64_RS_CRX: 1314 if (strstr (name, "[DCR]")) 1315 return 0; 1316 else if (strstr (name, "[ITM]")) 1317 return 1; 1318 else if (strstr (name, "[IVA]")) 1319 return 2; 1320 else if (strstr (name, "[PTA]")) 1321 return 8; 1322 else if (strstr (name, "[GPTA]")) 1323 return 9; 1324 else if (strstr (name, "[IPSR]")) 1325 return 16; 1326 else if (strstr (name, "[ISR]")) 1327 return 17; 1328 else if (strstr (name, "[IIP]")) 1329 return 19; 1330 else if (strstr (name, "[IFA]")) 1331 return 20; 1332 else if (strstr (name, "[ITIR]")) 1333 return 21; 1334 else if (strstr (name, "[IIPA]")) 1335 return 22; 1336 else if (strstr (name, "[IFS]")) 1337 return 23; 1338 else if (strstr (name, "[IIM]")) 1339 return 24; 1340 else if (strstr (name, "[IHA]")) 1341 return 25; 1342 else if (strstr (name, "[LID]")) 1343 return 64; 1344 else if (strstr (name, "[IVR]")) 1345 return 65; 1346 else if (strstr (name, "[TPR]")) 1347 return 66; 1348 else if (strstr (name, "[EOI]")) 1349 return 67; 1350 else if (strstr (name, "[ITV]")) 1351 return 72; 1352 else if (strstr (name, "[PMV]")) 1353 return 73; 1354 else if (strstr (name, "[CMCV]")) 1355 return 74; 1356 abort (); 1357 case IA64_RS_PSR: 1358 if (strstr (name, ".be")) 1359 return 1; 1360 else if (strstr (name, ".up")) 1361 return 2; 1362 else if (strstr (name, ".ac")) 1363 return 3; 1364 else if (strstr (name, ".mfl")) 1365 return 4; 1366 else if (strstr (name, ".mfh")) 1367 return 5; 1368 else if (strstr (name, ".ic")) 1369 return 13; 1370 else if (strstr (name, ".i")) 1371 return 14; 1372 else if (strstr (name, ".pk")) 1373 return 15; 1374 else if (strstr (name, ".dt")) 1375 return 17; 1376 else if (strstr (name, ".dfl")) 1377 return 18; 1378 else if (strstr (name, ".dfh")) 1379 return 19; 1380 else if (strstr (name, ".sp")) 1381 return 20; 1382 else if (strstr (name, ".pp")) 1383 return 21; 1384 else if (strstr (name, ".di")) 1385 return 22; 1386 else if (strstr (name, ".si")) 1387 return 23; 1388 else if (strstr (name, ".db")) 1389 return 24; 1390 else if (strstr (name, ".lp")) 1391 return 25; 1392 else if (strstr (name, ".tb")) 1393 return 26; 1394 else if (strstr (name, ".rt")) 1395 return 27; 1396 else if (strstr (name, ".cpl")) 1397 return 32; 1398 else if (strstr (name, ".rs")) 1399 return 34; 1400 else if (strstr (name, ".mc")) 1401 return 35; 1402 else if (strstr (name, ".it")) 1403 return 36; 1404 else if (strstr (name, ".id")) 1405 return 37; 1406 else if (strstr (name, ".da")) 1407 return 38; 1408 else if (strstr (name, ".dd")) 1409 return 39; 1410 else if (strstr (name, ".ss")) 1411 return 40; 1412 else if (strstr (name, ".ri")) 1413 return 41; 1414 else if (strstr (name, ".ed")) 1415 return 43; 1416 else if (strstr (name, ".bn")) 1417 return 44; 1418 else if (strstr (name, ".ia")) 1419 return 45; 1420 else if (strstr (name, ".vm")) 1421 return 46; 1422 else 1423 abort (); 1424 default: 1425 break; 1426 } 1427 return REG_NONE; 1428 } 1429 1430 static int 1431 lookup_specifier (const char *name) 1432 { 1433 if (strchr (name, '%')) 1434 { 1435 if (strstr (name, "AR[K%]") != NULL) 1436 return IA64_RS_AR_K; 1437 if (strstr (name, "AR[UNAT]") != NULL) 1438 return IA64_RS_AR_UNAT; 1439 if (strstr (name, "AR%, % in 8") != NULL) 1440 return IA64_RS_AR; 1441 if (strstr (name, "AR%, % in 48") != NULL) 1442 return IA64_RS_ARb; 1443 if (strstr (name, "BR%") != NULL) 1444 return IA64_RS_BR; 1445 if (strstr (name, "CR[IIB%]") != NULL) 1446 return IA64_RS_CR_IIB; 1447 if (strstr (name, "CR[IRR%]") != NULL) 1448 return IA64_RS_CR_IRR; 1449 if (strstr (name, "CR[LRR%]") != NULL) 1450 return IA64_RS_CR_LRR; 1451 if (strstr (name, "CR%") != NULL) 1452 return IA64_RS_CR; 1453 if (strstr (name, "DAHR%, % in 0") != NULL) 1454 return IA64_RS_DAHR; 1455 if (strstr (name, "FR%, % in 0") != NULL) 1456 return IA64_RS_FR; 1457 if (strstr (name, "FR%, % in 2") != NULL) 1458 return IA64_RS_FRb; 1459 if (strstr (name, "GR%") != NULL) 1460 return IA64_RS_GR; 1461 if (strstr (name, "PR%, % in 1 ") != NULL) 1462 return IA64_RS_PR; 1463 if (strstr (name, "PR%, % in 16 ") != NULL) 1464 return IA64_RS_PRr; 1465 1466 warn (_("don't know how to specify %% dependency %s\n"), 1467 name); 1468 } 1469 else if (strchr (name, '#')) 1470 { 1471 if (strstr (name, "CPUID#") != NULL) 1472 return IA64_RS_CPUID; 1473 if (strstr (name, "DBR#") != NULL) 1474 return IA64_RS_DBR; 1475 if (strstr (name, "IBR#") != NULL) 1476 return IA64_RS_IBR; 1477 if (strstr (name, "MSR#") != NULL) 1478 return IA64_RS_MSR; 1479 if (strstr (name, "PKR#") != NULL) 1480 return IA64_RS_PKR; 1481 if (strstr (name, "PMC#") != NULL) 1482 return IA64_RS_PMC; 1483 if (strstr (name, "PMD#") != NULL) 1484 return IA64_RS_PMD; 1485 if (strstr (name, "RR#") != NULL) 1486 return IA64_RS_RR; 1487 1488 warn (_("Don't know how to specify # dependency %s\n"), 1489 name); 1490 } 1491 else if (CONST_STRNEQ (name, "AR[FPSR]")) 1492 return IA64_RS_AR_FPSR; 1493 else if (CONST_STRNEQ (name, "AR[")) 1494 return IA64_RS_ARX; 1495 else if (CONST_STRNEQ (name, "CR[")) 1496 return IA64_RS_CRX; 1497 else if (CONST_STRNEQ (name, "PSR.")) 1498 return IA64_RS_PSR; 1499 else if (strcmp (name, "InService*") == 0) 1500 return IA64_RS_INSERVICE; 1501 else if (strcmp (name, "GR0") == 0) 1502 return IA64_RS_GR0; 1503 else if (strcmp (name, "CFM") == 0) 1504 return IA64_RS_CFM; 1505 else if (strcmp (name, "PR63") == 0) 1506 return IA64_RS_PR63; 1507 else if (strcmp (name, "RSE") == 0) 1508 return IA64_RS_RSE; 1509 1510 return IA64_RS_ANY; 1511 } 1512 1513 static void 1514 print_dependency_table (void) 1515 { 1516 int i, j; 1517 1518 if (debug) 1519 { 1520 for (i=0;i < iclen;i++) 1521 { 1522 if (ics[i]->is_class) 1523 { 1524 if (!ics[i]->nsubs) 1525 { 1526 if (ics[i]->comment) 1527 warn (_("IC:%s [%s] has no terminals or sub-classes\n"), 1528 ics[i]->name, ics[i]->comment); 1529 else 1530 warn (_("IC:%s has no terminals or sub-classes\n"), 1531 ics[i]->name); 1532 } 1533 } 1534 else 1535 { 1536 if (!ics[i]->terminal_resolved && !ics[i]->orphan) 1537 { 1538 if (ics[i]->comment) 1539 warn (_("no insns mapped directly to terminal IC %s [%s]"), 1540 ics[i]->name, ics[i]->comment); 1541 else 1542 warn (_("no insns mapped directly to terminal IC %s\n"), 1543 ics[i]->name); 1544 } 1545 } 1546 } 1547 1548 for (i = 0; i < iclen; i++) 1549 { 1550 if (ics[i]->orphan) 1551 { 1552 mark_used (ics[i], 1); 1553 warn (_("class %s is defined but not used\n"), 1554 ics[i]->name); 1555 } 1556 } 1557 1558 if (debug > 1) 1559 for (i = 0; i < rdepslen; i++) 1560 { 1561 static const char *mode_str[] = { "RAW", "WAW", "WAR" }; 1562 1563 if (rdeps[i]->total_chks == 0) 1564 { 1565 if (rdeps[i]->total_regs) 1566 warn (_("Warning: rsrc %s (%s) has no chks\n"), 1567 rdeps[i]->name, mode_str[rdeps[i]->mode]); 1568 else 1569 warn (_("Warning: rsrc %s (%s) has no chks or regs\n"), 1570 rdeps[i]->name, mode_str[rdeps[i]->mode]); 1571 } 1572 else if (rdeps[i]->total_regs == 0) 1573 warn (_("rsrc %s (%s) has no regs\n"), 1574 rdeps[i]->name, mode_str[rdeps[i]->mode]); 1575 } 1576 } 1577 1578 /* The dependencies themselves. */ 1579 printf ("static const struct ia64_dependency\ndependencies[] = {\n"); 1580 for (i = 0; i < rdepslen; i++) 1581 { 1582 /* '%', '#', AR[], CR[], or PSR. indicates we need to specify the actual 1583 resource used. */ 1584 int specifier = lookup_specifier (rdeps[i]->name); 1585 int regindex = lookup_regindex (rdeps[i]->name, specifier); 1586 1587 printf (" { \"%s\", %d, %d, %d, %d, ", 1588 rdeps[i]->name, specifier, 1589 (int)rdeps[i]->mode, (int)rdeps[i]->semantics, regindex); 1590 if (rdeps[i]->semantics == IA64_DVS_OTHER) 1591 { 1592 const char *quote, *rest; 1593 1594 putchar ('\"'); 1595 rest = rdeps[i]->extra; 1596 quote = strchr (rest, '\"'); 1597 while (quote != NULL) 1598 { 1599 printf ("%.*s\\\"", (int) (quote - rest), rest); 1600 rest = quote + 1; 1601 quote = strchr (rest, '\"'); 1602 } 1603 printf ("%s\", ", rest); 1604 } 1605 else 1606 printf ("NULL, "); 1607 printf("},\n"); 1608 } 1609 printf ("};\n\n"); 1610 1611 /* And dependency lists. */ 1612 for (i=0;i < dlistlen;i++) 1613 { 1614 int len = 2; 1615 printf ("static const unsigned short dep%d[] = {\n ", i); 1616 for (j=0;j < dlists[i]->len; j++) 1617 { 1618 len += printf ("%d, ", dlists[i]->deps[j]); 1619 if (len > 75) 1620 { 1621 printf("\n "); 1622 len = 2; 1623 } 1624 } 1625 printf ("\n};\n\n"); 1626 } 1627 1628 /* And opcode dependency list. */ 1629 printf ("#define NELS(X) (sizeof(X)/sizeof(X[0]))\n"); 1630 printf ("static const struct ia64_opcode_dependency\n"); 1631 printf ("op_dependencies[] = {\n"); 1632 for (i = 0; i < opdeplen; i++) 1633 { 1634 printf (" { "); 1635 if (opdeps[i]->chk == -1) 1636 printf ("0, NULL, "); 1637 else 1638 printf ("NELS(dep%d), dep%d, ", opdeps[i]->chk, opdeps[i]->chk); 1639 if (opdeps[i]->reg == -1) 1640 printf ("0, NULL, "); 1641 else 1642 printf ("NELS(dep%d), dep%d, ", opdeps[i]->reg, opdeps[i]->reg); 1643 printf ("},\n"); 1644 } 1645 printf ("};\n\n"); 1646 } 1647 1648 1649 /* Add STR to the string table. */ 1650 static struct string_entry * 1651 insert_string (char *str) 1652 { 1653 int start = 0, end = strtablen; 1654 int i, x; 1655 1656 if (strtablen == strtabtotlen) 1657 { 1658 strtabtotlen += 20; 1659 string_table = (struct string_entry **) 1660 xrealloc (string_table, 1661 sizeof (struct string_entry **) * strtabtotlen); 1662 } 1663 1664 if (strtablen == 0) 1665 { 1666 strtablen = 1; 1667 string_table[0] = tmalloc (struct string_entry); 1668 string_table[0]->s = xstrdup (str); 1669 string_table[0]->num = 0; 1670 return string_table[0]; 1671 } 1672 1673 if (strcmp (str, string_table[strtablen - 1]->s) > 0) 1674 i = end; 1675 else if (strcmp (str, string_table[0]->s) < 0) 1676 i = 0; 1677 else 1678 { 1679 while (1) 1680 { 1681 int c; 1682 1683 i = (start + end) / 2; 1684 c = strcmp (str, string_table[i]->s); 1685 1686 if (c < 0) 1687 end = i - 1; 1688 else if (c == 0) 1689 return string_table[i]; 1690 else 1691 start = i + 1; 1692 1693 if (start > end) 1694 break; 1695 } 1696 } 1697 1698 for (; i > 0 && i < strtablen; i--) 1699 if (strcmp (str, string_table[i - 1]->s) > 0) 1700 break; 1701 1702 for (; i < strtablen; i++) 1703 if (strcmp (str, string_table[i]->s) < 0) 1704 break; 1705 1706 for (x = strtablen - 1; x >= i; x--) 1707 { 1708 string_table[x + 1] = string_table[x]; 1709 string_table[x + 1]->num = x + 1; 1710 } 1711 1712 string_table[i] = tmalloc (struct string_entry); 1713 string_table[i]->s = xstrdup (str); 1714 string_table[i]->num = i; 1715 strtablen++; 1716 1717 return string_table[i]; 1718 } 1719 1720 static struct bittree * 1721 make_bittree_entry (void) 1722 { 1723 struct bittree *res = tmalloc (struct bittree); 1724 1725 res->disent = NULL; 1726 res->bits[0] = NULL; 1727 res->bits[1] = NULL; 1728 res->bits[2] = NULL; 1729 res->skip_flag = 0; 1730 res->bits_to_skip = 0; 1731 return res; 1732 } 1733 1734 1735 static struct disent * 1736 add_dis_table_ent (struct disent *which, int insn, int order, 1737 ci_t completer_index) 1738 { 1739 int ci = 0; 1740 struct disent *ent; 1741 1742 if (which != NULL) 1743 { 1744 ent = which; 1745 1746 ent->nextcnt++; 1747 while (ent->nexte != NULL) 1748 ent = ent->nexte; 1749 1750 ent = (ent->nexte = tmalloc (struct disent)); 1751 } 1752 else 1753 { 1754 ent = tmalloc (struct disent); 1755 ent->next_ent = disinsntable; 1756 disinsntable = ent; 1757 which = ent; 1758 } 1759 ent->nextcnt = 0; 1760 ent->nexte = NULL; 1761 ent->insn = insn; 1762 ent->priority = order; 1763 1764 while (completer_index != 1) 1765 { 1766 ci = (ci << 1) | (completer_index & 1); 1767 completer_index >>= 1; 1768 } 1769 ent->completer_index = ci; 1770 return which; 1771 } 1772 1773 static void 1774 finish_distable (void) 1775 { 1776 struct disent *ent = disinsntable; 1777 struct disent *prev = ent; 1778 1779 ent->ournum = 32768; 1780 while ((ent = ent->next_ent) != NULL) 1781 { 1782 ent->ournum = prev->ournum + prev->nextcnt + 1; 1783 prev = ent; 1784 } 1785 } 1786 1787 static void 1788 insert_bit_table_ent (struct bittree *curr_ent, int bit, ia64_insn opcode, 1789 ia64_insn mask, int opcodenum, int order, 1790 ci_t completer_index) 1791 { 1792 ia64_insn m; 1793 int b; 1794 struct bittree *next; 1795 1796 if (bit == -1) 1797 { 1798 struct disent *nent = add_dis_table_ent (curr_ent->disent, 1799 opcodenum, order, 1800 completer_index); 1801 curr_ent->disent = nent; 1802 return; 1803 } 1804 1805 m = ((ia64_insn) 1) << bit; 1806 1807 if (mask & m) 1808 b = (opcode & m) ? 1 : 0; 1809 else 1810 b = 2; 1811 1812 next = curr_ent->bits[b]; 1813 if (next == NULL) 1814 { 1815 next = make_bittree_entry (); 1816 curr_ent->bits[b] = next; 1817 } 1818 insert_bit_table_ent (next, bit - 1, opcode, mask, opcodenum, order, 1819 completer_index); 1820 } 1821 1822 static void 1823 add_dis_entry (struct bittree *first, ia64_insn opcode, ia64_insn mask, 1824 int opcodenum, struct completer_entry *ent, ci_t completer_index) 1825 { 1826 if (completer_index & ((ci_t)1 << 32) ) 1827 abort (); 1828 1829 while (ent != NULL) 1830 { 1831 ia64_insn newopcode = (opcode & (~ ent->mask)) | ent->bits; 1832 add_dis_entry (first, newopcode, mask, opcodenum, ent->addl_entries, 1833 (completer_index << 1) | 1); 1834 1835 if (ent->is_terminal) 1836 { 1837 insert_bit_table_ent (bittree, 40, newopcode, mask, 1838 opcodenum, opcode_count - ent->order - 1, 1839 (completer_index << 1) | 1); 1840 } 1841 completer_index <<= 1; 1842 ent = ent->alternative; 1843 } 1844 } 1845 1846 /* This optimization pass combines multiple "don't care" nodes. */ 1847 static void 1848 compact_distree (struct bittree *ent) 1849 { 1850 #define IS_SKIP(ent) \ 1851 ((ent->bits[2] !=NULL) \ 1852 && (ent->bits[0] == NULL && ent->bits[1] == NULL && ent->skip_flag == 0)) 1853 1854 int bitcnt = 0; 1855 struct bittree *nent = ent; 1856 int x; 1857 1858 while (IS_SKIP (nent)) 1859 { 1860 bitcnt++; 1861 nent = nent->bits[2]; 1862 } 1863 1864 if (bitcnt) 1865 { 1866 struct bittree *next = ent->bits[2]; 1867 1868 ent->bits[0] = nent->bits[0]; 1869 ent->bits[1] = nent->bits[1]; 1870 ent->bits[2] = nent->bits[2]; 1871 ent->disent = nent->disent; 1872 ent->skip_flag = 1; 1873 ent->bits_to_skip = bitcnt; 1874 while (next != nent) 1875 { 1876 struct bittree *b = next; 1877 next = next->bits[2]; 1878 free (b); 1879 } 1880 free (nent); 1881 } 1882 1883 for (x = 0; x < 3; x++) 1884 { 1885 struct bittree *i = ent->bits[x]; 1886 1887 if (i != NULL) 1888 compact_distree (i); 1889 } 1890 } 1891 1892 static unsigned char *insn_list; 1893 static int insn_list_len = 0; 1894 static int tot_insn_list_len = 0; 1895 1896 /* Generate the disassembler state machine corresponding to the tree 1897 in ENT. */ 1898 static void 1899 gen_dis_table (struct bittree *ent) 1900 { 1901 int x; 1902 int our_offset = insn_list_len; 1903 int bitsused = 5; 1904 int totbits = bitsused; 1905 int needed_bytes; 1906 int zero_count = 0; 1907 int zero_dest = 0; /* Initialize this with 0 to keep gcc quiet... */ 1908 1909 /* If this is a terminal entry, there's no point in skipping any 1910 bits. */ 1911 if (ent->skip_flag && ent->bits[0] == NULL && ent->bits[1] == NULL && 1912 ent->bits[2] == NULL) 1913 { 1914 if (ent->disent == NULL) 1915 abort (); 1916 else 1917 ent->skip_flag = 0; 1918 } 1919 1920 /* Calculate the amount of space needed for this entry, or at least 1921 a conservatively large approximation. */ 1922 if (ent->skip_flag) 1923 totbits += 5; 1924 1925 for (x = 1; x < 3; x++) 1926 if (ent->bits[x] != NULL) 1927 totbits += 16; 1928 1929 if (ent->disent != NULL) 1930 { 1931 if (ent->bits[2] != NULL) 1932 abort (); 1933 1934 totbits += 16; 1935 } 1936 1937 /* Now allocate the space. */ 1938 needed_bytes = (totbits + 7) / 8; 1939 if ((needed_bytes + insn_list_len) > tot_insn_list_len) 1940 { 1941 tot_insn_list_len += 256; 1942 insn_list = (unsigned char *) xrealloc (insn_list, tot_insn_list_len); 1943 } 1944 our_offset = insn_list_len; 1945 insn_list_len += needed_bytes; 1946 memset (insn_list + our_offset, 0, needed_bytes); 1947 1948 /* Encode the skip entry by setting bit 6 set in the state op field, 1949 and store the # of bits to skip immediately after. */ 1950 if (ent->skip_flag) 1951 { 1952 bitsused += 5; 1953 insn_list[our_offset + 0] |= 0x40 | ((ent->bits_to_skip >> 2) & 0xf); 1954 insn_list[our_offset + 1] |= ((ent->bits_to_skip & 3) << 6); 1955 } 1956 1957 #define IS_ONLY_IFZERO(ENT) \ 1958 ((ENT)->bits[0] != NULL && (ENT)->bits[1] == NULL && (ENT)->bits[2] == NULL \ 1959 && (ENT)->disent == NULL && (ENT)->skip_flag == 0) 1960 1961 /* Store an "if (bit is zero)" instruction by setting bit 7 in the 1962 state op field. */ 1963 if (ent->bits[0] != NULL) 1964 { 1965 struct bittree *nent = ent->bits[0]; 1966 zero_count = 0; 1967 1968 insn_list[our_offset] |= 0x80; 1969 1970 /* We can encode sequences of multiple "if (bit is zero)" tests 1971 by storing the # of zero bits to check in the lower 3 bits of 1972 the instruction. However, this only applies if the state 1973 solely tests for a zero bit. */ 1974 1975 if (IS_ONLY_IFZERO (ent)) 1976 { 1977 while (IS_ONLY_IFZERO (nent) && zero_count < 7) 1978 { 1979 nent = nent->bits[0]; 1980 zero_count++; 1981 } 1982 1983 insn_list[our_offset + 0] |= zero_count; 1984 } 1985 zero_dest = insn_list_len; 1986 gen_dis_table (nent); 1987 } 1988 1989 /* Now store the remaining tests. We also handle a sole "termination 1990 entry" by storing it as an "any bit" test. */ 1991 1992 for (x = 1; x < 3; x++) 1993 { 1994 if (ent->bits[x] != NULL || (x == 2 && ent->disent != NULL)) 1995 { 1996 struct bittree *i = ent->bits[x]; 1997 int idest; 1998 int currbits = 15; 1999 2000 if (i != NULL) 2001 { 2002 /* If the instruction being branched to only consists of 2003 a termination entry, use the termination entry as the 2004 place to branch to instead. */ 2005 if (i->bits[0] == NULL && i->bits[1] == NULL 2006 && i->bits[2] == NULL && i->disent != NULL) 2007 { 2008 idest = i->disent->ournum; 2009 i = NULL; 2010 } 2011 else 2012 idest = insn_list_len - our_offset; 2013 } 2014 else 2015 idest = ent->disent->ournum; 2016 2017 /* If the destination offset for the if (bit is 1) test is less 2018 than 256 bytes away, we can store it as 8-bits instead of 16; 2019 the instruction has bit 5 set for the 16-bit address, and bit 2020 4 for the 8-bit address. Since we've already allocated 16 2021 bits for the address we need to deallocate the space. 2022 2023 Note that branchings within the table are relative, and 2024 there are no branches that branch past our instruction yet 2025 so we do not need to adjust any other offsets. */ 2026 if (x == 1) 2027 { 2028 if (idest <= 256) 2029 { 2030 int start = our_offset + bitsused / 8 + 1; 2031 2032 memmove (insn_list + start, 2033 insn_list + start + 1, 2034 insn_list_len - (start + 1)); 2035 currbits = 7; 2036 totbits -= 8; 2037 needed_bytes--; 2038 insn_list_len--; 2039 insn_list[our_offset] |= 0x10; 2040 idest--; 2041 } 2042 else 2043 insn_list[our_offset] |= 0x20; 2044 } 2045 else 2046 { 2047 /* An instruction which solely consists of a termination 2048 marker and whose disassembly name index is < 4096 2049 can be stored in 16 bits. The encoding is slightly 2050 odd; the upper 4 bits of the instruction are 0x3, and 2051 bit 3 loses its normal meaning. */ 2052 2053 if (ent->bits[0] == NULL && ent->bits[1] == NULL 2054 && ent->bits[2] == NULL && ent->skip_flag == 0 2055 && ent->disent != NULL 2056 && ent->disent->ournum < (32768 + 4096)) 2057 { 2058 int start = our_offset + bitsused / 8 + 1; 2059 2060 memmove (insn_list + start, 2061 insn_list + start + 1, 2062 insn_list_len - (start + 1)); 2063 currbits = 11; 2064 totbits -= 5; 2065 bitsused--; 2066 needed_bytes--; 2067 insn_list_len--; 2068 insn_list[our_offset] |= 0x30; 2069 idest &= ~32768; 2070 } 2071 else 2072 insn_list[our_offset] |= 0x08; 2073 } 2074 2075 if (debug) 2076 { 2077 int id = idest; 2078 2079 if (i == NULL) 2080 id |= 32768; 2081 else if (! (id & 32768)) 2082 id += our_offset; 2083 2084 if (x == 1) 2085 printf ("%d: if (1) goto %d\n", our_offset, id); 2086 else 2087 printf ("%d: try %d\n", our_offset, id); 2088 } 2089 2090 /* Store the address of the entry being branched to. */ 2091 while (currbits >= 0) 2092 { 2093 unsigned char *byte = insn_list + our_offset + bitsused / 8; 2094 2095 if (idest & (1 << currbits)) 2096 *byte |= (1 << (7 - (bitsused % 8))); 2097 2098 bitsused++; 2099 currbits--; 2100 } 2101 2102 /* Now generate the states for the entry being branched to. */ 2103 if (i != NULL) 2104 gen_dis_table (i); 2105 } 2106 } 2107 2108 if (debug) 2109 { 2110 if (ent->skip_flag) 2111 printf ("%d: skipping %d\n", our_offset, ent->bits_to_skip); 2112 2113 if (ent->bits[0] != NULL) 2114 printf ("%d: if (0:%d) goto %d\n", our_offset, zero_count + 1, 2115 zero_dest); 2116 } 2117 2118 if (bitsused != totbits) 2119 abort (); 2120 } 2121 2122 static void 2123 print_dis_table (void) 2124 { 2125 int x; 2126 struct disent *cent = disinsntable; 2127 2128 printf ("static const char dis_table[] = {\n"); 2129 for (x = 0; x < insn_list_len; x++) 2130 { 2131 if ((x > 0) && ((x % 12) == 0)) 2132 printf ("\n"); 2133 2134 printf ("0x%02x, ", insn_list[x]); 2135 } 2136 printf ("\n};\n\n"); 2137 2138 printf ("static const struct ia64_dis_names ia64_dis_names[] = {\n"); 2139 while (cent != NULL) 2140 { 2141 struct disent *ent = cent; 2142 2143 while (ent != NULL) 2144 { 2145 printf ("{ 0x%lx, %d, %d, %d },\n", ( long ) ent->completer_index, 2146 ent->insn, (ent->nexte != NULL ? 1 : 0), 2147 ent->priority); 2148 ent = ent->nexte; 2149 } 2150 cent = cent->next_ent; 2151 } 2152 printf ("};\n\n"); 2153 } 2154 2155 static void 2156 generate_disassembler (void) 2157 { 2158 int i; 2159 2160 bittree = make_bittree_entry (); 2161 2162 for (i = 0; i < otlen; i++) 2163 { 2164 struct main_entry *ptr = ordered_table[i]; 2165 2166 if (ptr->opcode->type != IA64_TYPE_DYN) 2167 add_dis_entry (bittree, 2168 ptr->opcode->opcode, ptr->opcode->mask, 2169 ptr->main_index, 2170 ptr->completers, 1); 2171 } 2172 2173 compact_distree (bittree); 2174 finish_distable (); 2175 gen_dis_table (bittree); 2176 2177 print_dis_table (); 2178 } 2179 2180 static void 2181 print_string_table (void) 2182 { 2183 int x; 2184 char lbuf[80], buf[80]; 2185 int blen = 0; 2186 2187 printf ("static const char * const ia64_strings[] = {\n"); 2188 lbuf[0] = '\0'; 2189 2190 for (x = 0; x < strtablen; x++) 2191 { 2192 int len; 2193 2194 if (strlen (string_table[x]->s) > 75) 2195 abort (); 2196 2197 sprintf (buf, " \"%s\",", string_table[x]->s); 2198 len = strlen (buf); 2199 2200 if ((blen + len) > 75) 2201 { 2202 printf (" %s\n", lbuf); 2203 lbuf[0] = '\0'; 2204 blen = 0; 2205 } 2206 strcat (lbuf, buf); 2207 blen += len; 2208 } 2209 2210 if (blen > 0) 2211 printf (" %s\n", lbuf); 2212 2213 printf ("};\n\n"); 2214 } 2215 2216 static struct completer_entry **glist; 2217 static int glistlen = 0; 2218 static int glisttotlen = 0; 2219 2220 /* If the completer trees ENT1 and ENT2 are equal, return 1. */ 2221 2222 static int 2223 completer_entries_eq (struct completer_entry *ent1, 2224 struct completer_entry *ent2) 2225 { 2226 while (ent1 != NULL && ent2 != NULL) 2227 { 2228 if (ent1->name->num != ent2->name->num 2229 || ent1->bits != ent2->bits 2230 || ent1->mask != ent2->mask 2231 || ent1->is_terminal != ent2->is_terminal 2232 || ent1->dependencies != ent2->dependencies 2233 || ent1->order != ent2->order) 2234 return 0; 2235 2236 if (! completer_entries_eq (ent1->addl_entries, ent2->addl_entries)) 2237 return 0; 2238 2239 ent1 = ent1->alternative; 2240 ent2 = ent2->alternative; 2241 } 2242 2243 return ent1 == ent2; 2244 } 2245 2246 /* Insert ENT into the global list of completers and return it. If an 2247 equivalent entry (according to completer_entries_eq) already exists, 2248 it is returned instead. */ 2249 static struct completer_entry * 2250 insert_gclist (struct completer_entry *ent) 2251 { 2252 if (ent != NULL) 2253 { 2254 int i; 2255 int x; 2256 int start = 0, end; 2257 2258 ent->addl_entries = insert_gclist (ent->addl_entries); 2259 ent->alternative = insert_gclist (ent->alternative); 2260 2261 i = glistlen / 2; 2262 end = glistlen; 2263 2264 if (glisttotlen == glistlen) 2265 { 2266 glisttotlen += 20; 2267 glist = (struct completer_entry **) 2268 xrealloc (glist, sizeof (struct completer_entry *) * glisttotlen); 2269 } 2270 2271 if (glistlen == 0) 2272 { 2273 glist[0] = ent; 2274 glistlen = 1; 2275 return ent; 2276 } 2277 2278 if (ent->name->num < glist[0]->name->num) 2279 i = 0; 2280 else if (ent->name->num > glist[end - 1]->name->num) 2281 i = end; 2282 else 2283 { 2284 int c; 2285 2286 while (1) 2287 { 2288 i = (start + end) / 2; 2289 c = ent->name->num - glist[i]->name->num; 2290 2291 if (c < 0) 2292 end = i - 1; 2293 else if (c == 0) 2294 { 2295 while (i > 0 2296 && ent->name->num == glist[i - 1]->name->num) 2297 i--; 2298 2299 break; 2300 } 2301 else 2302 start = i + 1; 2303 2304 if (start > end) 2305 break; 2306 } 2307 2308 if (c == 0) 2309 { 2310 while (i < glistlen) 2311 { 2312 if (ent->name->num != glist[i]->name->num) 2313 break; 2314 2315 if (completer_entries_eq (ent, glist[i])) 2316 return glist[i]; 2317 2318 i++; 2319 } 2320 } 2321 } 2322 2323 for (; i > 0 && i < glistlen; i--) 2324 if (ent->name->num >= glist[i - 1]->name->num) 2325 break; 2326 2327 for (; i < glistlen; i++) 2328 if (ent->name->num < glist[i]->name->num) 2329 break; 2330 2331 for (x = glistlen - 1; x >= i; x--) 2332 glist[x + 1] = glist[x]; 2333 2334 glist[i] = ent; 2335 glistlen++; 2336 } 2337 return ent; 2338 } 2339 2340 static int 2341 get_prefix_len (const char *name) 2342 { 2343 char *c; 2344 2345 if (name[0] == '\0') 2346 return 0; 2347 2348 c = strchr (name, '.'); 2349 if (c != NULL) 2350 return c - name; 2351 else 2352 return strlen (name); 2353 } 2354 2355 static void 2356 compute_completer_bits (struct main_entry *ment, struct completer_entry *ent) 2357 { 2358 while (ent != NULL) 2359 { 2360 compute_completer_bits (ment, ent->addl_entries); 2361 2362 if (ent->is_terminal) 2363 { 2364 ia64_insn mask = 0; 2365 ia64_insn our_bits = ent->bits; 2366 struct completer_entry *p = ent->parent; 2367 ia64_insn p_bits; 2368 int x; 2369 2370 while (p != NULL && ! p->is_terminal) 2371 p = p->parent; 2372 2373 if (p != NULL) 2374 p_bits = p->bits; 2375 else 2376 p_bits = ment->opcode->opcode; 2377 2378 for (x = 0; x < 64; x++) 2379 { 2380 ia64_insn m = ((ia64_insn) 1) << x; 2381 2382 if ((p_bits & m) != (our_bits & m)) 2383 mask |= m; 2384 else 2385 our_bits &= ~m; 2386 } 2387 ent->bits = our_bits; 2388 ent->mask = mask; 2389 } 2390 else 2391 { 2392 ent->bits = 0; 2393 ent->mask = 0; 2394 } 2395 2396 ent = ent->alternative; 2397 } 2398 } 2399 2400 /* Find identical completer trees that are used in different 2401 instructions and collapse their entries. */ 2402 static void 2403 collapse_redundant_completers (void) 2404 { 2405 struct main_entry *ptr; 2406 int x; 2407 2408 for (ptr = maintable; ptr != NULL; ptr = ptr->next) 2409 { 2410 if (ptr->completers == NULL) 2411 abort (); 2412 2413 compute_completer_bits (ptr, ptr->completers); 2414 ptr->completers = insert_gclist (ptr->completers); 2415 } 2416 2417 /* The table has been finalized, now number the indexes. */ 2418 for (x = 0; x < glistlen; x++) 2419 glist[x]->num = x; 2420 } 2421 2422 2423 /* Attach two lists of dependencies to each opcode. 2424 1) all resources which, when already marked in use, conflict with this 2425 opcode (chks) 2426 2) all resources which must be marked in use when this opcode is used 2427 (regs). */ 2428 static int 2429 insert_opcode_dependencies (struct ia64_opcode *opc, 2430 struct completer_entry *cmp ATTRIBUTE_UNUSED) 2431 { 2432 /* Note all resources which point to this opcode. rfi has the most chks 2433 (79) and cmpxchng has the most regs (54) so 100 here should be enough. */ 2434 int i; 2435 int nregs = 0; 2436 unsigned short regs[256]; 2437 int nchks = 0; 2438 unsigned short chks[256]; 2439 /* Flag insns for which no class matched; there should be none. */ 2440 int no_class_found = 1; 2441 2442 for (i = 0; i < rdepslen; i++) 2443 { 2444 struct rdep *rs = rdeps[i]; 2445 int j; 2446 2447 if (strcmp (opc->name, "cmp.eq.and") == 0 2448 && CONST_STRNEQ (rs->name, "PR%") 2449 && rs->mode == 1) 2450 no_class_found = 99; 2451 2452 for (j=0; j < rs->nregs;j++) 2453 { 2454 int ic_note = 0; 2455 2456 if (in_iclass (opc, ics[rs->regs[j]], NULL, NULL, &ic_note)) 2457 { 2458 /* We can ignore ic_note 11 for non PR resources. */ 2459 if (ic_note == 11 && ! CONST_STRNEQ (rs->name, "PR")) 2460 ic_note = 0; 2461 2462 if (ic_note != 0 && rs->regnotes[j] != 0 2463 && ic_note != rs->regnotes[j] 2464 && !(ic_note == 11 && rs->regnotes[j] == 1)) 2465 warn (_("IC note %d in opcode %s (IC:%s) conflicts with resource %s note %d\n"), 2466 ic_note, opc->name, ics[rs->regs[j]]->name, 2467 rs->name, rs->regnotes[j]); 2468 /* Instruction class notes override resource notes. 2469 So far, only note 11 applies to an IC instead of a resource, 2470 and note 11 implies note 1. */ 2471 if (ic_note) 2472 regs[nregs++] = RDEP(ic_note, i); 2473 else 2474 regs[nregs++] = RDEP(rs->regnotes[j], i); 2475 no_class_found = 0; 2476 ++rs->total_regs; 2477 } 2478 } 2479 2480 for (j = 0; j < rs->nchks; j++) 2481 { 2482 int ic_note = 0; 2483 2484 if (in_iclass (opc, ics[rs->chks[j]], NULL, NULL, &ic_note)) 2485 { 2486 /* We can ignore ic_note 11 for non PR resources. */ 2487 if (ic_note == 11 && ! CONST_STRNEQ (rs->name, "PR")) 2488 ic_note = 0; 2489 2490 if (ic_note != 0 && rs->chknotes[j] != 0 2491 && ic_note != rs->chknotes[j] 2492 && !(ic_note == 11 && rs->chknotes[j] == 1)) 2493 warn (_("IC note %d for opcode %s (IC:%s) conflicts with resource %s note %d\n"), 2494 ic_note, opc->name, ics[rs->chks[j]]->name, 2495 rs->name, rs->chknotes[j]); 2496 if (ic_note) 2497 chks[nchks++] = RDEP(ic_note, i); 2498 else 2499 chks[nchks++] = RDEP(rs->chknotes[j], i); 2500 no_class_found = 0; 2501 ++rs->total_chks; 2502 } 2503 } 2504 } 2505 2506 if (no_class_found) 2507 warn (_("opcode %s has no class (ops %d %d %d)\n"), 2508 opc->name, 2509 opc->operands[0], opc->operands[1], opc->operands[2]); 2510 2511 return insert_dependencies (nchks, chks, nregs, regs); 2512 } 2513 2514 static void 2515 insert_completer_entry (struct ia64_opcode *opc, struct main_entry *tabent, 2516 int order) 2517 { 2518 struct completer_entry **ptr = &tabent->completers; 2519 struct completer_entry *parent = NULL; 2520 char pcopy[129], *prefix; 2521 int at_end = 0; 2522 2523 if (strlen (opc->name) > 128) 2524 abort (); 2525 2526 strcpy (pcopy, opc->name); 2527 prefix = pcopy + get_prefix_len (pcopy); 2528 2529 if (prefix[0] != '\0') 2530 prefix++; 2531 2532 while (! at_end) 2533 { 2534 int need_new_ent = 1; 2535 int plen = get_prefix_len (prefix); 2536 struct string_entry *sent; 2537 2538 at_end = (prefix[plen] == '\0'); 2539 prefix[plen] = '\0'; 2540 sent = insert_string (prefix); 2541 2542 while (*ptr != NULL) 2543 { 2544 int cmpres = sent->num - (*ptr)->name->num; 2545 2546 if (cmpres == 0) 2547 { 2548 need_new_ent = 0; 2549 break; 2550 } 2551 else 2552 ptr = &((*ptr)->alternative); 2553 } 2554 2555 if (need_new_ent) 2556 { 2557 struct completer_entry *nent = tmalloc (struct completer_entry); 2558 2559 nent->name = sent; 2560 nent->parent = parent; 2561 nent->addl_entries = NULL; 2562 nent->alternative = *ptr; 2563 *ptr = nent; 2564 nent->is_terminal = 0; 2565 nent->dependencies = -1; 2566 } 2567 2568 if (! at_end) 2569 { 2570 parent = *ptr; 2571 ptr = &((*ptr)->addl_entries); 2572 prefix += plen + 1; 2573 } 2574 } 2575 2576 if ((*ptr)->is_terminal) 2577 abort (); 2578 2579 (*ptr)->is_terminal = 1; 2580 (*ptr)->mask = (ia64_insn)-1; 2581 (*ptr)->bits = opc->opcode; 2582 (*ptr)->dependencies = insert_opcode_dependencies (opc, *ptr); 2583 (*ptr)->order = order; 2584 } 2585 2586 static void 2587 print_completer_entry (struct completer_entry *ent) 2588 { 2589 int moffset = 0; 2590 ia64_insn mask = ent->mask, bits = ent->bits; 2591 2592 if (mask != 0) 2593 { 2594 while (! (mask & 1)) 2595 { 2596 moffset++; 2597 mask = mask >> 1; 2598 bits = bits >> 1; 2599 } 2600 2601 if (bits & 0xffffffff00000000LL) 2602 abort (); 2603 } 2604 2605 printf (" { 0x%x, 0x%x, %d, %d, %d, %d, %d, %d },\n", 2606 (int)bits, 2607 (int)mask, 2608 ent->name->num, 2609 ent->alternative != NULL ? ent->alternative->num : -1, 2610 ent->addl_entries != NULL ? ent->addl_entries->num : -1, 2611 moffset, 2612 ent->is_terminal ? 1 : 0, 2613 ent->dependencies); 2614 } 2615 2616 static void 2617 print_completer_table (void) 2618 { 2619 int x; 2620 2621 printf ("static const struct ia64_completer_table\ncompleter_table[] = {\n"); 2622 for (x = 0; x < glistlen; x++) 2623 print_completer_entry (glist[x]); 2624 printf ("};\n\n"); 2625 } 2626 2627 static int 2628 opcodes_eq (struct ia64_opcode *opc1, struct ia64_opcode *opc2) 2629 { 2630 int x; 2631 int plen1, plen2; 2632 2633 if ((opc1->mask != opc2->mask) || (opc1->type != opc2->type) 2634 || (opc1->num_outputs != opc2->num_outputs) 2635 || (opc1->flags != opc2->flags)) 2636 return 0; 2637 2638 for (x = 0; x < 5; x++) 2639 if (opc1->operands[x] != opc2->operands[x]) 2640 return 0; 2641 2642 plen1 = get_prefix_len (opc1->name); 2643 plen2 = get_prefix_len (opc2->name); 2644 2645 if (plen1 == plen2 && (memcmp (opc1->name, opc2->name, plen1) == 0)) 2646 return 1; 2647 2648 return 0; 2649 } 2650 2651 static void 2652 add_opcode_entry (struct ia64_opcode *opc) 2653 { 2654 struct main_entry **place; 2655 struct string_entry *name; 2656 char prefix[129]; 2657 int found_it = 0; 2658 2659 if (strlen (opc->name) > 128) 2660 abort (); 2661 2662 place = &maintable; 2663 strcpy (prefix, opc->name); 2664 prefix[get_prefix_len (prefix)] = '\0'; 2665 name = insert_string (prefix); 2666 2667 /* Walk the list of opcode table entries. If it's a new 2668 instruction, allocate and fill in a new entry. Note 2669 the main table is alphabetical by opcode name. */ 2670 2671 while (*place != NULL) 2672 { 2673 if ((*place)->name->num == name->num 2674 && opcodes_eq ((*place)->opcode, opc)) 2675 { 2676 found_it = 1; 2677 break; 2678 } 2679 if ((*place)->name->num > name->num) 2680 break; 2681 2682 place = &((*place)->next); 2683 } 2684 if (! found_it) 2685 { 2686 struct main_entry *nent = tmalloc (struct main_entry); 2687 2688 nent->name = name; 2689 nent->opcode = opc; 2690 nent->next = *place; 2691 nent->completers = 0; 2692 *place = nent; 2693 2694 if (otlen == ottotlen) 2695 { 2696 ottotlen += 20; 2697 ordered_table = (struct main_entry **) 2698 xrealloc (ordered_table, sizeof (struct main_entry *) * ottotlen); 2699 } 2700 ordered_table[otlen++] = nent; 2701 } 2702 2703 insert_completer_entry (opc, *place, opcode_count++); 2704 } 2705 2706 static void 2707 print_main_table (void) 2708 { 2709 struct main_entry *ptr = maintable; 2710 int tindex = 0; 2711 2712 printf ("static const struct ia64_main_table\nmain_table[] = {\n"); 2713 while (ptr != NULL) 2714 { 2715 printf (" { %d, %d, %d, 0x", 2716 ptr->name->num, 2717 ptr->opcode->type, 2718 ptr->opcode->num_outputs); 2719 opcode_fprintf_vma (stdout, ptr->opcode->opcode); 2720 printf ("ull, 0x"); 2721 opcode_fprintf_vma (stdout, ptr->opcode->mask); 2722 printf ("ull, { %d, %d, %d, %d, %d }, 0x%x, %d, },\n", 2723 ptr->opcode->operands[0], 2724 ptr->opcode->operands[1], 2725 ptr->opcode->operands[2], 2726 ptr->opcode->operands[3], 2727 ptr->opcode->operands[4], 2728 ptr->opcode->flags, 2729 ptr->completers->num); 2730 2731 ptr->main_index = tindex++; 2732 2733 ptr = ptr->next; 2734 } 2735 printf ("};\n\n"); 2736 } 2737 2738 static void 2739 shrink (struct ia64_opcode *table) 2740 { 2741 int curr_opcode; 2742 2743 for (curr_opcode = 0; table[curr_opcode].name != NULL; curr_opcode++) 2744 { 2745 add_opcode_entry (table + curr_opcode); 2746 if (table[curr_opcode].num_outputs == 2 2747 && ((table[curr_opcode].operands[0] == IA64_OPND_P1 2748 && table[curr_opcode].operands[1] == IA64_OPND_P2) 2749 || (table[curr_opcode].operands[0] == IA64_OPND_P2 2750 && table[curr_opcode].operands[1] == IA64_OPND_P1))) 2751 { 2752 struct ia64_opcode *alias = tmalloc(struct ia64_opcode); 2753 unsigned i; 2754 2755 *alias = table[curr_opcode]; 2756 for (i = 2; i < NELEMS (alias->operands); ++i) 2757 alias->operands[i - 1] = alias->operands[i]; 2758 alias->operands[NELEMS (alias->operands) - 1] = IA64_OPND_NIL; 2759 --alias->num_outputs; 2760 alias->flags |= PSEUDO; 2761 add_opcode_entry (alias); 2762 } 2763 } 2764 } 2765 2766 2767 /* Program options. */ 2768 #define OPTION_SRCDIR 200 2769 2770 struct option long_options[] = 2771 { 2772 {"srcdir", required_argument, NULL, OPTION_SRCDIR}, 2773 {"debug", no_argument, NULL, 'd'}, 2774 {"version", no_argument, NULL, 'V'}, 2775 {"help", no_argument, NULL, 'h'}, 2776 {0, no_argument, NULL, 0} 2777 }; 2778 2779 static void 2780 print_version (void) 2781 { 2782 printf ("%s: version 1.0\n", program_name); 2783 xexit (0); 2784 } 2785 2786 static void 2787 usage (FILE * stream, int status) 2788 { 2789 fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n", 2790 program_name); 2791 xexit (status); 2792 } 2793 2794 int 2795 main (int argc, char **argv) 2796 { 2797 extern int chdir (char *); 2798 char *srcdir = NULL; 2799 int c; 2800 2801 program_name = *argv; 2802 xmalloc_set_program_name (program_name); 2803 2804 while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF) 2805 switch (c) 2806 { 2807 case OPTION_SRCDIR: 2808 srcdir = optarg; 2809 break; 2810 case 'V': 2811 case 'v': 2812 print_version (); 2813 break; 2814 case 'd': 2815 debug = 1; 2816 break; 2817 case 'h': 2818 case '?': 2819 usage (stderr, 0); 2820 default: 2821 case 0: 2822 break; 2823 } 2824 2825 if (optind != argc) 2826 usage (stdout, 1); 2827 2828 if (srcdir != NULL) 2829 if (chdir (srcdir) != 0) 2830 fail (_("unable to change directory to \"%s\", errno = %s\n"), 2831 srcdir, strerror (errno)); 2832 2833 load_insn_classes (); 2834 load_dependencies (); 2835 2836 shrink (ia64_opcodes_a); 2837 shrink (ia64_opcodes_b); 2838 shrink (ia64_opcodes_f); 2839 shrink (ia64_opcodes_i); 2840 shrink (ia64_opcodes_m); 2841 shrink (ia64_opcodes_x); 2842 shrink (ia64_opcodes_d); 2843 2844 collapse_redundant_completers (); 2845 2846 printf ("/* This file is automatically generated by ia64-gen. Do not edit! */\n"); 2847 printf ("/* Copyright 2007 Free Software Foundation, Inc.\n\ 2848 \n\ 2849 This file is part of the GNU opcodes library.\n\ 2850 \n\ 2851 This library is free software; you can redistribute it and/or modify\n\ 2852 it under the terms of the GNU General Public License as published by\n\ 2853 the Free Software Foundation; either version 3, or (at your option)\n\ 2854 any later version.\n\ 2855 \n\ 2856 It is distributed in the hope that it will be useful, but WITHOUT\n\ 2857 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\ 2858 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\ 2859 License for more details.\n\ 2860 \n\ 2861 You should have received a copy of the GNU General Public License\n\ 2862 along with this program; see the file COPYING. If not, write to the\n\ 2863 Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA\n\ 2864 02110-1301, USA. */\n"); 2865 2866 print_string_table (); 2867 print_dependency_table (); 2868 print_completer_table (); 2869 print_main_table (); 2870 2871 generate_disassembler (); 2872 2873 exit (0); 2874 } 2875