X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgenoutput.c;h=4eac581872965e30c926c23e72990939cb8d8c00;hb=7c568de5f7d7fb8852c9d1808236f2a8c2d45ecd;hp=c288107e9a4656e36ce86736d0cd0eda0fd47bb2;hpb=929efc7f759e1f5725c3e6349f92c28193d8f432;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/genoutput.c b/gcc/genoutput.c index c288107e9a4..4eac5818729 100644 --- a/gcc/genoutput.c +++ b/gcc/genoutput.c @@ -1,23 +1,23 @@ /* Generate code from to output assembler insns as recognized from rtl. - Copyright (C) 1987, 88, 92, 94-95, 97-98, 1999 - Free Software Foundation, Inc. + Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002, + 2003, 2004, 2005 Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -GNU CC 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 2, or (at your option) -any later version. +GCC 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 2, or (at your option) any later +version. -GNU CC 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. +GCC 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 GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. */ /* This program reads the machine description for the compiler target machine @@ -54,12 +54,10 @@ Boston, MA 02111-1307, USA. */ a. `predicate', an int-valued function, is the match_operand predicate for this operand. - b. `constraint' is the constraint for this operand. This exists - only if register constraints appear in match_operand rtx's. + b. `constraint' is the constraint for this operand. c. `address_p' indicates that the operand appears within ADDRESS - rtx's. This exists only if there are *no* register constraints - in the match_operand rtx's. + rtx's. d. `mode' is the machine mode that that operand is supposed to have. @@ -85,11 +83,13 @@ Boston, MA 02111-1307, USA. */ insn_data[24].template to be "clrd %0", and insn_data[24].n_operands to be 1. */ -#include "hconfig.h" +#include "bconfig.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "rtl.h" -#include "obstack.h" #include "errors.h" +#include "gensupport.h" /* No instruction can have more operands than this. Sorry for this arbitrary limit, but what machine will have an instruction with @@ -97,13 +97,8 @@ Boston, MA 02111-1307, USA. */ #define MAX_MAX_OPERANDS 40 -static struct obstack obstack; -struct obstack *rtl_obstack = &obstack; - -#define obstack_chunk_alloc xmalloc -#define obstack_chunk_free free - -static int n_occurrences PARAMS ((int, char *)); +static int n_occurrences (int, const char *); +static const char *strip_whitespace (const char *); /* insns in the machine description are assigned sequential code numbers that are used by insn-recog.c (produced by genrecog) to communicate @@ -163,6 +158,8 @@ struct data const char *template; int code_number; int index_number; + const char *filename; + int lineno; int n_operands; /* Number of operands this insn recognizes */ int n_dups; /* Number times match_dup appears in pattern */ int n_alternatives; /* Number of alternatives in each constraint */ @@ -175,57 +172,66 @@ struct data static struct data *idata, **idata_end = &idata; -static void output_prologue PARAMS ((void)); -static void output_predicate_decls PARAMS ((void)); -static void output_operand_data PARAMS ((void)); -static void output_insn_data PARAMS ((void)); -static void output_get_insn_name PARAMS ((void)); -static void scan_operands PARAMS ((struct data *, rtx, int, int)); -static int compare_operands PARAMS ((struct operand_data *, - struct operand_data *)); -static void place_operands PARAMS ((struct data *)); -static void process_template PARAMS ((struct data *, char *)); -static void validate_insn_alternatives PARAMS ((struct data *)); -static void gen_insn PARAMS ((rtx)); -static void gen_peephole PARAMS ((rtx)); -static void gen_expand PARAMS ((rtx)); -static void gen_split PARAMS ((rtx)); -static int n_occurrences PARAMS ((int, char *)); - -const char * -get_insn_name (index) - int index; +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); + +#ifdef USE_MD_CONSTRAINTS + +struct constraint_data { - static char buf[100]; + struct constraint_data *next_this_letter; + int lineno; + unsigned int namelen; + const char name[1]; +}; - 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; - } +/* This is a complete list (unlike the one in genpreds.c) of constraint + letters and modifiers with machine-independent meaning. The only + omission is digits, as these are handled specially. */ +static const char indep_constraints[] = ",=+%*?!#&<>EFVXgimnoprs"; - if (last_named) - sprintf(buf, "%s+%d", last_named->name, index - last_named->index_number); - else - sprintf(buf, "insn %d", index); +static struct constraint_data * +constraints_by_letter_table[1 << CHAR_BIT]; - return buf; -} +static int mdep_constraint_len (const char *, int, int); +static void note_constraint (rtx, int); + +#else /* !USE_MD_CONSTRAINTS */ + +static void check_constraint_len (void); +static int constraint_len (const char *, int); +#endif /* !USE_MD_CONSTRAINTS */ + + static void -output_prologue () +output_prologue (void) { printf ("/* Generated automatically by the program `genoutput'\n\ -from the machine description file `md'. */\n\n"); + from the machine description file `md'. */\n\n"); - printf ("#define NO_MD_PROTOTYPES\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"); @@ -233,51 +239,17 @@ from the machine description file `md'. */\n\n"); printf ("#include \"real.h\"\n"); printf ("#include \"insn-config.h\"\n\n"); printf ("#include \"conditions.h\"\n"); - printf ("#include \"insn-flags.h\"\n"); printf ("#include \"insn-attr.h\"\n\n"); - printf ("#include \"insn-codes.h\"\n\n"); printf ("#include \"recog.h\"\n\n"); printf ("#include \"toplev.h\"\n"); printf ("#include \"output.h\"\n"); -} - - -/* We need to define all predicates used. Keep a list of those we - have defined so far. There normally aren't very many predicates - used, so a linked list should be fast enough. */ - -static void -output_predicate_decls () -{ - struct predicate { const char *name; struct predicate *next; } *predicates = 0; - register struct operand_data *d; - struct predicate *p; - - for (d = odata; d; d = d->next) - if (d->predicate && d->predicate[0]) - { - for (p = predicates; p; p = p->next) - if (strcmp (p->name, d->predicate) == 0) - break; - - if (p == 0) - { - printf ("extern int %s PARAMS ((rtx, enum machine_mode));\n", - d->predicate); - p = (struct predicate *) alloca (sizeof (struct predicate)); - p->name = d->predicate; - p->next = predicates; - predicates = p; - } - } - - printf ("\n\n"); + printf ("#include \"target.h\"\n"); } static void -output_operand_data () +output_operand_data (void) { - register struct operand_data *d; + struct operand_data *d; printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n"); @@ -302,14 +274,14 @@ output_operand_data () } static void -output_insn_data () +output_insn_data (void) { - register struct data *d; + struct data *d; int name_offset = 0; int next_name_offset; const char * last_name = 0; const char * next_name = 0; - register struct data *n; + struct data *n; for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++) if (n->name) @@ -318,10 +290,12 @@ output_insn_data () 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) @@ -354,21 +328,65 @@ output_insn_data () switch (d->output_format) { case INSN_OUTPUT_FORMAT_NONE: - printf (" 0,\n"); + 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: - printf (" \"%s\",\n", d->template); + { + 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 != '\\') + { + /* Preserve two consecutive \n's or \r's, but treat \r\n + as a single newline. */ + 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 (" (const PTR) output_%d,\n", d->code_number); + 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: - abort (); + gcc_unreachable (); } if (d->name && d->name[0] != '*') - printf (" gen_%s,\n", d->name); + printf (" (insn_gen_fn) gen_%s,\n", d->name); else printf (" 0,\n"); @@ -384,13 +402,15 @@ output_insn_data () } static void -output_get_insn_name () +output_get_insn_name (void) { printf ("const char *\n"); - printf ("get_insn_name (code)\n"); - printf (" int code;\n"); + printf ("get_insn_name (int code)\n"); printf ("{\n"); - printf (" return insn_data[code].name;\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"); } @@ -406,14 +426,11 @@ static int max_opno; static int num_dups; static void -scan_operands (d, part, this_address_p, this_strict_low) - struct data *d; - rtx part; - int this_address_p; - int this_strict_low; +scan_operands (struct data *d, rtx part, int this_address_p, + int this_strict_low) { - register int i, j; - register const char *format_ptr; + int i, j; + const char *format_ptr; int opno; if (part == 0) @@ -427,21 +444,25 @@ scan_operands (d, part, this_address_p, this_strict_low) max_opno = opno; if (max_opno >= MAX_MAX_OPERANDS) { - error ("Too many operands (%d) in definition %s.\n", - max_opno + 1, get_insn_name (next_index_number)); + message_with_line (d->lineno, + "maximum number of operands exceeded"); + have_error = 1; return; } if (d->operand[opno].seen) - error ("Definition %s specified operand number %d more than once.\n", - get_insn_name (next_index_number), opno); + { + 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 = XSTR (part, 2); - if (XSTR (part, 2) != 0 && *XSTR (part, 2) != 0) - d->operand[opno].n_alternatives - = n_occurrences (',', XSTR (part, 2)) + 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; @@ -452,21 +473,25 @@ scan_operands (d, part, this_address_p, this_strict_low) max_opno = opno; if (max_opno >= MAX_MAX_OPERANDS) { - error ("Too many operands (%d) in definition %s.\n", - max_opno + 1, get_insn_name (next_index_number)); + message_with_line (d->lineno, + "maximum number of operands exceeded"); + have_error = 1; return; } if (d->operand[opno].seen) - error ("Definition %s specified operand number %d more than once.\n", - get_insn_name (next_index_number), opno); + { + 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 = XSTR (part, 1); - if (XSTR (part, 1) != 0 && *XSTR (part, 1) != 0) - d->operand[opno].n_alternatives - = n_occurrences (',', XSTR (part, 1)) + 1; + 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; @@ -478,13 +503,18 @@ scan_operands (d, part, this_address_p, this_strict_low) max_opno = opno; if (max_opno >= MAX_MAX_OPERANDS) { - error ("Too many operands (%d) in definition %s.\n", - max_opno + 1, get_insn_name (next_index_number)); + message_with_line (d->lineno, + "maximum number of operands exceeded"); + have_error = 1; return; } if (d->operand[opno].seen) - error ("Definition %s specified operand number %d more than once.\n", - get_insn_name (next_index_number), opno); + { + 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; @@ -500,7 +530,7 @@ scan_operands (d, part, this_address_p, this_strict_low) case MATCH_OP_DUP: case MATCH_PAR_DUP: ++num_dups; - return; + break; case ADDRESS: scan_operands (d, XEXP (part, 0), 1, 0); @@ -509,7 +539,7 @@ scan_operands (d, part, this_address_p, this_strict_low) case STRICT_LOW_PART: scan_operands (d, XEXP (part, 0), 0, 1); return; - + default: break; } @@ -534,8 +564,7 @@ scan_operands (d, part, this_address_p, this_strict_low) /* Compare two operands for content equality. */ static int -compare_operands (d0, d1) - struct operand_data *d0, *d1; +compare_operands (struct operand_data *d0, struct operand_data *d1) { const char *p0, *p1; @@ -573,8 +602,7 @@ compare_operands (d0, d1) find a subsequence that is the same, or allocate a new one at the end. */ static void -place_operands (d) - struct data *d; +place_operands (struct data *d) { struct operand_data *od, *od2; int i; @@ -628,12 +656,10 @@ place_operands (d) templates, or C code to generate the assembler code template. */ static void -process_template (d, template) - struct data *d; - char *template; +process_template (struct data *d, const char *template) { - register char *cp; - register int i; + const char *cp; + int i; /* Templates starting with * contain straight code to be run. */ if (template[0] == '*') @@ -641,14 +667,11 @@ process_template (d, template) d->template = 0; d->output_format = INSN_OUTPUT_FORMAT_FUNCTION; - printf ("\nstatic const char *output_%d PARAMS ((rtx *, rtx));\n", - d->code_number); puts ("\nstatic const char *"); - printf ("output_%d (operands, insn)\n", d->code_number); - puts (" rtx *operands ATTRIBUTE_UNUSED;"); - puts (" rtx insn ATTRIBUTE_UNUSED;"); + printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED)\n", + d->code_number); puts ("{"); - + print_rtx_ptr_loc (template); puts (template + 1); puts ("}"); } @@ -664,11 +687,22 @@ process_template (d, template) for (i = 0, cp = &template[1]; *cp; ) { - while (*cp == '\n' || *cp == ' ' || *cp== '\t') + const char *ep, *sp; + + while (ISSPACE (*cp)) cp++; printf (" \""); - while (*cp != '\n' && *cp != '\0') + + 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++; @@ -677,6 +711,15 @@ process_template (d, template) 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"); } @@ -690,40 +733,118 @@ process_template (d, template) /* Check insn D for consistency in number of constraint alternatives. */ static void -validate_insn_alternatives (d) - struct data *d; +validate_insn_alternatives (struct data *d) { - register int n = 0, start; + int n = 0, start; /* Make sure all the operands have the same number of alternatives in their constraints. Let N be that number. */ for (start = 0; start < d->n_operands; start++) if (d->operand[start].n_alternatives > 0) { - if (n == 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) + { +#ifdef USE_MD_CONSTRAINTS + if (ISSPACE (c) || strchr (indep_constraints, c)) + len = 1; + else if (ISDIGIT (c)) + { + const char *q = p; + do + q++; + while (ISDIGIT (*q)); + len = q - p; + } + else + len = mdep_constraint_len (p, d->lineno, start); +#else + 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; + } +#endif + + 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) - error ("wrong number of alternatives in operand %d of insn %s", - start, get_insn_name (d->index_number)); + { + message_with_line (d->lineno, + "wrong number of alternatives in operand %d", + start); + have_error = 1; + } } /* Record the insn's overall number of alternatives. */ d->n_alternatives = n; } + +/* Verify that there are no gaps in operand numbers for INSNs. */ + +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; + } +} /* Look at a define_insn just read. Assign its code number. Record on idata the template and the number of arguments. If the insn has a hairy output action, output a function for now. */ static void -gen_insn (insn) - rtx insn; +gen_insn (rtx insn, int lineno) { - register struct data *d = (struct data *) xmalloc (sizeof (struct data)); - register int i; + struct data *d = XNEW (struct data); + int i; - d->code_number = next_code_number++; + 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 @@ -745,9 +866,13 @@ gen_insn (insn) d->n_operands = max_opno + 1; d->n_dups = num_dups; +#ifndef USE_MD_CONSTRAINTS + check_constraint_len (); +#endif + validate_insn_operands (d); validate_insn_alternatives (d); place_operands (d); - process_template (d, XSTR (insn, 3)); + process_template (d, XTMPL (insn, 3)); } /* Look at a define_peephole just read. Assign its code number. @@ -755,14 +880,15 @@ gen_insn (insn) If the insn has a hairy output action, output it now. */ static void -gen_peephole (peep) - rtx peep; +gen_peephole (rtx peep, int lineno) { - register struct data *d = (struct data *) xmalloc (sizeof (struct data)); - register int i; + struct data *d = XNEW (struct data); + int i; - d->code_number = next_code_number++; + d->code_number = next_code_number; d->index_number = next_index_number; + d->filename = read_rtx_filename; + d->lineno = lineno; d->name = 0; /* Build up the list in the same order as the insns are seen @@ -786,21 +912,22 @@ gen_peephole (peep) validate_insn_alternatives (d); place_operands (d); - process_template (d, XSTR (peep, 2)); + process_template (d, XTMPL (peep, 2)); } /* Process a define_expand just read. Assign its code number, only for the purposes of `insn_gen_function'. */ static void -gen_expand (insn) - rtx insn; +gen_expand (rtx insn, int lineno) { - register struct data *d = (struct data *) xmalloc (sizeof (struct data)); - register int i; + struct data *d = XNEW (struct data); + int i; - d->code_number = next_code_number++; + 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 @@ -836,14 +963,15 @@ gen_expand (insn) only for reasons of consistency and to simplify genrecog. */ static void -gen_split (split) - rtx split; +gen_split (rtx split, int lineno) { - register struct data *d = (struct data *) xmalloc (sizeof (struct data)); - register int i; + struct data *d = XNEW (struct data); + int i; - d->code_number = next_code_number++; + d->code_number = next_code_number; d->index_number = next_index_number; + d->filename = read_rtx_filename; + d->lineno = lineno; d->name = 0; /* Build up the list in the same order as the insns are seen @@ -870,57 +998,18 @@ gen_split (split) place_operands (d); } - -PTR -xmalloc (size) - size_t size; -{ - register PTR val = (PTR) malloc (size); - if (val == 0) - fatal ("virtual memory exhausted"); - return val; -} - -PTR -xrealloc (old, size) - PTR old; - size_t size; -{ - register PTR ptr; - if (old) - ptr = (PTR) realloc (old, size); - else - ptr = (PTR) malloc (size); - if (!ptr) - fatal ("virtual memory exhausted"); - return ptr; -} - -extern int main PARAMS ((int, char **)); +extern int main (int, char **); int -main (argc, argv) - int argc; - char **argv; +main (int argc, char **argv) { rtx desc; - FILE *infile; - register int c; progname = "genoutput"; - obstack_init (rtl_obstack); - if (argc <= 1) - fatal ("No input file name."); - - infile = fopen (argv[1], "r"); - if (infile == 0) - { - perror (argv[1]); - return (FATAL_EXIT_CODE); - } - read_rtx_filename = argv[1]; + if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE) + return (FATAL_EXIT_CODE); output_prologue (); next_code_number = 0; @@ -930,26 +1019,47 @@ main (argc, argv) while (1) { - c = read_skip_spaces (infile); - if (c == EOF) + int line_no; + + desc = read_md_rtx (&line_no, &next_code_number); + if (desc == NULL) break; - ungetc (c, infile); - - desc = read_rtx (infile); - if (GET_CODE (desc) == DEFINE_INSN) - gen_insn (desc); - if (GET_CODE (desc) == DEFINE_PEEPHOLE) - gen_peephole (desc); - if (GET_CODE (desc) == DEFINE_EXPAND) - gen_expand (desc); - if (GET_CODE (desc) == DEFINE_SPLIT - || GET_CODE (desc) == DEFINE_PEEPHOLE2) - gen_split (desc); + + switch (GET_CODE (desc)) + { + case DEFINE_INSN: + gen_insn (desc, line_no); + break; + + case DEFINE_PEEPHOLE: + gen_peephole (desc, line_no); + break; + + case DEFINE_EXPAND: + gen_expand (desc, line_no); + break; + + case DEFINE_SPLIT: + case DEFINE_PEEPHOLE2: + gen_split (desc, line_no); + break; + +#ifdef USE_MD_CONSTRAINTS + case DEFINE_CONSTRAINT: + case DEFINE_REGISTER_CONSTRAINT: + case DEFINE_ADDRESS_CONSTRAINT: + case DEFINE_MEMORY_CONSTRAINT: + note_constraint (desc, line_no); + break; +#endif + + default: + break; + } next_index_number++; } printf("\n\n"); - output_predicate_decls (); output_operand_data (); output_insn_data (); output_get_insn_name (); @@ -959,13 +1069,171 @@ main (argc, argv) ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE); } +/* Return the number of occurrences of character C in string S or + -1 if S is the null string. */ + static int -n_occurrences (c, s) - int c; - char *s; +n_occurrences (int c, const char *s) { int n = 0; + + if (s == 0 || *s == '\0') + return -1; + while (*s) n += (*s++ == c); + return n; } + +/* Remove whitespace in `s' by moving up characters until the end. + Return a new string. */ + +static const char * +strip_whitespace (const char *s) +{ + char *p, *q; + char ch; + + if (s == 0) + return 0; + + p = q = XNEWVEC (char, strlen (s) + 1); + while ((ch = *s++) != '\0') + if (! ISSPACE (ch)) + *p++ = ch; + + *p = '\0'; + return q; +} + +#ifdef USE_MD_CONSTRAINTS + +/* Record just enough information about a constraint to allow checking + of operand constraint strings above, in validate_insn_alternatives. + Does not validate most properties of the constraint itself; does + enforce no duplicate names, no overlap with MI constraints, and no + prefixes. EXP is the define_*constraint form, LINENO the line number + reported by the reader. */ +static void +note_constraint (rtx exp, int lineno) +{ + const char *name = XSTR (exp, 0); + unsigned int namelen = strlen (name); + struct constraint_data **iter, **slot, *new; + + if (strchr (indep_constraints, name[0])) + { + if (name[1] == '\0') + message_with_line (lineno, "constraint letter '%s' cannot be " + "redefined by the machine description", name); + else + message_with_line (lineno, "constraint name '%s' cannot be defined by " + "the machine description, as it begins with '%c'", + name, name[0]); + have_error = 1; + return; + } + + slot = &constraints_by_letter_table[(unsigned int)name[0]]; + for (iter = slot; *iter; iter = &(*iter)->next_this_letter) + { + /* This causes slot to end up pointing to the + next_this_letter field of the last constraint with a name + of equal or greater length than the new constraint; hence + the new constraint will be inserted after all previous + constraints with names of the same length. */ + if ((*iter)->namelen >= namelen) + slot = iter; + + if (!strcmp ((*iter)->name, name)) + { + message_with_line (lineno, "redefinition of constraint '%s'", name); + message_with_line ((*iter)->lineno, "previous definition is here"); + have_error = 1; + return; + } + else if (!strncmp ((*iter)->name, name, (*iter)->namelen)) + { + message_with_line (lineno, "defining constraint '%s' here", name); + message_with_line ((*iter)->lineno, "renders constraint '%s' " + "(defined here) a prefix", (*iter)->name); + have_error = 1; + return; + } + else if (!strncmp ((*iter)->name, name, namelen)) + { + message_with_line (lineno, "constraint '%s' is a prefix", name); + message_with_line ((*iter)->lineno, "of constraint '%s' " + "(defined here)", (*iter)->name); + have_error = 1; + return; + } + } + new = xmalloc (sizeof (struct constraint_data) + namelen); + strcpy ((char *)new + offsetof(struct constraint_data, name), name); + new->namelen = namelen; + new->lineno = lineno; + new->next_this_letter = *slot; + *slot = new; +} + +/* Return the length of the constraint name beginning at position S + of an operand constraint string, or issue an error message if there + is no such constraint. Does not expect to be called for generic + constraints. */ +static int +mdep_constraint_len (const char *s, int lineno, int opno) +{ + struct constraint_data *p; + + p = constraints_by_letter_table[(unsigned int)s[0]]; + + if (p) + for (; p; p = p->next_this_letter) + if (!strncmp (s, p->name, p->namelen)) + return p->namelen; + + message_with_line (lineno, + "error: undefined machine-specific constraint " + "at this point: \"%s\"", s); + message_with_line (lineno, "note: in operand %d", opno); + have_error = 1; + return 1; /* safe */ +} + +#else +/* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not + tampered with. This isn't bullet-proof, but it should catch + most genuine mistakes. */ +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) +{ + /* Check that we still match defaults.h . First we do a generation-time + check that fails if the value is not the expected one... */ + gcc_assert (DEFAULT_CONSTRAINT_LEN (*p, p) == 1); + /* And now a compile-time check that should give a diagnostic if the + definition doesn't exactly match. */ +#define DEFAULT_CONSTRAINT_LEN(C,STR) 1 + /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is + being used. */ +#undef DEFAULT_CONSTRAINT_LEN +#define DEFAULT_CONSTRAINT_LEN(C,STR) \ + ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len) + return CONSTRAINT_LEN (*p, p); + /* And set it back. */ +#undef DEFAULT_CONSTRAINT_LEN +#define DEFAULT_CONSTRAINT_LEN(C,STR) 1 +} +#endif