| /* opc2c.c --- generate C opcode decoder code from from .opc file |
| |
| Copyright (C) 2005-2016 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 && strcmp (argv[1], "-l") == 0) |
| { |
| sim_log = fopen (argv[2], "w"); |
| fprintf (stderr, "sim_log: %s\n", argv[2]); |
| argc -= 2; |
| argv += 2; |
| } |
| |
| 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); |
| } |
| |
| 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; |
| } |