X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgenoutput.c;h=44bc412d48840ad8094d8a516add5857cbaae653;hb=ac4ededf628466d520f6b6edbf15f14d2c1fe776;hp=80b73fcb91564446db1ee1d5bb7d8256acb72108;hpb=337057dd46c607bfdb0d01974e8c8398f89c1741;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/genoutput.c b/gcc/genoutput.c index 80b73fcb915..44bc412d488 100644 --- a/gcc/genoutput.c +++ b/gcc/genoutput.c @@ -1,6 +1,6 @@ /* Generate code from to output assembler insns as recognized from rtl. - Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000 - Free Software Foundation, Inc. + Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002, + 2003, 2004 Free Software Foundation, Inc. This file is part of GCC. @@ -85,8 +85,10 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA 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 "errors.h" #include "gensupport.h" @@ -97,8 +99,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define MAX_MAX_OPERANDS 40 -static int n_occurrences PARAMS ((int, const char *)); -static const char *strip_whitespace PARAMS ((const 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 @@ -171,26 +173,26 @@ 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 *, const char *)); -static void validate_insn_alternatives PARAMS ((struct data *)); -static void validate_insn_operands PARAMS ((struct data *)); -static void gen_insn PARAMS ((rtx, int)); -static void gen_peephole PARAMS ((rtx, int)); -static void gen_expand PARAMS ((rtx, int)); -static void gen_split PARAMS ((rtx, int)); +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 (index) - int index; +get_insn_name (int index) { static char buf[100]; @@ -212,13 +214,15 @@ get_insn_name (index) } static void -output_prologue () +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"); @@ -235,49 +239,11 @@ output_prologue () 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. */ -struct predicate { const char *name; struct predicate *next; }; - -static void -output_predicate_decls () -{ - struct predicate *predicates = 0; - struct operand_data *d; - struct predicate *p, *next; - - 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 *) xmalloc (sizeof (struct predicate)); - p->name = d->predicate; - p->next = predicates; - predicates = p; - } - } - - printf ("\n\n"); - for (p = predicates; p; p = next) - { - next = p->next; - free (p); - } + printf ("#include \"target.h\"\n"); } static void -output_operand_data () +output_operand_data (void) { struct operand_data *d; @@ -304,7 +270,7 @@ output_operand_data () } static void -output_insn_data () +output_insn_data (void) { struct data *d; int name_offset = 0; @@ -320,6 +286,7 @@ 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) @@ -356,13 +323,22 @@ 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: { 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) { @@ -379,11 +355,26 @@ output_insn_data () ++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 (); @@ -406,13 +397,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"); } @@ -428,11 +421,8 @@ 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) { int i, j; const char *format_ptr; @@ -544,7 +534,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; } @@ -569,8 +559,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; @@ -608,8 +597,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; @@ -663,9 +651,7 @@ place_operands (d) templates, or C code to generate the assembler code template. */ static void -process_template (d, template) - struct data *d; - const char *template; +process_template (struct data *d, const char *template) { const char *cp; int i; @@ -676,12 +662,9 @@ 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 ("{"); puts (template + 1); @@ -699,11 +682,22 @@ process_template (d, template) for (i = 0, cp = &template[1]; *cp; ) { + const char *ep, *sp; + while (ISSPACE (*cp)) cp++; printf (" \""); - while (!IS_VSPACE (*cp) && *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++; @@ -734,8 +728,7 @@ 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) { int n = 0, start; @@ -744,7 +737,51 @@ validate_insn_alternatives (d) 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) + { + 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) { @@ -762,8 +799,7 @@ validate_insn_alternatives (d) /* Verify that there are no gaps in operand numbers for INSNs. */ static void -validate_insn_operands (d) - struct data *d; +validate_insn_operands (struct data *d) { int i; @@ -780,11 +816,9 @@ validate_insn_operands (d) a hairy output action, output a function for now. */ static void -gen_insn (insn, lineno) - rtx insn; - int lineno; +gen_insn (rtx insn, int lineno) { - struct data *d = (struct data *) xmalloc (sizeof (struct data)); + struct data *d = xmalloc (sizeof (struct data)); int i; d->code_number = next_code_number; @@ -811,6 +845,7 @@ gen_insn (insn, lineno) 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); @@ -822,11 +857,9 @@ gen_insn (insn, lineno) If the insn has a hairy output action, output it now. */ static void -gen_peephole (peep, lineno) - rtx peep; - int lineno; +gen_peephole (rtx peep, int lineno) { - struct data *d = (struct data *) xmalloc (sizeof (struct data)); + struct data *d = xmalloc (sizeof (struct data)); int i; d->code_number = next_code_number; @@ -862,11 +895,9 @@ gen_peephole (peep, lineno) only for the purposes of `insn_gen_function'. */ static void -gen_expand (insn, lineno) - rtx insn; - int lineno; +gen_expand (rtx insn, int lineno) { - struct data *d = (struct data *) xmalloc (sizeof (struct data)); + struct data *d = xmalloc (sizeof (struct data)); int i; d->code_number = next_code_number; @@ -907,11 +938,9 @@ gen_expand (insn, lineno) only for reasons of consistency and to simplify genrecog. */ static void -gen_split (split, lineno) - rtx split; - int lineno; +gen_split (rtx split, int lineno) { - struct data *d = (struct data *) xmalloc (sizeof (struct data)); + struct data *d = xmalloc (sizeof (struct data)); int i; d->code_number = next_code_number; @@ -944,12 +973,10 @@ gen_split (split, lineno) place_operands (d); } -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; @@ -982,13 +1009,12 @@ main (argc, argv) if (GET_CODE (desc) == DEFINE_EXPAND) gen_expand (desc, line_no); if (GET_CODE (desc) == DEFINE_SPLIT - || GET_CODE (desc) == DEFINE_PEEPHOLE2) + || GET_CODE (desc) == DEFINE_PEEPHOLE2) gen_split (desc, line_no); next_index_number++; } printf("\n\n"); - output_predicate_decls (); output_operand_data (); output_insn_data (); output_get_insn_name (); @@ -1002,9 +1028,7 @@ main (argc, argv) -1 if S is the null string. */ static int -n_occurrences (c, s) - int c; - const char *s; +n_occurrences (int c, const char *s) { int n = 0; @@ -1021,8 +1045,7 @@ n_occurrences (c, s) Return a new string. */ static const char * -strip_whitespace (s) - const char *s; +strip_whitespace (const char *s) { char *p, *q; char ch; @@ -1038,3 +1061,39 @@ strip_whitespace (s) *p = '\0'; return q; } + +/* 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++) + if (constraint_len (p, d) != d) + abort (); +} + +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... */ + if (DEFAULT_CONSTRAINT_LEN (*p, p) != 1) + abort (); + /* 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 +}