sim/m32c/opc2c.c

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