Gcc 3.4.2 20040728.

1 files changed, 170 insertions, 122 deletions

diff --git a/contrib/gcc/genoutput.c b/contrib/gcc/genoutput.c
index 80b73fc..9e27b27 100644
--- a/contrib/gcc/genoutput.c
+++ b/contrib/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);
@@ -734,8 +717,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 +726,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 +788,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 +805,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 +834,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 +846,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 +884,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 +927,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 +962,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 +998,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 +1017,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 +1034,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 +1050,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
+}