#include "bconfig.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "rtl.h"
#include "errors.h"
#include "gensupport.h"
#define MAX_MAX_OPERANDS 40
static int n_occurrences (int, const char *);
static const char *strip_whitespace (const char *);
static int next_code_number;
static int next_index_number;
static int next_operand_number = 1;
struct operand_data
{
struct operand_data *next;
int index;
const char *predicate;
const char *constraint;
enum machine_mode mode;
unsigned char n_alternatives;
char address_p;
char strict_low;
char eliminable;
char seen;
};
static struct operand_data null_operand =
{
0, 0, "", "", VOIDmode, 0, 0, 0, 0, 0
};
static struct operand_data *odata = &null_operand;
static struct operand_data **odata_end = &null_operand.next;
#define INSN_OUTPUT_FORMAT_NONE 0
#define INSN_OUTPUT_FORMAT_SINGLE 1
#define INSN_OUTPUT_FORMAT_MULTI 2
#define INSN_OUTPUT_FORMAT_FUNCTION 3
struct data
{
struct data *next;
const char *name;
const char *template;
int code_number;
int index_number;
const char *filename;
int lineno;
int n_operands;
int n_dups;
int n_alternatives;
int operand_number;
int output_format;
struct operand_data operand[MAX_MAX_OPERANDS];
};
static struct data *idata, **idata_end = &idata;
static void output_prologue (void);
static void output_operand_data (void);
static void output_insn_data (void);
static void output_get_insn_name (void);
static void scan_operands (struct data *, rtx, int, int);
static int compare_operands (struct operand_data *,
struct operand_data *);
static void place_operands (struct data *);
static void process_template (struct data *, const char *);
static void validate_insn_alternatives (struct data *);
static void validate_insn_operands (struct data *);
static void gen_insn (rtx, int);
static void gen_peephole (rtx, int);
static void gen_expand (rtx, int);
static void gen_split (rtx, int);
static void check_constraint_len (void);
static int constraint_len (const char *, int);
const char *
get_insn_name (int index)
{
static char buf[100];
struct data *i, *last_named = NULL;
for (i = idata; i ; i = i->next)
{
if (i->index_number == index)
return i->name;
if (i->name)
last_named = i;
}
if (last_named)
sprintf(buf, "%s+%d", last_named->name, index - last_named->index_number);
else
sprintf(buf, "insn %d", index);
return buf;
}
static void
output_prologue (void)
{
printf ("/* Generated automatically by the program `genoutput'\n\
from the machine description file `md'. */\n\n");
printf ("#include \"config.h\"\n");
printf ("#include \"system.h\"\n");
printf ("#include \"coretypes.h\"\n");
printf ("#include \"tm.h\"\n");
printf ("#include \"flags.h\"\n");
printf ("#include \"ggc.h\"\n");
printf ("#include \"rtl.h\"\n");
printf ("#include \"expr.h\"\n");
printf ("#include \"insn-codes.h\"\n");
printf ("#include \"tm_p.h\"\n");
printf ("#include \"function.h\"\n");
printf ("#include \"regs.h\"\n");
printf ("#include \"hard-reg-set.h\"\n");
printf ("#include \"real.h\"\n");
printf ("#include \"insn-config.h\"\n\n");
printf ("#include \"conditions.h\"\n");
printf ("#include \"insn-attr.h\"\n\n");
printf ("#include \"recog.h\"\n\n");
printf ("#include \"toplev.h\"\n");
printf ("#include \"output.h\"\n");
printf ("#include \"target.h\"\n");
}
static void
output_operand_data (void)
{
struct operand_data *d;
printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n");
for (d = odata; d; d = d->next)
{
printf (" {\n");
printf (" %s,\n",
d->predicate && d->predicate[0] ? d->predicate : "0");
printf (" \"%s\",\n", d->constraint ? d->constraint : "");
printf (" %smode,\n", GET_MODE_NAME (d->mode));
printf (" %d,\n", d->strict_low);
printf (" %d\n", d->eliminable);
printf(" },\n");
}
printf("};\n\n\n");
}
static void
output_insn_data (void)
{
struct data *d;
int name_offset = 0;
int next_name_offset;
const char * last_name = 0;
const char * next_name = 0;
struct data *n;
for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++)
if (n->name)
{
next_name = n->name;
break;
}
printf ("#if GCC_VERSION >= 2007\n__extension__\n#endif\n");
printf ("\nconst struct insn_data insn_data[] = \n{\n");
for (d = idata; d; d = d->next)
{
printf (" /* %s:%d */\n", d->filename, d->lineno);
printf (" {\n");
if (d->name)
{
printf (" \"%s\",\n", d->name);
name_offset = 0;
last_name = d->name;
next_name = 0;
for (n = d->next, next_name_offset = 1; n;
n = n->next, next_name_offset++)
{
if (n->name)
{
next_name = n->name;
break;
}
}
}
else
{
name_offset++;
if (next_name && (last_name == 0
|| name_offset > next_name_offset / 2))
printf (" \"%s-%d\",\n", next_name,
next_name_offset - name_offset);
else
printf (" \"%s+%d\",\n", last_name, name_offset);
}
switch (d->output_format)
{
case INSN_OUTPUT_FORMAT_NONE:
printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
printf (" { 0 },\n");
printf ("#else\n");
printf (" { 0, 0, 0 },\n");
printf ("#endif\n");
break;
case INSN_OUTPUT_FORMAT_SINGLE:
{
const char *p = d->template;
char prev = 0;
printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
printf (" { .single =\n");
printf ("#else\n");
printf (" {\n");
printf ("#endif\n");
printf (" \"");
while (*p)
{
if (IS_VSPACE (*p) && prev != '\\')
{
if (*p == '\n' && prev != '\r')
printf ("\\n\\\n");
}
else
putchar (*p);
prev = *p;
++p;
}
printf ("\",\n");
printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
printf (" },\n");
printf ("#else\n");
printf (" 0, 0 },\n");
printf ("#endif\n");
}
break;
case INSN_OUTPUT_FORMAT_MULTI:
printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
printf (" { .multi = output_%d },\n", d->code_number);
printf ("#else\n");
printf (" { 0, output_%d, 0 },\n", d->code_number);
printf ("#endif\n");
break;
case INSN_OUTPUT_FORMAT_FUNCTION:
printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
printf (" { .function = output_%d },\n", d->code_number);
printf ("#else\n");
printf (" { 0, 0, output_%d },\n", d->code_number);
printf ("#endif\n");
break;
default:
gcc_unreachable ();
}
if (d->name && d->name[0] != '*')
printf (" (insn_gen_fn) gen_%s,\n", d->name);
else
printf (" 0,\n");
printf (" &operand_data[%d],\n", d->operand_number);
printf (" %d,\n", d->n_operands);
printf (" %d,\n", d->n_dups);
printf (" %d,\n", d->n_alternatives);
printf (" %d\n", d->output_format);
printf(" },\n");
}
printf ("};\n\n\n");
}
static void
output_get_insn_name (void)
{
printf ("const char *\n");
printf ("get_insn_name (int code)\n");
printf ("{\n");
printf (" if (code == NOOP_MOVE_INSN_CODE)\n");
printf (" return \"NOOP_MOVE\";\n");
printf (" else\n");
printf (" return insn_data[code].name;\n");
printf ("}\n");
}
static int max_opno;
static int num_dups;
static void
scan_operands (struct data *d, rtx part, int this_address_p,
int this_strict_low)
{
int i, j;
const char *format_ptr;
int opno;
if (part == 0)
return;
switch (GET_CODE (part))
{
case MATCH_OPERAND:
opno = XINT (part, 0);
if (opno > max_opno)
max_opno = opno;
if (max_opno >= MAX_MAX_OPERANDS)
{
message_with_line (d->lineno,
"maximum number of operands exceeded");
have_error = 1;
return;
}
if (d->operand[opno].seen)
{
message_with_line (d->lineno,
"repeated operand number %d\n", opno);
have_error = 1;
}
d->operand[opno].seen = 1;
d->operand[opno].mode = GET_MODE (part);
d->operand[opno].strict_low = this_strict_low;
d->operand[opno].predicate = XSTR (part, 1);
d->operand[opno].constraint = strip_whitespace (XSTR (part, 2));
d->operand[opno].n_alternatives
= n_occurrences (',', d->operand[opno].constraint) + 1;
d->operand[opno].address_p = this_address_p;
d->operand[opno].eliminable = 1;
return;
case MATCH_SCRATCH:
opno = XINT (part, 0);
if (opno > max_opno)
max_opno = opno;
if (max_opno >= MAX_MAX_OPERANDS)
{
message_with_line (d->lineno,
"maximum number of operands exceeded");
have_error = 1;
return;
}
if (d->operand[opno].seen)
{
message_with_line (d->lineno,
"repeated operand number %d\n", opno);
have_error = 1;
}
d->operand[opno].seen = 1;
d->operand[opno].mode = GET_MODE (part);
d->operand[opno].strict_low = 0;
d->operand[opno].predicate = "scratch_operand";
d->operand[opno].constraint = strip_whitespace (XSTR (part, 1));
d->operand[opno].n_alternatives
= n_occurrences (',', d->operand[opno].constraint) + 1;
d->operand[opno].address_p = 0;
d->operand[opno].eliminable = 0;
return;
case MATCH_OPERATOR:
case MATCH_PARALLEL:
opno = XINT (part, 0);
if (opno > max_opno)
max_opno = opno;
if (max_opno >= MAX_MAX_OPERANDS)
{
message_with_line (d->lineno,
"maximum number of operands exceeded");
have_error = 1;
return;
}
if (d->operand[opno].seen)
{
message_with_line (d->lineno,
"repeated operand number %d\n", opno);
have_error = 1;
}
d->operand[opno].seen = 1;
d->operand[opno].mode = GET_MODE (part);
d->operand[opno].strict_low = 0;
d->operand[opno].predicate = XSTR (part, 1);
d->operand[opno].constraint = 0;
d->operand[opno].address_p = 0;
d->operand[opno].eliminable = 0;
for (i = 0; i < XVECLEN (part, 2); i++)
scan_operands (d, XVECEXP (part, 2, i), 0, 0);
return;
case MATCH_DUP:
case MATCH_OP_DUP:
case MATCH_PAR_DUP:
++num_dups;
break;
case ADDRESS:
scan_operands (d, XEXP (part, 0), 1, 0);
return;
case STRICT_LOW_PART:
scan_operands (d, XEXP (part, 0), 0, 1);
return;
default:
break;
}
format_ptr = GET_RTX_FORMAT (GET_CODE (part));
for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
switch (*format_ptr++)
{
case 'e':
case 'u':
scan_operands (d, XEXP (part, i), 0, 0);
break;
case 'E':
if (XVEC (part, i) != NULL)
for (j = 0; j < XVECLEN (part, i); j++)
scan_operands (d, XVECEXP (part, i, j), 0, 0);
break;
}
}
static int
compare_operands (struct operand_data *d0, struct operand_data *d1)
{
const char *p0, *p1;
p0 = d0->predicate;
if (!p0)
p0 = "";
p1 = d1->predicate;
if (!p1)
p1 = "";
if (strcmp (p0, p1) != 0)
return 0;
p0 = d0->constraint;
if (!p0)
p0 = "";
p1 = d1->constraint;
if (!p1)
p1 = "";
if (strcmp (p0, p1) != 0)
return 0;
if (d0->mode != d1->mode)
return 0;
if (d0->strict_low != d1->strict_low)
return 0;
if (d0->eliminable != d1->eliminable)
return 0;
return 1;
}
static void
place_operands (struct data *d)
{
struct operand_data *od, *od2;
int i;
if (d->n_operands == 0)
{
d->operand_number = 0;
return;
}
for (od = odata, i = 0; od; od = od->next, i = 0)
if (compare_operands (od, &d->operand[0]))
{
od2 = od->next;
i = 1;
while (1)
{
if (i == d->n_operands)
goto full_match;
if (od2 == NULL)
goto partial_match;
if (! compare_operands (od2, &d->operand[i]))
break;
++i, od2 = od2->next;
}
}
partial_match:
d->operand_number = next_operand_number - i;
for (; i < d->n_operands; ++i)
{
od2 = &d->operand[i];
*odata_end = od2;
odata_end = &od2->next;
od2->index = next_operand_number++;
}
*odata_end = NULL;
return;
full_match:
d->operand_number = od->index;
return;
}
static void
process_template (struct data *d, const char *template)
{
const char *cp;
int i;
if (template[0] == '*')
{
d->template = 0;
d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
puts ("\nstatic const char *");
printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED)\n",
d->code_number);
puts ("{");
puts (template + 1);
puts ("}");
}
else if (template[0] == '@')
{
d->template = 0;
d->output_format = INSN_OUTPUT_FORMAT_MULTI;
printf ("\nstatic const char * const output_%d[] = {\n", d->code_number);
for (i = 0, cp = &template[1]; *cp; )
{
const char *ep, *sp;
while (ISSPACE (*cp))
cp++;
printf (" \"");
for (ep = sp = cp; !IS_VSPACE (*ep) && *ep != '\0'; ++ep)
if (!ISSPACE (*ep))
sp = ep + 1;
if (sp != ep)
message_with_line (d->lineno,
"trailing whitespace in output template");
while (cp < sp)
{
putchar (*cp);
cp++;
}
printf ("\",\n");
i++;
}
if (i == 1)
message_with_line (d->lineno,
"'@' is redundant for output template with single alternative");
if (i != d->n_alternatives)
{
message_with_line (d->lineno,
"wrong number of alternatives in the output template");
have_error = 1;
}
printf ("};\n");
}
else
{
d->template = template;
d->output_format = INSN_OUTPUT_FORMAT_SINGLE;
}
}
static void
validate_insn_alternatives (struct data *d)
{
int n = 0, start;
for (start = 0; start < d->n_operands; start++)
if (d->operand[start].n_alternatives > 0)
{
int len, i;
const char *p;
char c;
int which_alternative = 0;
int alternative_count_unsure = 0;
for (p = d->operand[start].constraint; (c = *p); p += len)
{
len = CONSTRAINT_LEN (c, p);
if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c)))
{
message_with_line (d->lineno,
"invalid length %d for char '%c' in alternative %d of operand %d",
len, c, which_alternative, start);
len = 1;
have_error = 1;
}
if (c == ',')
{
which_alternative++;
continue;
}
for (i = 1; i < len; i++)
if (p[i] == '\0')
{
message_with_line (d->lineno,
"NUL in alternative %d of operand %d",
which_alternative, start);
alternative_count_unsure = 1;
break;
}
else if (strchr (",#*", p[i]))
{
message_with_line (d->lineno,
"'%c' in alternative %d of operand %d",
p[i], which_alternative, start);
alternative_count_unsure = 1;
}
}
if (alternative_count_unsure)
have_error = 1;
else if (n == 0)
n = d->operand[start].n_alternatives;
else if (n != d->operand[start].n_alternatives)
{
message_with_line (d->lineno,
"wrong number of alternatives in operand %d",
start);
have_error = 1;
}
}
d->n_alternatives = n;
}
static void
validate_insn_operands (struct data *d)
{
int i;
for (i = 0; i < d->n_operands; ++i)
if (d->operand[i].seen == 0)
{
message_with_line (d->lineno, "missing operand %d", i);
have_error = 1;
}
}
static void
gen_insn (rtx insn, int lineno)
{
struct data *d = xmalloc (sizeof (struct data));
int i;
d->code_number = next_code_number;
d->index_number = next_index_number;
d->filename = read_rtx_filename;
d->lineno = lineno;
if (XSTR (insn, 0)[0])
d->name = XSTR (insn, 0);
else
d->name = 0;
d->next = 0;
*idata_end = d;
idata_end = &d->next;
max_opno = -1;
num_dups = 0;
memset (d->operand, 0, sizeof (d->operand));
for (i = 0; i < XVECLEN (insn, 1); i++)
scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
d->n_operands = max_opno + 1;
d->n_dups = num_dups;
check_constraint_len ();
validate_insn_operands (d);
validate_insn_alternatives (d);
place_operands (d);
process_template (d, XTMPL (insn, 3));
}
static void
gen_peephole (rtx peep, int lineno)
{
struct data *d = xmalloc (sizeof (struct data));
int i;
d->code_number = next_code_number;
d->index_number = next_index_number;
d->filename = read_rtx_filename;
d->lineno = lineno;
d->name = 0;
d->next = 0;
*idata_end = d;
idata_end = &d->next;
max_opno = -1;
num_dups = 0;
memset (d->operand, 0, sizeof (d->operand));
for (i = 0; i < XVECLEN (peep, 0); i++)
scan_operands (d, XVECEXP (peep, 0, i), 0, 0);
d->n_operands = max_opno + 1;
d->n_dups = 0;
validate_insn_alternatives (d);
place_operands (d);
process_template (d, XTMPL (peep, 2));
}
static void
gen_expand (rtx insn, int lineno)
{
struct data *d = xmalloc (sizeof (struct data));
int i;
d->code_number = next_code_number;
d->index_number = next_index_number;
d->filename = read_rtx_filename;
d->lineno = lineno;
if (XSTR (insn, 0)[0])
d->name = XSTR (insn, 0);
else
d->name = 0;
d->next = 0;
*idata_end = d;
idata_end = &d->next;
max_opno = -1;
num_dups = 0;
memset (d->operand, 0, sizeof (d->operand));
if (XVEC (insn, 1))
for (i = 0; i < XVECLEN (insn, 1); i++)
scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
d->n_operands = max_opno + 1;
d->n_dups = num_dups;
d->template = 0;
d->output_format = INSN_OUTPUT_FORMAT_NONE;
validate_insn_alternatives (d);
place_operands (d);
}
static void
gen_split (rtx split, int lineno)
{
struct data *d = xmalloc (sizeof (struct data));
int i;
d->code_number = next_code_number;
d->index_number = next_index_number;
d->filename = read_rtx_filename;
d->lineno = lineno;
d->name = 0;
d->next = 0;
*idata_end = d;
idata_end = &d->next;
max_opno = -1;
num_dups = 0;
memset (d->operand, 0, sizeof (d->operand));
for (i = 0; i < XVECLEN (split, 0); i++)
scan_operands (d, XVECEXP (split, 0, i), 0, 0);
d->n_operands = max_opno + 1;
d->n_dups = 0;
d->n_alternatives = 0;
d->template = 0;
d->output_format = INSN_OUTPUT_FORMAT_NONE;
place_operands (d);
}
extern int main (int, char **);
int
main (int argc, char **argv)
{
rtx desc;
progname = "genoutput";
if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
return (FATAL_EXIT_CODE);
output_prologue ();
next_code_number = 0;
next_index_number = 0;
while (1)
{
int line_no;
desc = read_md_rtx (&line_no, &next_code_number);
if (desc == NULL)
break;
if (GET_CODE (desc) == DEFINE_INSN)
gen_insn (desc, line_no);
if (GET_CODE (desc) == DEFINE_PEEPHOLE)
gen_peephole (desc, line_no);
if (GET_CODE (desc) == DEFINE_EXPAND)
gen_expand (desc, line_no);
if (GET_CODE (desc) == DEFINE_SPLIT
|| GET_CODE (desc) == DEFINE_PEEPHOLE2)
gen_split (desc, line_no);
next_index_number++;
}
printf("\n\n");
output_operand_data ();
output_insn_data ();
output_get_insn_name ();
fflush (stdout);
return (ferror (stdout) != 0 || have_error
? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}
static int
n_occurrences (int c, const char *s)
{
int n = 0;
if (s == 0 || *s == '\0')
return -1;
while (*s)
n += (*s++ == c);
return n;
}
static const char *
strip_whitespace (const char *s)
{
char *p, *q;
char ch;
if (s == 0)
return 0;
p = q = xmalloc (strlen (s) + 1);
while ((ch = *s++) != '\0')
if (! ISSPACE (ch))
*p++ = ch;
*p = '\0';
return q;
}
static void
check_constraint_len (void)
{
const char *p;
int d;
for (p = ",#*+=&%!1234567890"; *p; p++)
for (d = -9; d < 9; d++)
gcc_assert (constraint_len (p, d) == d);
}
static int
constraint_len (const char *p, int genoutput_default_constraint_len)
{
gcc_assert (DEFAULT_CONSTRAINT_LEN (*p, p) == 1);
#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
#undef DEFAULT_CONSTRAINT_LEN
#define DEFAULT_CONSTRAINT_LEN(C,STR) \
((C) != *p || STR != p ? -1 : genoutput_default_constraint_len)
return CONSTRAINT_LEN (*p, p);
#undef DEFAULT_CONSTRAINT_LEN
#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
}