1 /* opc2c.c --- generate C opcode decoder code from from .opc file 2 3 Copyright (C) 2005-2014 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 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 printf ("%*s%s", level, "", op->lines[i]); 343 344 if (op->comment) 345 printf ("%*s}\n", level, ""); 346 } 347 348 void 349 store_opcode_bits (opcode * op, int byte, Indirect * ind) 350 { 351 int bits = op->b[byte].decodable_bits; 352 353 do 354 { 355 if (!valid_varybits (bits, op, byte)) 356 continue; 357 358 switch (ind[bits].type) 359 { 360 case T_unused: 361 if (byte == op->dbytes - 1) 362 { 363 ind[bits].type = T_op; 364 ind[bits].u.op = op; 365 op->last_ind = ind; 366 break; 367 } 368 else 369 { 370 int i2; 371 372 ind[bits].type = T_indirect; 373 ind[bits].u.ind = (Indirect *) malloc (256 * sizeof (Indirect)); 374 for (i2 = 0; i2 < 256; i2++) 375 ind[bits].u.ind[i2].type = T_unused; 376 store_opcode_bits (op, byte + 1, ind[bits].u.ind); 377 } 378 break; 379 380 case T_indirect: 381 if (byte < op->dbytes - 1) 382 store_opcode_bits (op, byte + 1, ind[bits].u.ind); 383 break; 384 385 case T_op: 386 break; 387 388 case T_done: 389 break; 390 } 391 } 392 while ((bits = next_varybits (bits, op, byte)) != 0); 393 } 394 395 void 396 emit_indirect (Indirect * ind, int byte) 397 { 398 int unsup = 0; 399 int j, n, mask; 400 401 mask = 0; 402 for (j = 0; j < 256; j++) 403 { 404 switch (ind[j].type) 405 { 406 case T_indirect: 407 mask = 0xff; 408 break; 409 case T_op: 410 mask |= ind[j].u.op->b[byte].decodable_mask; 411 break; 412 case T_done: 413 case T_unused: 414 break; 415 } 416 } 417 418 printf ("%*s GETBYTE ();\n", byte * 6, ""); 419 printf ("%*s switch (op[%d] & 0x%02x)\n", byte * 6, "", byte, mask); 420 printf ("%*s {\n", byte * 6, ""); 421 422 for (j = 0; j < 256; j++) 423 if ((j & ~mask) == 0) 424 { 425 switch (ind[j].type) 426 { 427 case T_done: 428 break; 429 case T_unused: 430 unsup = 1; 431 break; 432 case T_op: 433 for (n = j; n < 256; n++) 434 if ((n & ~mask) == 0 435 && ind[n].type == T_op && ind[n].u.op == ind[j].u.op) 436 { 437 ind[n].type = T_done; 438 printf ("%*s case 0x%02x:\n", byte * 6, "", n); 439 } 440 for (n = byte; n < ind[j].u.op->nbytes - 1; n++) 441 printf ("%*s GETBYTE();\n", byte * 6, ""); 442 dump_lines (ind[j].u.op, byte * 6 + 6, ind); 443 printf ("%*s break;\n", byte * 6, ""); 444 break; 445 case T_indirect: 446 printf ("%*s case 0x%02x:\n", byte * 6, "", j); 447 emit_indirect (ind[j].u.ind, byte + 1); 448 printf ("%*s break;\n", byte * 6, ""); 449 break; 450 } 451 } 452 if (unsup) 453 printf ("%*s default: UNSUPPORTED(); break;\n", byte * 6, ""); 454 printf ("%*s }\n", byte * 6, ""); 455 } 456 457 static char * 458 pv_dup (char * p, char * ep) 459 { 460 int n = ep - p; 461 char *rv = (char *) malloc (n + 1); 462 463 memcpy (rv, p, n); 464 rv[n] = 0; 465 return rv; 466 } 467 468 static unsigned char 469 str2mask (char * str, char * ep) 470 { 471 unsigned char rv = 0; 472 473 while (str < ep) 474 { 475 rv *= 2; 476 if (*str == '1') 477 rv += 1; 478 str++; 479 } 480 return rv; 481 } 482 483 static void 484 process_vary (char * line) 485 { 486 char * cp; 487 char * ep; 488 Vary * v = (Vary *) malloc (sizeof (Vary)); 489 490 n_varies++; 491 if (vary) 492 vary = (Vary **) realloc (vary, n_varies * sizeof (Vary *)); 493 else 494 vary = (Vary **) malloc (n_varies * sizeof (Vary *)); 495 vary[n_varies - 1] = v; 496 497 cp = line; 498 499 for (cp = line; isspace (*cp); cp++); 500 for (ep = cp; *ep && !isspace (*ep); ep++); 501 502 v->name = pv_dup (cp, ep); 503 v->nlen = strlen (v->name); 504 v->mask = (1 << v->nlen) - 1; 505 506 v->n_patterns = 0; 507 v->patterns = (unsigned char *) malloc (1); 508 while (1) 509 { 510 for (cp = ep; isspace (*cp); cp++); 511 if (!isdigit (*cp)) 512 break; 513 for (ep = cp; *ep && !isspace (*ep); ep++); 514 v->n_patterns++; 515 v->patterns = (unsigned char *) realloc (v->patterns, v->n_patterns); 516 v->patterns[v->n_patterns - 1] = str2mask (cp, ep); 517 } 518 } 519 520 static int 521 fieldcmp (opcode * op, int bit, char *name) 522 { 523 int n = strlen (name); 524 525 if (memcmp (op->id + bit, name, n) == 0 526 && (!isalpha (op->id[bit + n]) || op->var_start[bit + n])) 527 return 1; 528 return 0; 529 } 530 531 static void 532 log_indirect (Indirect * ind, int byte) 533 { 534 int i, j; 535 char * last_c = 0; 536 537 for (i = 0; i < 256; i++) 538 { 539 540 for (j = 0; j < byte; j++) 541 fprintf (sim_log, "%s ", prmb (255, cur_bits[j])); 542 fprintf (sim_log, "%s ", prmb (255, i)); 543 544 switch (ind[i].type) 545 { 546 case T_op: 547 case T_done: 548 if (last_c && (ind[i].u.op->comment == last_c)) 549 fprintf (sim_log, "''\n"); 550 else 551 fprintf (sim_log, "%s\n", ind[i].u.op->comment); 552 last_c = ind[i].u.op->comment; 553 break; 554 case T_unused: 555 fprintf (sim_log, "unused\n"); 556 break; 557 case T_indirect: 558 fprintf (sim_log, "indirect\n"); 559 cur_bits[byte] = i; 560 log_indirect (ind[i].u.ind, byte + 1); 561 last_c = 0; 562 break; 563 } 564 } 565 } 566 567 int 568 main (int argc, char ** argv) 569 { 570 char * line; 571 FILE * in; 572 int lineno = 0; 573 int i; 574 VaryRef * vlist; 575 int skipping_section = 0; 576 577 if (argc > 2 && strcmp (argv[1], "-l") == 0) 578 { 579 sim_log = fopen (argv[2], "w"); 580 fprintf (stderr, "sim_log: %s\n", argv[2]); 581 argc -= 2; 582 argv += 2; 583 } 584 585 if (argc < 2) 586 { 587 fprintf (stderr, "usage: opc2c infile.opc > outfile.opc\n"); 588 exit (1); 589 } 590 591 orig_filename = lbasename (argv[1]); 592 in = fopen (argv[1], "r"); 593 if (!in) 594 { 595 fprintf (stderr, "Unable to open file %s for reading: %s\n", argv[1], 596 xstrerror (errno)); 597 exit (1); 598 } 599 600 n_opcodes = 0; 601 opcodes = (opcode **) malloc (sizeof (opcode *)); 602 op = &prefix_text; 603 op->lineno = 0; 604 while ((line = safe_fgets (in)) != 0) 605 { 606 lineno++; 607 if (strncmp (line, "/*?* ", 5) == 0) 608 { 609 skipping_section = 1; 610 continue; 611 } 612 if (strncmp (line, " /** ", 6) == 0 613 && (isdigit (line[6]) || memcmp (line + 6, "VARY", 4) == 0)) 614 line += 2; 615 if (line[0] == '/' && line[1] == '*' && line[2] == '*') 616 { 617 skipping_section = 0; 618 if (strncmp (line, "/** */", 6) == 0) 619 { 620 op = &suffix_text; 621 op->lineno = lineno; 622 } 623 else if (strncmp (line, "/** VARY ", 9) == 0) 624 process_vary (line + 9); 625 else 626 { 627 char * lp; 628 int i, bit, byte; 629 int var_start = 1; 630 631 n_opcodes++; 632 opcodes = 633 (opcode **) realloc (opcodes, n_opcodes * sizeof (opcode *)); 634 op = (opcode *) malloc (sizeof (opcode)); 635 opcodes[n_opcodes - 1] = op; 636 637 op->nbytes = op->dbytes = 0; 638 memset (op->id, 0, sizeof (op->id)); 639 memset (op->var_start, 0, sizeof (op->var_start)); 640 for (i = 0; i < MAX_BYTES; i++) 641 { 642 op->b[i].decodable_mask = 0; 643 op->b[i].decodable_bits = 0; 644 } 645 op->comment = strdup (line); 646 op->comment[strlen (op->comment) - 1] = 0; 647 while (op->comment[0] && isspace (op->comment[0])) 648 op->comment++; 649 op->lineno = lineno; 650 op->nlines = 0; 651 op->lines = 0; 652 op->last_ind = 0; 653 op->semantics_label = 0; 654 op->nvaries = 0; 655 op->vary = 0; 656 657 i = 0; 658 for (lp = line + 4; *lp; lp++) 659 { 660 bit = 7 - (i & 7); 661 byte = i >> 3; 662 663 if (strncmp (lp, "*/", 2) == 0) 664 break; 665 else if ((lp[0] == ' ' && lp[1] == ' ') || (lp[0] == '\t')) 666 { 667 while (*lp == ' ' || *lp == '\t') 668 lp ++; 669 op->syntax = strdup (lp); 670 lp = strstr (op->syntax, "*/"); 671 if (lp) 672 { 673 *lp-- = 0; 674 while ((*lp == ' ' || *lp == '\t') 675 && lp > op->syntax) 676 *lp-- = 0; 677 } 678 break; 679 } 680 else if (*lp == ' ') 681 var_start = 1; 682 else 683 { 684 if (*lp == '0' || *lp == '1') 685 { 686 op->b[byte].decodable_mask |= 1 << bit; 687 var_start = 1; 688 if (op->dbytes < byte + 1) 689 op->dbytes = byte + 1; 690 } 691 else if (var_start) 692 { 693 op->var_start[i] = 1; 694 var_start = 0; 695 if (op->dbytes < byte + 1) 696 op->dbytes = byte + 1; 697 } 698 if (*lp == '1') 699 op->b[byte].decodable_bits |= 1 << bit; 700 701 op->nbytes = byte + 1; 702 op->id[i++] = *lp; 703 } 704 } 705 } 706 } 707 else if (!skipping_section) 708 { 709 op->nlines++; 710 if (op->lines) 711 op->lines = 712 (char **) realloc (op->lines, op->nlines * sizeof (char *)); 713 else 714 op->lines = (char **) malloc (op->nlines * sizeof (char *)); 715 op->lines[op->nlines - 1] = strdup (line); 716 } 717 } 718 719 { 720 int i, j; 721 for (i = 0; i < n_varies; i++) 722 { 723 Vary *v = vary[i]; 724 lprintf (sim_log, "V[%s] %d\n", v->name, v->nlen); 725 for (j = 0; j < v->n_patterns; j++) 726 lprintf (sim_log, " P %02x\n", v->patterns[j]); 727 } 728 } 729 730 for (i = n_opcodes - 2; i >= 0; i--) 731 { 732 if (opcodes[i]->nlines == 0) 733 { 734 opcodes[i]->nlines = opcodes[i + 1]->nlines; 735 opcodes[i]->lines = opcodes[i + 1]->lines; 736 } 737 } 738 739 for (i = 0; i < 256; i++) 740 indirect[i].type = T_unused; 741 742 qsort (opcodes, n_opcodes, sizeof (opcodes[0]), op_cmp); 743 744 vlist = (VaryRef *) malloc (n_varies * sizeof (VaryRef)); 745 746 for (i = 0; i < n_opcodes; i++) 747 { 748 int j, b, v; 749 750 for (j = 0; j < opcodes[i]->nbytes; j++) 751 lprintf (sim_log, "%s ", 752 prmb (opcodes[i]->b[j].decodable_mask, 753 opcodes[i]->b[j].decodable_bits)); 754 lprintf (sim_log, " %s\n", opcodes[i]->comment); 755 756 for (j = 0; j < opcodes[i]->nbytes; j++) 757 { 758 for (b = 0; b < 8; b++) 759 if (isalpha (opcodes[i]->id[j * 8 + b])) 760 for (v = 0; v < n_varies; v++) 761 if (fieldcmp (opcodes[i], j * 8 + b, vary[v]->name)) 762 { 763 int nv = opcodes[i]->nvaries++; 764 if (nv) 765 opcodes[i]->vary = 766 (VaryRef *) realloc (opcodes[i]->vary, 767 (nv + 1) * sizeof (VaryRef)); 768 else 769 opcodes[i]->vary = 770 (VaryRef *) malloc ((nv + 1) * sizeof (VaryRef)); 771 772 opcodes[i]->vary[nv].varyno = v; 773 opcodes[i]->vary[nv].byte = j; 774 opcodes[i]->vary[nv].shift = 8 - b - vary[v]->nlen; 775 lprintf (sim_log, "[vary %s shift %d]\n", 776 vary[v]->name, opcodes[i]->vary[nv].shift); 777 } 778 779 } 780 } 781 782 for (i = 0; i < n_opcodes; i++) 783 { 784 int i2; 785 int bytes = opcodes[i]->dbytes; 786 787 lprintf (sim_log, "\nmask:"); 788 for (i2 = 0; i2 < opcodes[i]->nbytes; i2++) 789 lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_mask); 790 lprintf (sim_log, "%*s%s\n", 13 - 3 * opcodes[i]->nbytes, "", 791 opcodes[i]->comment); 792 793 lprintf (sim_log, "bits:"); 794 for (i2 = 0; i2 < opcodes[i]->nbytes; i2++) 795 lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_bits); 796 lprintf (sim_log, "%*s(%s) %d byte%s\n", 13 - 3 * opcodes[i]->nbytes, 797 "", opcodes[i]->id, bytes, bytes == 1 ? "" : "s"); 798 799 store_opcode_bits (opcodes[i], 0, indirect); 800 } 801 802 dump_lines (&prefix_text, 0, 0); 803 804 emit_indirect (indirect, 0); 805 806 dump_lines (&suffix_text, 0, 0); 807 808 if (sim_log) 809 log_indirect (indirect, 0); 810 811 return errors; 812 } 813
