opcodes/opc2c.c

   1 /* opc2c.c --- generate C opcode decoder code from from .opc file
   2
   3    Copyright (C) 2005-2017 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 }