1 /* opc2c.c --- generate C opcode decoder code from from .opc file 2 3 Copyright (C) 2005-2016 Free Software Foundation, Inc. 4 Contributed by Red Hat, Inc. 5 6 This file is part of the GNU opcode library. 7 8 This program 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 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 22 #include <stdio.h> 23 #include <string.h> 24 #include <ctype.h> 25 #include <stdlib.h> 26 #include <errno.h> 27 #include "libiberty.h" 28 29 static char * line_buf = NULL; 30 static int line_buf_size = 0; 31 32 #define LBUFINCR 100 33 34 char * 35 safe_fgets (FILE * f) 36 { 37 char * line_ptr; 38 39 if (line_buf == NULL) 40 { 41 line_buf = (char *) malloc (LBUFINCR); 42 line_buf_size = LBUFINCR; 43 } 44 45 /* Points to last byte. */ 46 line_ptr = line_buf + line_buf_size - 1; 47 48 /* So we can see if fgets put a 0 there. */ 49 *line_ptr = 1; 50 if (fgets (line_buf, line_buf_size, f) == 0) 51 return NULL; 52 53 /* We filled the buffer? */ 54 while (line_ptr[0] == 0 && line_ptr[-1] != '\n') 55 { 56 /* Make the buffer bigger and read more of the line. */ 57 line_buf_size += LBUFINCR; 58 line_buf = (char *) realloc (line_buf, line_buf_size); 59 60 /* Points to last byte again. */ 61 line_ptr = line_buf + line_buf_size - 1; 62 /* So we can see if fgets put a 0 there. */ 63 *line_ptr = 1; 64 65 if (fgets (line_buf + line_buf_size - LBUFINCR - 1, LBUFINCR + 1, f) == 0) 66 return NULL; 67 } 68 69 return line_buf; 70 } 71 72 73 static int errors = 0; 74 75 #define MAX_BYTES 10 76 77 typedef struct 78 { 79 int varyno:16; 80 int byte:8; 81 int shift:8; 82 } VaryRef; 83 84 typedef struct 85 { 86 char nbytes; 87 char dbytes; 88 char id[MAX_BYTES * 8 + 1]; 89 unsigned char var_start[MAX_BYTES * 8 + 1]; 90 struct 91 { 92 unsigned char decodable_mask; 93 unsigned char decodable_bits; 94 } b[MAX_BYTES]; 95 char * comment; 96 char * syntax; 97 int lineno; 98 int nlines; 99 char ** lines; 100 struct Indirect * last_ind; 101 int semantics_label; 102 int nvaries; 103 VaryRef * vary; 104 } opcode; 105 106 int n_opcodes; 107 opcode ** opcodes; 108 opcode * op; 109 110 typedef struct 111 { 112 char * name; 113 int nlen; 114 unsigned char mask; 115 int n_patterns; 116 unsigned char * patterns; 117 } Vary; 118 119 Vary ** vary = 0; 120 int n_varies = 0; 121 122 unsigned char cur_bits[MAX_BYTES + 1]; 123 124 const char * orig_filename; 125 126 FILE * sim_log = NULL; 127 #define lprintf if (sim_log) fprintf 128 129 opcode prefix_text, suffix_text; 130 131 typedef enum 132 { 133 T_unused, 134 T_op, 135 T_indirect, 136 T_done 137 } OpType; 138 139 typedef struct Indirect 140 { 141 OpType type; 142 union 143 { 144 struct Indirect * ind; 145 opcode * op; 146 } u; 147 } Indirect; 148 149 Indirect indirect[256]; 150 151 static int 152 next_varybits (int bits, opcode * op, int byte) 153 { 154 int mask = op->b[byte].decodable_mask; 155 int i; 156 157 for (i = 0; i < 8; i++) 158 if (!(mask & (1 << i))) 159 { 160 if (bits & (1 << i)) 161 { 162 bits &= ~(1 << i); 163 } 164 else 165 { 166 bits |= (1 << i); 167 return bits; 168 } 169 } 170 return 0; 171 } 172 173 static int 174 valid_varybits (int bits, opcode * op, int byte) 175 { 176 if (op->nvaries) 177 { 178 int vn; 179 180 for (vn = 0; vn < op->nvaries; vn++) 181 { 182 Vary * v; 183 int found = 0; 184 int i; 185 int ob; 186 187 if (byte != op->vary[vn].byte) 188 continue; 189 v = vary[op->vary[vn].varyno]; 190 ob = (bits >> op->vary[vn].shift) & v->mask; 191 lprintf (sim_log, "varybits: vary %s ob %x\n", v->name, ob); 192 193 for (i = 0; i < v->n_patterns; i++) 194 if (ob == v->patterns[i]) 195 { 196 lprintf (sim_log, " found at %d\n", i); 197 found = 1; 198 break; 199 } 200 if (!found) 201 return 0; 202 } 203 } 204 return 1; 205 } 206 207 char * 208 prmb (int mask, int bits) 209 { 210 static char buf[8][30]; 211 static int bn = 0; 212 char * bp; 213 214 bn = (bn + 1) % 8; 215 bp = buf[bn]; 216 int i; 217 for (i = 0; i < 8; i++) 218 { 219 int bit = 0x80 >> i; 220 221 if (!(mask & bit)) 222 *bp++ = '-'; 223 else if (bits & bit) 224 *bp++ = '1'; 225 else 226 *bp++ = '0'; 227 if (i % 4 == 3) 228 *bp++ = ' '; 229 } 230 *--bp = 0; 231 return buf[bn]; 232 } 233 234 static int 235 op_cmp (const void *va, const void *vb) 236 { 237 const opcode * a = *(const opcode **) va; 238 const opcode * b = *(const opcode **) vb; 239 240 if (a->nbytes != b->nbytes) 241 return a->nbytes - b->nbytes; 242 243 return strcmp (a->id, b->id); 244 } 245 246 void 247 dump_lines (opcode * op, int level, Indirect * ind) 248 { 249 char * varnames[40]; 250 int i, vn = 0; 251 252 if (op->semantics_label) 253 { 254 printf ("%*sgoto op_semantics_%d;\n", level, "", op->semantics_label); 255 return; 256 } 257 258 if (ind != op->last_ind) 259 { 260 static int labelno = 0; 261 labelno++; 262 printf ("%*sop_semantics_%d:\n", level, "", labelno); 263 op->semantics_label = labelno; 264 } 265 266 if (op->comment) 267 { 268 level += 2; 269 printf ("%*s{\n", level, ""); 270 printf ("%*s %s\n", level, "", op->comment); 271 } 272 273 for (i = 0; i < op->nbytes * 8;) 274 { 275 if (isalpha (op->id[i])) 276 { 277 int byte = i >> 3; 278 int mask = 0; 279 int shift = 0; 280 char name[33]; 281 char * np = name; 282 283 while (op->id[i] && isalpha (op->id[i])) 284 { 285 mask = (mask << 1) | 1; 286 shift = 7 - (i & 7); 287 *np++ = op->id[i++]; 288 if (op->var_start[i]) 289 break; 290 } 291 *np = 0; 292 varnames[vn++] = strdup (name); 293 printf ("#line %d \"%s\"\n", op->lineno + 1, orig_filename); 294 if (mask & ~0xff) 295 { 296 fprintf (stderr, "Error: variable %s spans bytes: %s\n", 297 name, op->comment); 298 errors++; 299 } 300 else if (shift && (mask != 0xff)) 301 printf ("%*s int %s AU = (op[%d] >> %d) & 0x%02x;\n", 302 level, "", name, byte, shift, mask); 303 else if (mask != 0xff) 304 printf ("%*s int %s AU = op[%d] & 0x%02x;\n", 305 level, "", name, byte, mask); 306 else 307 printf ("%*s int %s AU = op[%d];\n", level, "", name, byte); 308 } 309 else 310 i++; 311 } 312 313 if (op->comment) 314 { 315 printf ("%*s if (trace)\n", level, ""); 316 printf ("%*s {\n", level, ""); 317 printf ("%*s printf (\"\\033[33m%%s\\033[0m ", level, ""); 318 for (i = 0; i < op->nbytes; i++) 319 printf (" %%02x"); 320 printf ("\\n\""); 321 printf (",\n%*s \"%s\"", level, "", op->comment); 322 for (i = 0; i < op->nbytes; i++) 323 { 324 if (i == 0) 325 printf (",\n%*s op[%d]", level, "", i); 326 else 327 printf (", op[%d]", i); 328 } 329 printf (");\n"); 330 for (i = 0; i < vn; i++) 331 printf ("%*s printf (\" %s = 0x%%x%s\", %s);\n", level, "", 332 varnames[i], (i < vn - 1) ? "," : "\\n", varnames[i]); 333 printf ("%*s }\n", level, ""); 334 } 335 336 if (op->syntax) 337 printf ("%*s SYNTAX(\"%s\");\n", level, "", op->syntax); 338 339 printf ("#line %d \"%s\"\n", op->lineno + 1, orig_filename); 340 341 for (i = 0; i < op->nlines; i++) 342 if (op->lines[i][0] == '\n') 343 printf ("%s", op->lines[i]); 344 else 345 printf ("%*s%s", level, "", op->lines[i]); 346 347 if (op->comment) 348 printf ("%*s}\n", level, ""); 349 } 350 351 void 352 store_opcode_bits (opcode * op, int byte, Indirect * ind) 353 { 354 int bits = op->b[byte].decodable_bits; 355 356 do 357 { 358 if (!valid_varybits (bits, op, byte)) 359 continue; 360 361 switch (ind[bits].type) 362 { 363 case T_unused: 364 if (byte == op->dbytes - 1) 365 { 366 ind[bits].type = T_op; 367 ind[bits].u.op = op; 368 op->last_ind = ind; 369 break; 370 } 371 else 372 { 373 int i2; 374 375 ind[bits].type = T_indirect; 376 ind[bits].u.ind = (Indirect *) malloc (256 * sizeof (Indirect)); 377 for (i2 = 0; i2 < 256; i2++) 378 ind[bits].u.ind[i2].type = T_unused; 379 store_opcode_bits (op, byte + 1, ind[bits].u.ind); 380 } 381 break; 382 383 case T_indirect: 384 if (byte < op->dbytes - 1) 385 store_opcode_bits (op, byte + 1, ind[bits].u.ind); 386 break; 387 388 case T_op: 389 break; 390 391 case T_done: 392 break; 393 } 394 } 395 while ((bits = next_varybits (bits, op, byte)) != 0); 396 } 397 398 void 399 emit_indirect (Indirect * ind, int byte) 400 { 401 int unsup = 0; 402 int j, n, mask; 403 404 mask = 0; 405 for (j = 0; j < 256; j++) 406 { 407 switch (ind[j].type) 408 { 409 case T_indirect: 410 mask = 0xff; 411 break; 412 case T_op: 413 mask |= ind[j].u.op->b[byte].decodable_mask; 414 break; 415 case T_done: 416 case T_unused: 417 break; 418 } 419 } 420 421 printf ("%*s GETBYTE ();\n", byte * 6, ""); 422 printf ("%*s switch (op[%d] & 0x%02x)\n", byte * 6, "", byte, mask); 423 printf ("%*s {\n", byte * 6, ""); 424 425 for (j = 0; j < 256; j++) 426 if ((j & ~mask) == 0) 427 { 428 switch (ind[j].type) 429 { 430 case T_done: 431 break; 432 case T_unused: 433 unsup = 1; 434 break; 435 case T_op: 436 for (n = j; n < 256; n++) 437 if ((n & ~mask) == 0 438 && ind[n].type == T_op && ind[n].u.op == ind[j].u.op) 439 { 440 ind[n].type = T_done; 441 printf ("%*s case 0x%02x:\n", byte * 6, "", n); 442 } 443 for (n = byte; n < ind[j].u.op->nbytes - 1; n++) 444 printf ("%*s GETBYTE();\n", byte * 6, ""); 445 dump_lines (ind[j].u.op, byte * 6 + 6, ind); 446 printf ("%*s break;\n", byte * 6, ""); 447 break; 448 case T_indirect: 449 printf ("%*s case 0x%02x:\n", byte * 6, "", j); 450 emit_indirect (ind[j].u.ind, byte + 1); 451 printf ("%*s break;\n", byte * 6, ""); 452 break; 453 } 454 } 455 if (unsup) 456 printf ("%*s default: UNSUPPORTED(); break;\n", byte * 6, ""); 457 printf ("%*s }\n", byte * 6, ""); 458 } 459 460 static char * 461 pv_dup (char * p, char * ep) 462 { 463 int n = ep - p; 464 char *rv = (char *) malloc (n + 1); 465 466 memcpy (rv, p, n); 467 rv[n] = 0; 468 return rv; 469 } 470 471 static unsigned char 472 str2mask (char * str, char * ep) 473 { 474 unsigned char rv = 0; 475 476 while (str < ep) 477 { 478 rv *= 2; 479 if (*str == '1') 480 rv += 1; 481 str++; 482 } 483 return rv; 484 } 485 486 static void 487 process_vary (char * line) 488 { 489 char * cp; 490 char * ep; 491 Vary * v = (Vary *) malloc (sizeof (Vary)); 492 493 n_varies++; 494 if (vary) 495 vary = (Vary **) realloc (vary, n_varies * sizeof (Vary *)); 496 else 497 vary = (Vary **) malloc (n_varies * sizeof (Vary *)); 498 vary[n_varies - 1] = v; 499 500 cp = line; 501 502 for (cp = line; isspace (*cp); cp++); 503 for (ep = cp; *ep && !isspace (*ep); ep++); 504 505 v->name = pv_dup (cp, ep); 506 v->nlen = strlen (v->name); 507 v->mask = (1 << v->nlen) - 1; 508 509 v->n_patterns = 0; 510 v->patterns = (unsigned char *) malloc (1); 511 while (1) 512 { 513 for (cp = ep; isspace (*cp); cp++); 514 if (!isdigit (*cp)) 515 break; 516 for (ep = cp; *ep && !isspace (*ep); ep++); 517 v->n_patterns++; 518 v->patterns = (unsigned char *) realloc (v->patterns, v->n_patterns); 519 v->patterns[v->n_patterns - 1] = str2mask (cp, ep); 520 } 521 } 522 523 static int 524 fieldcmp (opcode * op, int bit, char *name) 525 { 526 int n = strlen (name); 527 528 if (memcmp (op->id + bit, name, n) == 0 529 && (!isalpha (op->id[bit + n]) || op->var_start[bit + n])) 530 return 1; 531 return 0; 532 } 533 534 static void 535 log_indirect (Indirect * ind, int byte) 536 { 537 int i, j; 538 char * last_c = 0; 539 540 for (i = 0; i < 256; i++) 541 { 542 543 for (j = 0; j < byte; j++) 544 fprintf (sim_log, "%s ", prmb (255, cur_bits[j])); 545 fprintf (sim_log, "%s ", prmb (255, i)); 546 547 switch (ind[i].type) 548 { 549 case T_op: 550 case T_done: 551 if (last_c && (ind[i].u.op->comment == last_c)) 552 fprintf (sim_log, "''\n"); 553 else 554 fprintf (sim_log, "%s\n", ind[i].u.op->comment); 555 last_c = ind[i].u.op->comment; 556 break; 557 case T_unused: 558 fprintf (sim_log, "unused\n"); 559 break; 560 case T_indirect: 561 fprintf (sim_log, "indirect\n"); 562 cur_bits[byte] = i; 563 log_indirect (ind[i].u.ind, byte + 1); 564 last_c = 0; 565 break; 566 } 567 } 568 } 569 570 int 571 main (int argc, char ** argv) 572 { 573 char * line; 574 FILE * in; 575 int lineno = 0; 576 int i; 577 VaryRef * vlist; 578 int skipping_section = 0; 579 580 if (argc > 2 && strcmp (argv[1], "-l") == 0) 581 { 582 sim_log = fopen (argv[2], "w"); 583 fprintf (stderr, "sim_log: %s\n", argv[2]); 584 argc -= 2; 585 argv += 2; 586 } 587 588 if (argc < 2) 589 { 590 fprintf (stderr, "usage: opc2c infile.opc > outfile.opc\n"); 591 exit (1); 592 } 593 594 orig_filename = lbasename (argv[1]); 595 in = fopen (argv[1], "r"); 596 if (!in) 597 { 598 fprintf (stderr, "Unable to open file %s for reading: %s\n", argv[1], 599 xstrerror (errno)); 600 exit (1); 601 } 602 603 n_opcodes = 0; 604 opcodes = (opcode **) malloc (sizeof (opcode *)); 605 op = &prefix_text; 606 op->lineno = 0; 607 while ((line = safe_fgets (in)) != 0) 608 { 609 lineno++; 610 if (strncmp (line, "/*?* ", 5) == 0) 611 { 612 skipping_section = 1; 613 continue; 614 } 615 if (strncmp (line, " /** ", 6) == 0 616 && (isdigit (line[6]) || memcmp (line + 6, "VARY", 4) == 0)) 617 line += 2; 618 if (line[0] == '/' && line[1] == '*' && line[2] == '*') 619 { 620 skipping_section = 0; 621 if (strncmp (line, "/** */", 6) == 0) 622 { 623 op = &suffix_text; 624 op->lineno = lineno; 625 } 626 else if (strncmp (line, "/** VARY ", 9) == 0) 627 process_vary (line + 9); 628 else 629 { 630 char * lp; 631 int i, bit, byte; 632 int var_start = 1; 633 634 n_opcodes++; 635 opcodes = 636 (opcode **) realloc (opcodes, n_opcodes * sizeof (opcode *)); 637 op = (opcode *) malloc (sizeof (opcode)); 638 opcodes[n_opcodes - 1] = op; 639 640 op->nbytes = op->dbytes = 0; 641 memset (op->id, 0, sizeof (op->id)); 642 memset (op->var_start, 0, sizeof (op->var_start)); 643 for (i = 0; i < MAX_BYTES; i++) 644 { 645 op->b[i].decodable_mask = 0; 646 op->b[i].decodable_bits = 0; 647 } 648 op->comment = strdup (line); 649 op->comment[strlen (op->comment) - 1] = 0; 650 while (op->comment[0] && isspace (op->comment[0])) 651 op->comment++; 652 op->lineno = lineno; 653 op->nlines = 0; 654 op->lines = 0; 655 op->last_ind = 0; 656 op->semantics_label = 0; 657 op->nvaries = 0; 658 op->vary = 0; 659 660 i = 0; 661 for (lp = line + 4; *lp; lp++) 662 { 663 bit = 7 - (i & 7); 664 byte = i >> 3; 665 666 if (strncmp (lp, "*/", 2) == 0) 667 break; 668 else if ((lp[0] == ' ' && lp[1] == ' ') || (lp[0] == '\t')) 669 { 670 while (*lp == ' ' || *lp == '\t') 671 lp ++; 672 op->syntax = strdup (lp); 673 lp = strstr (op->syntax, "*/"); 674 if (lp) 675 { 676 *lp-- = 0; 677 while ((*lp == ' ' || *lp == '\t') 678 && lp > op->syntax) 679 *lp-- = 0; 680 } 681 break; 682 } 683 else if (*lp == ' ') 684 var_start = 1; 685 else 686 { 687 if (*lp == '0' || *lp == '1') 688 { 689 op->b[byte].decodable_mask |= 1 << bit; 690 var_start = 1; 691 if (op->dbytes < byte + 1) 692 op->dbytes = byte + 1; 693 } 694 else if (var_start) 695 { 696 op->var_start[i] = 1; 697 var_start = 0; 698 if (op->dbytes < byte + 1) 699 op->dbytes = byte + 1; 700 } 701 if (*lp == '1') 702 op->b[byte].decodable_bits |= 1 << bit; 703 704 op->nbytes = byte + 1; 705 op->id[i++] = *lp; 706 } 707 } 708 } 709 } 710 else if (!skipping_section) 711 { 712 op->nlines++; 713 if (op->lines) 714 op->lines = 715 (char **) realloc (op->lines, op->nlines * sizeof (char *)); 716 else 717 op->lines = (char **) malloc (op->nlines * sizeof (char *)); 718 op->lines[op->nlines - 1] = strdup (line); 719 } 720 } 721 722 { 723 int i, j; 724 for (i = 0; i < n_varies; i++) 725 { 726 Vary *v = vary[i]; 727 lprintf (sim_log, "V[%s] %d\n", v->name, v->nlen); 728 for (j = 0; j < v->n_patterns; j++) 729 lprintf (sim_log, " P %02x\n", v->patterns[j]); 730 } 731 } 732 733 for (i = n_opcodes - 2; i >= 0; i--) 734 { 735 if (opcodes[i]->nlines == 0) 736 { 737 opcodes[i]->nlines = opcodes[i + 1]->nlines; 738 opcodes[i]->lines = opcodes[i + 1]->lines; 739 } 740 } 741 742 for (i = 0; i < 256; i++) 743 indirect[i].type = T_unused; 744 745 qsort (opcodes, n_opcodes, sizeof (opcodes[0]), op_cmp); 746 747 vlist = (VaryRef *) malloc (n_varies * sizeof (VaryRef)); 748 749 for (i = 0; i < n_opcodes; i++) 750 { 751 int j, b, v; 752 753 for (j = 0; j < opcodes[i]->nbytes; j++) 754 lprintf (sim_log, "%s ", 755 prmb (opcodes[i]->b[j].decodable_mask, 756 opcodes[i]->b[j].decodable_bits)); 757 lprintf (sim_log, " %s\n", opcodes[i]->comment); 758 759 for (j = 0; j < opcodes[i]->nbytes; j++) 760 { 761 for (b = 0; b < 8; b++) 762 if (isalpha (opcodes[i]->id[j * 8 + b])) 763 for (v = 0; v < n_varies; v++) 764 if (fieldcmp (opcodes[i], j * 8 + b, vary[v]->name)) 765 { 766 int nv = opcodes[i]->nvaries++; 767 if (nv) 768 opcodes[i]->vary = 769 (VaryRef *) realloc (opcodes[i]->vary, 770 (nv + 1) * sizeof (VaryRef)); 771 else 772 opcodes[i]->vary = 773 (VaryRef *) malloc ((nv + 1) * sizeof (VaryRef)); 774 775 opcodes[i]->vary[nv].varyno = v; 776 opcodes[i]->vary[nv].byte = j; 777 opcodes[i]->vary[nv].shift = 8 - b - vary[v]->nlen; 778 lprintf (sim_log, "[vary %s shift %d]\n", 779 vary[v]->name, opcodes[i]->vary[nv].shift); 780 } 781 782 } 783 } 784 785 for (i = 0; i < n_opcodes; i++) 786 { 787 int i2; 788 int bytes = opcodes[i]->dbytes; 789 790 lprintf (sim_log, "\nmask:"); 791 for (i2 = 0; i2 < opcodes[i]->nbytes; i2++) 792 lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_mask); 793 lprintf (sim_log, "%*s%s\n", 13 - 3 * opcodes[i]->nbytes, "", 794 opcodes[i]->comment); 795 796 lprintf (sim_log, "bits:"); 797 for (i2 = 0; i2 < opcodes[i]->nbytes; i2++) 798 lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_bits); 799 lprintf (sim_log, "%*s(%s) %d byte%s\n", 13 - 3 * opcodes[i]->nbytes, 800 "", opcodes[i]->id, bytes, bytes == 1 ? "" : "s"); 801 802 store_opcode_bits (opcodes[i], 0, indirect); 803 } 804 805 dump_lines (&prefix_text, 0, 0); 806 807 emit_indirect (indirect, 0); 808 809 dump_lines (&suffix_text, 0, 0); 810 811 if (sim_log) 812 log_indirect (indirect, 0); 813 814 return errors; 815 } 816
