mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-03 04:12:10 +08:00
727 lines
15 KiB
C
727 lines
15 KiB
C
/* opc2c.c --- generate C simulator code from from .opc file
|
|
|
|
Copyright (C) 2005-2015 Free Software Foundation, Inc.
|
|
Contributed by Red Hat, Inc.
|
|
|
|
This file is part of the GNU simulators.
|
|
|
|
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 "safe-fgets.h"
|
|
|
|
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;
|
|
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 = 0;
|
|
#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++)
|
|
{
|
|
int found = 0;
|
|
int i;
|
|
int ob;
|
|
|
|
if (byte != op->vary[vn].byte)
|
|
continue;
|
|
Vary *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, 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 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, "");
|
|
}
|
|
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);
|
|
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, *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;
|
|
|
|
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 = argv[1];
|
|
in = fopen (argv[1], "r");
|
|
if (!in)
|
|
{
|
|
fprintf (stderr, "Unable to open file %s for reading\n", argv[1]);
|
|
perror ("The error was");
|
|
exit (1);
|
|
}
|
|
|
|
n_opcodes = 0;
|
|
opcodes = (opcode **) malloc (sizeof (opcode *));
|
|
op = &prefix_text;
|
|
op->lineno = 1;
|
|
while ((line = safe_fgets (in)) != 0)
|
|
{
|
|
lineno++;
|
|
if (strncmp (line, " /** ", 6) == 0
|
|
&& (isdigit (line[6]) || memcmp (line + 6, "VARY", 4) == 0))
|
|
line += 2;
|
|
if (line[0] == '/' && line[1] == '*' && line[2] == '*')
|
|
{
|
|
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'))
|
|
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 (*lp == '1')
|
|
op->b[byte].decodable_bits |= 1 << bit;
|
|
|
|
op->nbytes = byte + 1;
|
|
op->id[i++] = *lp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
}
|