*** empty log message ***

From-SVN: r784

gcc/config/rs6000/rs6000.md

@@ -2922,7 +2922,7 @@
 (define_insn ""
   [(call (mem:SI (match_operand:SI 0 "call_operand" "l,s"))
 	 (match_operand 1 "" "fg,fg"))
-   (clobber (match_scratch:SI 3 "=l,l"))]
+   (clobber (match_scratch:SI 2 "=l,l"))]
   ""
   "@
    brl\;l 2,20(1)

gcc/genextract.c

 /* Generate code from machine description to extract operands from insn as rtl.
-   Copyright (C) 1987, 1991 Free Software Foundation, Inc.
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -22,6 +22,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "config.h"
 #include "rtl.h"
 #include "obstack.h"
+#include "insn-config.h"
 
 static struct obstack obstack;
 struct obstack *rtl_obstack = &obstack;
@@ -31,46 +32,73 @@ struct obstack *rtl_obstack = &obstack;
 
 extern void free ();
 
+/* This structure contains all the information needed to describe one
+   set of extractions methods.  Each method may be used by more than 
+   one pattern if the operands are in the same place.
+
+   The string for each operand describes that path to the operand and
+   contains `0' through `9' when going into an expression and `a' through
+   `z' when going into a vector.  We assume here that only the first operand
+   of an rtl expression is a vector.  genrecog.c makes the same assumption
+   (and uses the same representation) and it is currently true.  */
+
+struct extraction
+{
+  int op_count;
+  char *oplocs[MAX_RECOG_OPERANDS];
+  int dup_count;
+  char *duplocs[MAX_DUP_OPERANDS];
+  int dupnums[MAX_DUP_OPERANDS];
+  struct code_ptr *insns;
+  struct extraction *next;
+};
+
+/* Holds a single insn code that use an extraction method.  */
+
+struct code_ptr
+{
+  int insn_code;
+  struct code_ptr *next;
+};
+
+static struct extraction *extractions;
+
 /* Number instruction patterns handled, starting at 0 for first one.  */
 
 static int insn_code_number;
 
+/* Records the large operand number in this insn.  */
+
+static int op_count;
+
+/* Records the location of any operands using the string format described
+   above.  */
+
+static char *oplocs[MAX_RECOG_OPERANDS];
+
 /* Number the occurrences of MATCH_DUP in each instruction,
    starting at 0 for the first occurrence.  */
 
 static int dup_count;
 
-/* Record which operand numbers have been seen in the current pattern.
-   This table is made longer as needed.  */
-
-static char *operand_seen;
+/* Records the location of any MATCH_DUP operands.  */
 
-/* Current allocated length of operand_seen.  */
+static char *duplocs[MAX_DUP_OPERANDS];
 
-static int operand_seen_length;
+/* Record the operand number of any MATCH_DUPs.  */
 
-/* Have we got any peephole patterns yet?  */
+static int dupnums[MAX_DUP_OPERANDS];
 
-static int peephole_seen;
+/* Record the list of insn_codes for peepholes.  */
 
-/* While tree-walking an instruction pattern, we keep a chain
-   of these `struct link's to record how to get down to the
-   current position.  In each one, POS is the operand number,
-   and if the operand is a vector VEC is the element number.
-   VEC is -1 if the operand is not a vector.  */
-
-struct link
-{
-  struct link *next;
-  int pos;
-  int vecelt;
-};
+static struct code_ptr *peepholes;
 
 static void walk_rtx ();
 static void print_path ();
 char *xmalloc ();
 char *xrealloc ();
 static void fatal ();
+static char *copystr ();
 static void mybzero ();
 void fancy_abort ();
 
@@ -79,68 +107,93 @@ gen_insn (insn)
      rtx insn;
 {
   register int i;
+  register struct extraction *p;
+  register struct code_ptr *link;
 
+  op_count = 0;
   dup_count = 0;
 
   /* No operands seen so far in this pattern.  */
-  mybzero (operand_seen, operand_seen_length);
-
-  printf ("    case %d:\n", insn_code_number);
+  mybzero (oplocs, sizeof oplocs);
 
   /* Walk the insn's pattern, remembering at all times the path
      down to the walking point.  */
 
   if (XVECLEN (insn, 1) == 1)
-    walk_rtx (XVECEXP (insn, 1, 0), 0);
+    walk_rtx (XVECEXP (insn, 1, 0), "");
   else
     for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
       {
-	struct link link;
-	link.next = 0;
-	link.pos = 0;
-	link.vecelt = i;
-	walk_rtx (XVECEXP (insn, 1, i), &link);
-      }
+	char *path = (char *) alloca (2);
 
-  /* If the operand numbers used in the pattern are not consecutive,
-     don't leave an operand uninitialized.  */
-  for (i = operand_seen_length - 1; i >= 0; i--)
-    if (operand_seen[i])
-      break;
-  for (; i >= 0; i--)
-    if (!operand_seen[i])
-      {
-	printf ("      ro[%d] = const0_rtx;\n", i);
-	printf ("      ro_loc[%d] = &junk;\n", i);
+	path[0] = 'a' + i;
+	path[1] = 0;
+
+	walk_rtx (XVECEXP (insn, 1, i), path);
       }
-  printf ("      break;\n");
-}
 
-/* Record that we have seen an operand with number OPNO in this pattern.  */
+  link = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
+  link->insn_code = insn_code_number;
 
-static void
-mark_operand_seen (opno)
-     int opno;
-{
-  if (opno >= operand_seen_length)
+  /* See if we find something that already had this extraction method. */
+
+  for (p = extractions; p; p = p->next)
     {
-      operand_seen_length *= 2;
-      operand_seen = (char *) xrealloc (operand_seen, operand_seen_length);
+      if (p->op_count != op_count || p->dup_count != dup_count)
+	continue;
+
+      for (i = 0; i < op_count; i++)
+	if (p->oplocs[i] != oplocs[i]
+	    && ! (p->oplocs[i] != 0 && oplocs[i] != 0
+		  && ! strcmp (p->oplocs[i], oplocs[i])))
+	  break;
+
+      if (i != op_count)
+	continue;
+
+      for (i = 0; i < dup_count; i++)
+	if (p->dupnums[i] != dupnums[i]
+	    || strcmp (p->duplocs[i], duplocs[i]))
+	  break;
+
+      if (i != dup_count)
+	continue;
+
+      /* This extraction is the same as ours.  Just link us in.  */
+      link->next = p->insns;
+      p->insns = link;
+      return;
     }
 
-  operand_seen[opno] = 1;
+  /* Otherwise, make a new extraction method.  */
+
+  p = (struct extraction *) xmalloc (sizeof (struct extraction));
+  p->op_count = op_count;
+  p->dup_count = dup_count;
+  p->next = extractions;
+  extractions = p;
+  p->insns = link;
+  link->next = 0;
+
+  for (i = 0; i < op_count; i++)
+    p->oplocs[i] = oplocs[i];
+
+  for (i = 0; i < dup_count; i++)
+    p->dupnums[i] = dupnums[i], p->duplocs[i] = duplocs[i];
 }
 
 static void
 walk_rtx (x, path)
      rtx x;
-     struct link *path;
+     char *path;
 {
   register RTX_CODE code;
   register int i;
   register int len;
   register char *fmt;
-  struct link link;
+  register struct code_ptr *link;
+  int depth = strlen (path);
+  char *newpath;
 
   if (x == 0)
     return;
@@ -157,49 +210,44 @@ walk_rtx (x, path)
 
     case MATCH_OPERAND:
     case MATCH_SCRATCH:
-      mark_operand_seen (XINT (x, 0));
-      printf ("      ro[%d] = *(ro_loc[%d] = &",
-	      XINT (x, 0), XINT (x, 0));
-      print_path (path);
-      printf (");\n");
+      oplocs[XINT (x, 0)] = copystr (path);
+      op_count = MAX (op_count, XINT (x, 0) + 1);
       break;
 
     case MATCH_DUP:
     case MATCH_OP_DUP:
-      printf ("      recog_dup_loc[%d] = &", dup_count);
-      print_path (path);
-      printf (";\n");
-      printf ("      recog_dup_num[%d] = %d;\n", dup_count, XINT (x, 0));
+      duplocs[dup_count] = copystr (path);
+      dupnums[dup_count] = XINT (x, 0);
       dup_count++;
       break;
 
     case MATCH_OPERATOR:
-      mark_operand_seen (XINT (x, 0));
-      printf ("      ro[%d] = *(ro_loc[%d]\n        = &",
-	      XINT (x, 0), XINT (x, 0));
-      print_path (path);
-      printf (");\n");
-      link.next = path;
-      link.vecelt = -1;
+      oplocs[XINT (x, 0)] = copystr (path);
+      op_count = MAX (op_count, XINT (x, 0) + 1);
+
+      newpath = (char *) alloca (depth + 2);
+      strcpy (newpath, path);
+      newpath[depth + 1] = 0;
+
       for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
 	{
-	  link.pos = i;
-	  walk_rtx (XVECEXP (x, 2, i), &link);
+	  newpath[depth] = '0' + i;
+	  walk_rtx (XVECEXP (x, 2, i), newpath);
 	}
       return;
 
     case MATCH_PARALLEL:
-      mark_operand_seen (XINT (x, 0));
-      printf ("      ro[%d] = *(ro_loc[%d]\n        = &",
-	      XINT (x, 0), XINT (x, 0));
-      print_path (path);
-      printf (");\n");
-      link.next = path;
-      link.pos = 0;
+      oplocs[XINT (x, 0)] = copystr (path);
+      op_count = MAX (op_count, XINT (x, 0) + 1);
+
+      newpath = (char *) alloca (depth + 2);
+      strcpy (newpath, path);
+      newpath[depth + 1] = 0;
+
       for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
 	{
-	  link.vecelt = i;
-	  walk_rtx (XVECEXP (x, 2, i), &link);
+	  newpath[depth] = 'a' + i;
+	  walk_rtx (XVECEXP (x, 2, i), newpath);
 	}
       return;
 
@@ -208,24 +256,26 @@ walk_rtx (x, path)
       return;
     }
 
-  link.next = path;
-  link.vecelt = -1;
+  newpath = (char *) alloca (depth + 2);
+  strcpy (newpath, path);
+  newpath[depth + 1] = 0;
+
   fmt = GET_RTX_FORMAT (code);
   len = GET_RTX_LENGTH (code);
   for (i = 0; i < len; i++)
     {
-      link.pos = i;
       if (fmt[i] == 'e' || fmt[i] == 'u')
 	{
-	  walk_rtx (XEXP (x, i), &link);
+	  newpath[depth] = '0' + i;
+	  walk_rtx (XEXP (x, i), newpath);
 	}
       else if (fmt[i] == 'E')
 	{
 	  int j;
 	  for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 	    {
-	      link.vecelt = j;
-	      walk_rtx (XVECEXP (x, i, j), &link);
+	      newpath[depth] = 'a' + i;
+	      walk_rtx (XVECEXP (x, i, j), newpath);
 	    }
 	}
     }
@@ -237,21 +287,34 @@ walk_rtx (x, path)
 
 static void
 print_path (path)
-     struct link *path;
+     char *path;
 {
-  if (path == 0)
-    printf ("insn");
-  else if (path->vecelt >= 0)
+  register int len = strlen (path);
+  register int i;
+
+  /* We first write out the operations (XEXP or XVECEXP) in reverse
+     order, then write "insn", then the indices in forward order.  */
+
+  for (i = len - 1; i >=0 ; i--)
     {
+      if (path[i] >= 'a' && path[i] <= 'z')
 	printf ("XVECEXP (");
-      print_path (path->next);
-      printf (", %d, %d)", path->pos, path->vecelt);
-    }
+      else if (path[i] >= '0' && path[i] <= '9')
+	printf ("XEXP (");
       else
+	abort ();
+    }
+  
+  printf ("insn");
+
+  for (i = 0; i < len; i++)
     {
-      printf ("XEXP (");
-      print_path (path->next);
-      printf (", %d)", path->pos);
+      if (path[i] >= 'a' && path[i] <= 'z')
+	printf (", 0, %d)", path[i] - 'a');
+      else if (path[i] >= '0' && path[i] <= '9')
+	printf (", %d)", path[i] - '0');
+      else
+	abort ();
     }
 }
 
@@ -296,6 +359,21 @@ fancy_abort ()
   fatal ("Internal gcc abort.");
 }
 
+static char *
+copystr (s1)
+     char *s1;
+{
+  register char *tem;
+
+  if (s1 == 0)
+    return 0;
+
+  tem = (char *) xmalloc (strlen (s1) + 1);
+  strcpy (tem, s1);
+
+  return tem;
+}
+
 static void
 mybzero (b, length)
      register char *b;
@@ -314,6 +392,8 @@ main (argc, argv)
   FILE *infile;
   extern rtx read_rtx ();
   register int c, i;
+  struct extraction *p;
+  struct code_ptr *link;
 
   obstack_init (rtl_obstack);
 
@@ -334,9 +414,6 @@ main (argc, argv)
 
   insn_code_number = 0;
 
-  operand_seen_length = 40;
-  operand_seen = (char *) xmalloc (40);
-
   printf ("/* Generated automatically by the program `genextract'\n\
 from the machine description file `md'.  */\n\n");
 
@@ -346,6 +423,7 @@ from the machine description file `md'.  */\n\n");
   /* This variable exists only so it can be the "location"
      of any missing operand whose numbers are skipped by a given pattern.  */
   printf ("static rtx junk;\n");
+
   printf ("extern rtx recog_operand[];\n");
   printf ("extern rtx *recog_operand_loc[];\n");
   printf ("extern rtx *recog_dup_loc[];\n");
@@ -359,10 +437,11 @@ from the machine description file `md'.  */\n\n");
   printf ("  register rtx *ro = recog_operand;\n");
   printf ("  register rtx **ro_loc = recog_operand_loc;\n");
   printf ("  int insn_code = INSN_CODE (insn);\n");
-  printf ("  if (insn_code == -1) fatal_insn_not_found (insn);\n");
   printf ("  insn = PATTERN (insn);\n");
   printf ("  switch (insn_code)\n");
   printf ("    {\n");
+  printf ("    case -1:\n");
+  printf ("      fatal_insn_not_found (insn);\n\n");
 
   /* Read the machine description.  */
 
@@ -379,35 +458,77 @@ from the machine description file `md'.  */\n\n");
 	  gen_insn (desc);
 	  ++insn_code_number;
 	}
-      if (GET_CODE (desc) == DEFINE_PEEPHOLE)
+
+      else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
 	{
-	  printf ("    case %d: goto peephole;\n", insn_code_number);
+	  struct code_ptr *link
+	    = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
+
+	  link->insn_code = insn_code_number;
+	  link->next = peepholes;
+	  peepholes = link;
 	  ++insn_code_number;
-	  ++peephole_seen;
 	}
-      if (GET_CODE (desc) == DEFINE_EXPAND || GET_CODE (desc) == DEFINE_SPLIT)
-	{
-	  printf ("    case %d: break;\n", insn_code_number);
+
+      else if (GET_CODE (desc) == DEFINE_EXPAND
+	       || GET_CODE (desc) == DEFINE_SPLIT)
 	++insn_code_number;
     }
-    }
 
-  /* This should never be reached.  */
-  printf ("\n    default:\n      abort ();\n");
-
-  if (peephole_seen)
+  /* Write out code to handle peepholes and the insn_codes that it should
+     be called for.  */
+  if (peepholes)
     {
+      for (link = peepholes; link; link = link->next)
+	printf ("    case %d:\n", link->insn_code);
+
       /* The vector in the insn says how many operands it has.
 	 And all it contains are operands.  In fact, the vector was
 	 created just for the sake of this function.  */
-      printf ("    peephole:\n");
       printf ("#if __GNUC__ > 1 && !defined (bcopy)\n");
       printf ("#define bcopy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT)\n");
       printf ("#endif\n");
       printf ("      bcopy (&XVECEXP (insn, 0, 0), ro,\n");
       printf ("             sizeof (rtx) * XVECLEN (insn, 0));\n");
-      printf ("      break;\n");
+      printf ("      break;\n\n");
+    }
+
+  /* Write out all the ways to extract insn operands.  */
+  for (p = extractions; p; p = p->next)
+    {
+      for (link = p->insns; link; link = link->next)
+	printf ("    case %d:\n", link->insn_code);
+
+      for (i = 0; i < p->op_count; i++)
+	{
+	  if (p->oplocs[i] == 0)
+	    {
+	      printf ("      ro[%d] = const0_rtx;\n", i);
+	      printf ("      ro_loc[%d] = &junk;\n", i, i);
 	    }
+	  else
+	    {
+	      printf ("      ro[%d] = *(ro_loc[%d] = &", i, i);
+	      print_path (p->oplocs[i]);
+	      printf (");\n");
+	    }
+	}
+
+      for (i = 0; i < p->dup_count; i++)
+	{
+	  printf ("      recog_dup_loc[%d] = &", i);
+	  print_path (p->duplocs[i]);
+	  printf (";\n");
+	  printf ("      recog_dup_num[%d] = %d;\n", i, p->dupnums[i]);
+	}
+
+      printf ("      break;\n\n");
+    }
+
+  /* This should never be reached.  Note that we would also reach this abort
+   if we tried to extract something whose INSN_CODE was a DEFINE_EXPAND or
+   DEFINE_SPLIT, but that is correct.  */
+  printf ("    default:\n      abort ();\n");
 
   printf ("    }\n}\n");