X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgenoutput.c;h=44bc412d48840ad8094d8a516add5857cbaae653;hb=ac4ededf628466d520f6b6edbf15f14d2c1fe776;hp=4cb9c00b6490672057d29485033fbe8e210e6be5;hpb=0922b1b8057a504feec8f1326bb563ad7decf754;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/genoutput.c b/gcc/genoutput.c
index 4cb9c00b649..44bc412d488 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 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, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.  */
 
 
 /* This program reads the machine description for the compiler target machine
@@ -65,6 +65,10 @@ Boston, MA 02111-1307, USA.  */
 
      e. `strict_low', is nonzero for operands contained in a STRICT_LOW_PART.
 
+     f. `eliminable', is nonzero for operands that are matched normally by
+     MATCH_OPERAND; it is zero for operands that should not be changed during
+     register elimination such as MATCH_OPERATORs.
+
   The code number of an insn is simply its position in the machine
   description; code numbers are assigned sequentially to entries in
   the description, starting with code number 0.
@@ -81,11 +85,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
@@ -93,13 +99,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 PROTO((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
@@ -128,6 +129,7 @@ struct operand_data
   unsigned char n_alternatives;
   char address_p;
   char strict_low;
+  char eliminable;
   char seen;
 };
 
@@ -135,7 +137,7 @@ struct operand_data
 
 static struct operand_data null_operand =
 {
-  0, 0, "", "", VOIDmode, 0, 0, 0, 0
+  0, 0, "", "", VOIDmode, 0, 0, 0, 0, 0
 };
 
 static struct operand_data *odata = &null_operand;
@@ -158,6 +160,7 @@ struct data
   const char *template;
   int code_number;
   int index_number;
+  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 */
@@ -170,26 +173,26 @@ struct data
 
 static struct data *idata, **idata_end = &idata;
 
-static void output_prologue PROTO((void));
-static void output_predicate_decls PROTO((void));
-static void output_operand_data PROTO((void));
-static void output_insn_data PROTO((void));
-static void output_get_insn_name PROTO((void));
-static void scan_operands PROTO((struct data *, rtx, int, int));
-static int compare_operands PROTO((struct operand_data *,
-				   struct operand_data *));
-static void place_operands PROTO((struct data *));
-static void process_template PROTO((struct data *, char *));
-static void validate_insn_alternatives PROTO((struct data *));
-static void gen_insn PROTO((rtx));
-static void gen_peephole PROTO((rtx));
-static void gen_expand PROTO((rtx));
-static void gen_split PROTO((rtx));
-static int n_occurrences PROTO((int, char *));
+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];
 
@@ -211,16 +214,20 @@ 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");
+   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");
@@ -228,51 +235,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");
+  printf ("#include \"target.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 ()
+output_operand_data (void)
 {
-  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 PROTO ((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");
-}
-
-static void
-output_operand_data ()
-{
-  register struct operand_data *d;
+  struct operand_data *d;
 
   printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n");
 
@@ -287,7 +260,9 @@ output_operand_data ()
 
       printf ("    %smode,\n", GET_MODE_NAME (d->mode));
 
-      printf ("    %d\n", d->strict_low);
+      printf ("    %d,\n", d->strict_low);
+
+      printf ("    %d\n", d->eliminable);
 
       printf("  },\n");
     }
@@ -295,14 +270,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)
@@ -311,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)
@@ -347,21 +323,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 ("    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 ();
 	}
 
       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");
 
@@ -377,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");
 }
 
@@ -399,14 +421,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)
@@ -420,22 +439,27 @@ 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;
 
     case MATCH_SCRATCH:
@@ -444,22 +468,27 @@ 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;
 
     case MATCH_OPERATOR:
@@ -469,19 +498,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 = 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;
@@ -490,7 +525,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);
@@ -499,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;
     }
@@ -524,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;
 
@@ -553,6 +587,9 @@ compare_operands (d0, d1)
   if (d0->strict_low != d1->strict_low)
     return 0;
 
+  if (d0->eliminable != d1->eliminable)
+    return 0;
+
   return 1;
 }
 
@@ -560,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;
@@ -615,12 +651,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] == '*')
@@ -628,12 +662,9 @@ process_template (d, template)
       d->template = 0;
       d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
 
-      printf ("\nstatic const char *output_%d PROTO ((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);
@@ -651,11 +682,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++;
@@ -664,6 +706,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");
     }
@@ -677,40 +728,102 @@ 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)
+	  {
+	    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)
-	  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 = xmalloc (sizeof (struct data));
+  int i;
 
-  d->code_number = next_code_number++;
+  d->code_number = next_code_number;
   d->index_number = next_index_number;
+  d->lineno = lineno;
   if (XSTR (insn, 0)[0])
     d->name = XSTR (insn, 0);
   else
@@ -732,9 +845,11 @@ gen_insn (insn)
   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, XSTR (insn, 3));
+  process_template (d, XTMPL (insn, 3));
 }
 
 /* Look at a define_peephole just read.  Assign its code number.
@@ -742,14 +857,14 @@ 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 = xmalloc (sizeof (struct data));
+  int i;
 
-  d->code_number = next_code_number++;
+  d->code_number = next_code_number;
   d->index_number = next_index_number;
+  d->lineno = lineno;
   d->name = 0;
 
   /* Build up the list in the same order as the insns are seen
@@ -773,21 +888,21 @@ 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 = xmalloc (sizeof (struct data));
+  int i;
 
-  d->code_number = next_code_number++;
+  d->code_number = next_code_number;
   d->index_number = next_index_number;
+  d->lineno = lineno;
   if (XSTR (insn, 0)[0])
     d->name = XSTR (insn, 0);
   else
@@ -823,14 +938,14 @@ 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 = xmalloc (sizeof (struct data));
+  int i;
 
-  d->code_number = next_code_number++;
+  d->code_number = next_code_number;
   d->index_number = next_index_number;
+  d->lineno = lineno;
   d->name = 0;
 
   /* Build up the list in the same order as the insns are seen
@@ -857,57 +972,21 @@ 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 PROTO ((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.");
+    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;
@@ -917,26 +996,25 @@ 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);
+	gen_insn (desc, line_no);
       if (GET_CODE (desc) == DEFINE_PEEPHOLE)
-	gen_peephole (desc);
+	gen_peephole (desc, line_no);
       if (GET_CODE (desc) == DEFINE_EXPAND)
-	gen_expand (desc);
+	gen_expand (desc, line_no);
       if (GET_CODE (desc) == DEFINE_SPLIT
- 	  || GET_CODE (desc) == DEFINE_PEEPHOLE2)
-	gen_split (desc);
+	  || 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 ();
@@ -946,13 +1024,76 @@ 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 = xmalloc (strlen (s) + 1);
+  while ((ch = *s++) != '\0')
+    if (! ISSPACE (ch))
+      *p++ = ch;
+
+  *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
+}