URL
https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk
Subversion Repositories open8_urisc
[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [opcodes/] [opc2c.c] - Rev 35
Go to most recent revision | Compare with Previous | Blame | View Log
/* opc2c.c --- generate C opcode decoder code from from .opc file Copyright (C) 2005, 2007, 2008, 2009 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]; 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++) 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; }
Go to most recent revision | Compare with Previous | Blame | View Log