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 *
safe_fgets(FILE * f)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
next_varybits(int bits,opcode * op,int byte)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
valid_varybits(int bits,opcode * op,int byte)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 *
prmb(int mask,int bits)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
op_cmp(const void * va,const void * vb)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
dump_lines(opcode * op,int level,Indirect * ind)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
store_opcode_bits(opcode * op,int byte,Indirect * ind)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
emit_indirect(Indirect * ind,int byte)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 *
pv_dup(char * p,char * ep)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
str2mask(char * str,char * ep)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
process_vary(char * line)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
fieldcmp(opcode * op,int bit,char * name)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
log_indirect(Indirect * ind,int byte)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
main(int argc,char ** argv)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