/* opc2c.c --- generate C opcode decoder code from from .opc file Copyright (C) 2005-2019 Free Software Foundation, Inc. Contributed by Red Hat, Inc. This file is part of the GNU opcode library. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <stdio.h> #include <string.h> #include <ctype.h> #include <stdlib.h> #include <errno.h> #include "libiberty.h" static char * line_buf = NULL; static int line_buf_size = 0; #define LBUFINCR 100 char * safe_fgets (FILE * f) { char * line_ptr; if (line_buf == NULL) { line_buf = (char *) malloc (LBUFINCR); line_buf_size = LBUFINCR; } /* Points to last byte. */ line_ptr = line_buf + line_buf_size - 1; /* So we can see if fgets put a 0 there. */ *line_ptr = 1; if (fgets (line_buf, line_buf_size, f) == 0) return NULL; /* We filled the buffer? */ while (line_ptr[0] == 0 && line_ptr[-1] != '\n') { /* Make the buffer bigger and read more of the line. */ line_buf_size += LBUFINCR; line_buf = (char *) realloc (line_buf, line_buf_size); /* Points to last byte again. */ line_ptr = line_buf + line_buf_size - 1; /* So we can see if fgets put a 0 there. */ *line_ptr = 1; if (fgets (line_buf + line_buf_size - LBUFINCR - 1, LBUFINCR + 1, f) == 0) return NULL; } return line_buf; } static int errors = 0; #define MAX_BYTES 10 typedef struct { int varyno:16; int byte:8; int shift:8; } VaryRef; typedef struct { char nbytes; char dbytes; char id[MAX_BYTES * 8 + 1]; unsigned char var_start[MAX_BYTES * 8 + 1]; struct { unsigned char decodable_mask; unsigned char decodable_bits; } b[MAX_BYTES]; char * comment; char * syntax; int lineno; int nlines; char ** lines; struct Indirect * last_ind; int semantics_label; int nvaries; VaryRef * vary; } opcode; int n_opcodes; opcode ** opcodes; opcode * op; typedef struct { char * name; int nlen; unsigned char mask; int n_patterns; unsigned char * patterns; } Vary; Vary ** vary = 0; int n_varies = 0; unsigned char cur_bits[MAX_BYTES + 1]; const char * orig_filename; FILE * sim_log = NULL; #define lprintf if (sim_log) fprintf opcode prefix_text, suffix_text; typedef enum { T_unused, T_op, T_indirect, T_done } OpType; typedef struct Indirect { OpType type; union { struct Indirect * ind; opcode * op; } u; } Indirect; Indirect indirect[256]; static int next_varybits (int bits, opcode * op, int byte) { int mask = op->b[byte].decodable_mask; int i; for (i = 0; i < 8; i++) if (!(mask & (1 << i))) { if (bits & (1 << i)) { bits &= ~(1 << i); } else { bits |= (1 << i); return bits; } } return 0; } static int valid_varybits (int bits, opcode * op, int byte) { if (op->nvaries) { int vn; for (vn = 0; vn < op->nvaries; vn++) { Vary * v; int found = 0; int i; int ob; if (byte != op->vary[vn].byte) continue; v = vary[op->vary[vn].varyno]; ob = (bits >> op->vary[vn].shift) & v->mask; lprintf (sim_log, "varybits: vary %s ob %x\n", v->name, ob); for (i = 0; i < v->n_patterns; i++) if (ob == v->patterns[i]) { lprintf (sim_log, " found at %d\n", i); found = 1; break; } if (!found) return 0; } } return 1; } char * prmb (int mask, int bits) { static char buf[8][30]; static int bn = 0; char * bp; bn = (bn + 1) % 8; bp = buf[bn]; int i; for (i = 0; i < 8; i++) { int bit = 0x80 >> i; if (!(mask & bit)) *bp++ = '-'; else if (bits & bit) *bp++ = '1'; else *bp++ = '0'; if (i % 4 == 3) *bp++ = ' '; } *--bp = 0; return buf[bn]; } static int op_cmp (const void *va, const void *vb) { const opcode * a = *(const opcode **) va; const opcode * b = *(const opcode **) vb; if (a->nbytes != b->nbytes) return a->nbytes - b->nbytes; return strcmp (a->id, b->id); } void dump_lines (opcode * op, int level, Indirect * ind) { char * varnames[40]; int i, vn = 0; if (op->semantics_label) { printf ("%*sgoto op_semantics_%d;\n", level, "", op->semantics_label); return; } if (ind != op->last_ind) { static int labelno = 0; labelno++; printf ("%*sop_semantics_%d:\n", level, "", labelno); op->semantics_label = labelno; } if (op->comment) { level += 2; printf ("%*s{\n", level, ""); printf ("%*s %s\n", level, "", op->comment); } for (i = 0; i < op->nbytes * 8;) { if (isalpha (op->id[i])) { int byte = i >> 3; int mask = 0; int shift = 0; char name[33]; char * np = name; while (op->id[i] && isalpha (op->id[i])) { mask = (mask << 1) | 1; shift = 7 - (i & 7); *np++ = op->id[i++]; if (op->var_start[i]) break; } *np = 0; varnames[vn++] = strdup (name); printf ("#line %d \"%s\"\n", op->lineno + 1, orig_filename); if (mask & ~0xff) { fprintf (stderr, "Error: variable %s spans bytes: %s\n", name, op->comment); errors++; } else if (shift && (mask != 0xff)) printf ("%*s int %s AU = (op[%d] >> %d) & 0x%02x;\n", level, "", name, byte, shift, mask); else if (mask != 0xff) printf ("%*s int %s AU = op[%d] & 0x%02x;\n", level, "", name, byte, mask); else printf ("%*s int %s AU = op[%d];\n", level, "", name, byte); } else i++; } if (op->comment) { printf ("%*s if (trace)\n", level, ""); printf ("%*s {\n", level, ""); printf ("%*s printf (\"\\033[33m%%s\\033[0m ", level, ""); for (i = 0; i < op->nbytes; i++) printf (" %%02x"); printf ("\\n\""); printf (",\n%*s \"%s\"", level, "", op->comment); for (i = 0; i < op->nbytes; i++) { if (i == 0) printf (",\n%*s op[%d]", level, "", i); else printf (", op[%d]", i); } printf (");\n"); for (i = 0; i < vn; i++) printf ("%*s printf (\" %s = 0x%%x%s\", %s);\n", level, "", varnames[i], (i < vn - 1) ? "," : "\\n", varnames[i]); printf ("%*s }\n", level, ""); } if (op->syntax) printf ("%*s SYNTAX(\"%s\");\n", level, "", op->syntax); printf ("#line %d \"%s\"\n", op->lineno + 1, orig_filename); for (i = 0; i < op->nlines; i++) if (op->lines[i][0] == '\n') printf ("%s", op->lines[i]); else printf ("%*s%s", level, "", op->lines[i]); if (op->comment) printf ("%*s}\n", level, ""); } void store_opcode_bits (opcode * op, int byte, Indirect * ind) { int bits = op->b[byte].decodable_bits; do { if (!valid_varybits (bits, op, byte)) continue; switch (ind[bits].type) { case T_unused: if (byte == op->dbytes - 1) { ind[bits].type = T_op; ind[bits].u.op = op; op->last_ind = ind; break; } else { int i2; ind[bits].type = T_indirect; ind[bits].u.ind = (Indirect *) malloc (256 * sizeof (Indirect)); for (i2 = 0; i2 < 256; i2++) ind[bits].u.ind[i2].type = T_unused; store_opcode_bits (op, byte + 1, ind[bits].u.ind); } break; case T_indirect: if (byte < op->dbytes - 1) store_opcode_bits (op, byte + 1, ind[bits].u.ind); break; case T_op: break; case T_done: break; } } while ((bits = next_varybits (bits, op, byte)) != 0); } void emit_indirect (Indirect * ind, int byte) { int unsup = 0; int j, n, mask; mask = 0; for (j = 0; j < 256; j++) { switch (ind[j].type) { case T_indirect: mask = 0xff; break; case T_op: mask |= ind[j].u.op->b[byte].decodable_mask; break; case T_done: case T_unused: break; } } printf ("%*s GETBYTE ();\n", byte * 6, ""); printf ("%*s switch (op[%d] & 0x%02x)\n", byte * 6, "", byte, mask); printf ("%*s {\n", byte * 6, ""); for (j = 0; j < 256; j++) if ((j & ~mask) == 0) { switch (ind[j].type) { case T_done: break; case T_unused: unsup = 1; break; case T_op: for (n = j; n < 256; n++) if ((n & ~mask) == 0 && ind[n].type == T_op && ind[n].u.op == ind[j].u.op) { ind[n].type = T_done; printf ("%*s case 0x%02x:\n", byte * 6, "", n); } for (n = byte; n < ind[j].u.op->nbytes - 1; n++) printf ("%*s GETBYTE();\n", byte * 6, ""); dump_lines (ind[j].u.op, byte * 6 + 6, ind); printf ("%*s break;\n", byte * 6, ""); break; case T_indirect: printf ("%*s case 0x%02x:\n", byte * 6, "", j); emit_indirect (ind[j].u.ind, byte + 1); printf ("%*s break;\n", byte * 6, ""); break; } } if (unsup) printf ("%*s default: UNSUPPORTED(); break;\n", byte * 6, ""); printf ("%*s }\n", byte * 6, ""); } static char * pv_dup (char * p, char * ep) { int n = ep - p; char *rv = (char *) malloc (n + 1); memcpy (rv, p, n); rv[n] = 0; return rv; } static unsigned char str2mask (char * str, char * ep) { unsigned char rv = 0; while (str < ep) { rv *= 2; if (*str == '1') rv += 1; str++; } return rv; } static void process_vary (char * line) { char * cp; char * ep; Vary * v = (Vary *) malloc (sizeof (Vary)); n_varies++; if (vary) vary = (Vary **) realloc (vary, n_varies * sizeof (Vary *)); else vary = (Vary **) malloc (n_varies * sizeof (Vary *)); vary[n_varies - 1] = v; cp = line; for (cp = line; isspace (*cp); cp++); for (ep = cp; *ep && !isspace (*ep); ep++); v->name = pv_dup (cp, ep); v->nlen = strlen (v->name); v->mask = (1 << v->nlen) - 1; v->n_patterns = 0; v->patterns = (unsigned char *) malloc (1); while (1) { for (cp = ep; isspace (*cp); cp++); if (!isdigit (*cp)) break; for (ep = cp; *ep && !isspace (*ep); ep++); v->n_patterns++; v->patterns = (unsigned char *) realloc (v->patterns, v->n_patterns); v->patterns[v->n_patterns - 1] = str2mask (cp, ep); } } static int fieldcmp (opcode * op, int bit, char *name) { int n = strlen (name); if (memcmp (op->id + bit, name, n) == 0 && (!isalpha (op->id[bit + n]) || op->var_start[bit + n])) return 1; return 0; } static void log_indirect (Indirect * ind, int byte) { int i, j; char * last_c = 0; for (i = 0; i < 256; i++) { for (j = 0; j < byte; j++) fprintf (sim_log, "%s ", prmb (255, cur_bits[j])); fprintf (sim_log, "%s ", prmb (255, i)); switch (ind[i].type) { case T_op: case T_done: if (last_c && (ind[i].u.op->comment == last_c)) fprintf (sim_log, "''\n"); else fprintf (sim_log, "%s\n", ind[i].u.op->comment); last_c = ind[i].u.op->comment; break; case T_unused: fprintf (sim_log, "unused\n"); break; case T_indirect: fprintf (sim_log, "indirect\n"); cur_bits[byte] = i; log_indirect (ind[i].u.ind, byte + 1); last_c = 0; break; } } } int main (int argc, char ** argv) { char * line; FILE * in; int lineno = 0; int i; VaryRef * vlist; int skipping_section = 0; if (argc < 2) { fprintf (stderr, "usage: opc2c infile.opc > outfile.opc\n"); exit (1); } orig_filename = lbasename (argv[1]); in = fopen (argv[1], "r"); if (!in) { fprintf (stderr, "Unable to open file %s for reading: %s\n", argv[1], xstrerror (errno)); exit (1); } n_opcodes = 0; opcodes = (opcode **) malloc (sizeof (opcode *)); op = &prefix_text; op->lineno = 0; while ((line = safe_fgets (in)) != 0) { lineno++; if (strncmp (line, "/*?* ", 5) == 0) { skipping_section = 1; continue; } if (strncmp (line, " /** ", 6) == 0 && (isdigit (line[6]) || memcmp (line + 6, "VARY", 4) == 0)) line += 2; if (line[0] == '/' && line[1] == '*' && line[2] == '*') { skipping_section = 0; if (strncmp (line, "/** */", 6) == 0) { op = &suffix_text; op->lineno = lineno; } else if (strncmp (line, "/** VARY ", 9) == 0) process_vary (line + 9); else { char * lp; int i, bit, byte; int var_start = 1; n_opcodes++; opcodes = (opcode **) realloc (opcodes, n_opcodes * sizeof (opcode *)); op = (opcode *) malloc (sizeof (opcode)); opcodes[n_opcodes - 1] = op; op->nbytes = op->dbytes = 0; memset (op->id, 0, sizeof (op->id)); memset (op->var_start, 0, sizeof (op->var_start)); for (i = 0; i < MAX_BYTES; i++) { op->b[i].decodable_mask = 0; op->b[i].decodable_bits = 0; } op->comment = strdup (line); op->comment[strlen (op->comment) - 1] = 0; while (op->comment[0] && isspace (op->comment[0])) op->comment++; op->lineno = lineno; op->nlines = 0; op->lines = 0; op->last_ind = 0; op->semantics_label = 0; op->nvaries = 0; op->vary = 0; i = 0; for (lp = line + 4; *lp; lp++) { bit = 7 - (i & 7); byte = i >> 3; if (strncmp (lp, "*/", 2) == 0) break; else if ((lp[0] == ' ' && lp[1] == ' ') || (lp[0] == '\t')) { while (*lp == ' ' || *lp == '\t') lp ++; op->syntax = strdup (lp); lp = strstr (op->syntax, "*/"); if (lp) { *lp-- = 0; while ((*lp == ' ' || *lp == '\t') && lp > op->syntax) *lp-- = 0; } break; } else if (*lp == ' ') var_start = 1; else { if (*lp == '0' || *lp == '1') { op->b[byte].decodable_mask |= 1 << bit; var_start = 1; if (op->dbytes < byte + 1) op->dbytes = byte + 1; } else if (var_start) { op->var_start[i] = 1; var_start = 0; if (op->dbytes < byte + 1) op->dbytes = byte + 1; } if (*lp == '1') op->b[byte].decodable_bits |= 1 << bit; op->nbytes = byte + 1; op->id[i++] = *lp; } } } } else if (!skipping_section) { op->nlines++; if (op->lines) op->lines = (char **) realloc (op->lines, op->nlines * sizeof (char *)); else op->lines = (char **) malloc (op->nlines * sizeof (char *)); op->lines[op->nlines - 1] = strdup (line); } } { int i, j; for (i = 0; i < n_varies; i++) { Vary *v = vary[i]; lprintf (sim_log, "V[%s] %d\n", v->name, v->nlen); for (j = 0; j < v->n_patterns; j++) lprintf (sim_log, " P %02x\n", v->patterns[j]); } } for (i = n_opcodes - 2; i >= 0; i--) { if (opcodes[i]->nlines == 0) { opcodes[i]->nlines = opcodes[i + 1]->nlines; opcodes[i]->lines = opcodes[i + 1]->lines; } } for (i = 0; i < 256; i++) indirect[i].type = T_unused; qsort (opcodes, n_opcodes, sizeof (opcodes[0]), op_cmp); vlist = (VaryRef *) malloc (n_varies * sizeof (VaryRef)); for (i = 0; i < n_opcodes; i++) { int j, b, v; for (j = 0; j < opcodes[i]->nbytes; j++) lprintf (sim_log, "%s ", prmb (opcodes[i]->b[j].decodable_mask, opcodes[i]->b[j].decodable_bits)); lprintf (sim_log, " %s\n", opcodes[i]->comment); for (j = 0; j < opcodes[i]->nbytes; j++) { for (b = 0; b < 8; b++) if (isalpha (opcodes[i]->id[j * 8 + b])) for (v = 0; v < n_varies; v++) if (fieldcmp (opcodes[i], j * 8 + b, vary[v]->name)) { int nv = opcodes[i]->nvaries++; if (nv) opcodes[i]->vary = (VaryRef *) realloc (opcodes[i]->vary, (nv + 1) * sizeof (VaryRef)); else opcodes[i]->vary = (VaryRef *) malloc ((nv + 1) * sizeof (VaryRef)); opcodes[i]->vary[nv].varyno = v; opcodes[i]->vary[nv].byte = j; opcodes[i]->vary[nv].shift = 8 - b - vary[v]->nlen; lprintf (sim_log, "[vary %s shift %d]\n", vary[v]->name, opcodes[i]->vary[nv].shift); } } } for (i = 0; i < n_opcodes; i++) { int i2; int bytes = opcodes[i]->dbytes; lprintf (sim_log, "\nmask:"); for (i2 = 0; i2 < opcodes[i]->nbytes; i2++) lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_mask); lprintf (sim_log, "%*s%s\n", 13 - 3 * opcodes[i]->nbytes, "", opcodes[i]->comment); lprintf (sim_log, "bits:"); for (i2 = 0; i2 < opcodes[i]->nbytes; i2++) lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_bits); lprintf (sim_log, "%*s(%s) %d byte%s\n", 13 - 3 * opcodes[i]->nbytes, "", opcodes[i]->id, bytes, bytes == 1 ? "" : "s"); store_opcode_bits (opcodes[i], 0, indirect); } printf ("/* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */\n"); dump_lines (&prefix_text, 0, 0); emit_indirect (indirect, 0); dump_lines (&suffix_text, 0, 0); if (sim_log) log_indirect (indirect, 0); return errors; }