X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgensupport.c;h=e81682c7c21723019788786f81b0d5714a7b37d6;hb=cf609de46f6ab09fe2300129765da24925fd6833;hp=f25b80026ebdd16f1bf7f844eb6a005970689a65;hpb=f316cb53db7661842a26fe9f3ecec955c7065822;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/gensupport.c b/gcc/gensupport.c
index f25b80026eb..e81682c7c21 100644
--- a/gcc/gensupport.c
+++ b/gcc/gensupport.c
@@ -1,56 +1,72 @@
 /* Support routines for the various generation passes.
-   Copyright (C) 2000 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+   2010, 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)
+   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 3, 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 COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
 
-#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 "hashtab.h"
+#include "read-md.h"
 #include "gensupport.h"
 
 
+/* In case some macros used by files we include need it, define this here.  */
+int target_flags;
+
+int insn_elision = 1;
+
 static struct obstack obstack;
 struct obstack *rtl_obstack = &obstack;
 
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
 static int sequence_num;
-static int errors;
 
 static int predicable_default;
 static const char *predicable_true;
 static const char *predicable_false;
 
+static htab_t condition_table;
+
 /* We initially queue all patterns, process the define_insn and
    define_cond_exec patterns, then return them one at a time.  */
 
 struct queue_elem
 {
   rtx data;
+  const char *filename;
   int lineno;
   struct queue_elem *next;
+  /* In a DEFINE_INSN that came from a DEFINE_INSN_AND_SPLIT, SPLIT
+     points to the generated DEFINE_SPLIT.  */
+  struct queue_elem *split;
 };
 
+#define MNEMONIC_ATTR_NAME "mnemonic"
+#define MNEMONIC_HTAB_SIZE 1024
+
 static struct queue_elem *define_attr_queue;
 static struct queue_elem **define_attr_tail = &define_attr_queue;
+static struct queue_elem *define_pred_queue;
+static struct queue_elem **define_pred_tail = &define_pred_queue;
 static struct queue_elem *define_insn_queue;
 static struct queue_elem **define_insn_tail = &define_insn_queue;
 static struct queue_elem *define_cond_exec_queue;
@@ -58,71 +74,66 @@ static struct queue_elem **define_cond_exec_tail = &define_cond_exec_queue;
 static struct queue_elem *other_queue;
 static struct queue_elem **other_tail = &other_queue;
 
-static void queue_pattern PARAMS ((rtx, struct queue_elem ***, int));
-static void remove_constraints PARAMS ((rtx));
-static void process_rtx PARAMS ((rtx, int));
-
-static int is_predicable PARAMS ((struct queue_elem *));
-static void identify_predicable_attribute PARAMS ((void));
-static int n_alternatives PARAMS ((const char *));
-static void collect_insn_data PARAMS ((rtx, int *, int *));
-static rtx alter_predicate_for_insn PARAMS ((rtx, int, int, int));
-static const char *alter_test_for_insn PARAMS ((struct queue_elem *,
-						struct queue_elem *));
-static char *shift_output_template PARAMS ((char *, const char *, int));
-static const char *alter_output_for_insn PARAMS ((struct queue_elem *,
-						  struct queue_elem *,
-						  int, int));
-static void process_one_cond_exec PARAMS ((struct queue_elem *));
-static void process_define_cond_exec PARAMS ((void));
+static struct queue_elem *queue_pattern (rtx, struct queue_elem ***,
+					 const char *, int);
+
+static void remove_constraints (rtx);
+static void process_rtx (rtx, int);
+
+static int is_predicable (struct queue_elem *);
+static void identify_predicable_attribute (void);
+static int n_alternatives (const char *);
+static void collect_insn_data (rtx, int *, int *);
+static rtx alter_predicate_for_insn (rtx, int, int, int);
+static const char *alter_test_for_insn (struct queue_elem *,
+					struct queue_elem *);
+static char *shift_output_template (char *, const char *, int);
+static const char *alter_output_for_insn (struct queue_elem *,
+					  struct queue_elem *,
+					  int, int);
+static void process_one_cond_exec (struct queue_elem *);
+static void process_define_cond_exec (void);
+static void init_predicate_table (void);
+static void record_insn_name (int, const char *);
 
-void
-message_with_line VPARAMS ((int lineno, const char *msg, ...))
-{
-#ifndef ANSI_PROTOTYPES
-  int lineno;
-  const char *msg;
-#endif
-  va_list ap;
-
-  VA_START (ap, msg);
+/* Make a version of gen_rtx_CONST_INT so that GEN_INT can be used in
+   the gensupport programs.  */
 
-#ifndef ANSI_PROTOTYPES
-  lineno = va_arg (ap, int);
-  msg = va_arg (ap, const char *);
-#endif
-
-  fprintf (stderr, "%s:%d: ", read_rtx_filename, lineno);
-  vfprintf (stderr, msg, ap);
-  fputc ('\n', stderr);
+rtx
+gen_rtx_CONST_INT (enum machine_mode ARG_UNUSED (mode),
+		   HOST_WIDE_INT arg)
+{
+  rtx rt = rtx_alloc (CONST_INT);
 
-  va_end (ap);
+  XWINT (rt, 0) = arg;
+  return rt;
 }
 
-/* Queue PATTERN on LIST_TAIL.  */
+/* Queue PATTERN on LIST_TAIL.  Return the address of the new queue
+   element.  */
 
-static void
-queue_pattern (pattern, list_tail, lineno)
-     rtx pattern;
-     struct queue_elem ***list_tail;
-     int lineno;
+static struct queue_elem *
+queue_pattern (rtx pattern, struct queue_elem ***list_tail,
+	       const char *filename, int lineno)
 {
-  struct queue_elem *e = (struct queue_elem *) xmalloc (sizeof (*e));
+  struct queue_elem *e = XNEW(struct queue_elem);
   e->data = pattern;
+  e->filename = filename;
   e->lineno = lineno;
   e->next = NULL;
+  e->split = NULL;
   **list_tail = e;
   *list_tail = &e->next;
+  return e;
 }
 
 /* Recursively remove constraints from an rtx.  */
 
 static void
-remove_constraints (part)
-     rtx part;
+remove_constraints (rtx part)
 {
-  register int i, j;
-  register const char *format_ptr;
+  int i, j;
+  const char *format_ptr;
 
   if (part == 0)
     return;
@@ -149,34 +160,45 @@ remove_constraints (part)
       }
 }
 
-/* Process a top level rtx in some way, queueing as appropriate.  */
+/* Process a top level rtx in some way, queuing as appropriate.  */
 
 static void
-process_rtx (desc, lineno)
-     rtx desc;
-     int lineno;
+process_rtx (rtx desc, int lineno)
 {
   switch (GET_CODE (desc))
     {
     case DEFINE_INSN:
-      queue_pattern (desc, &define_insn_tail, lineno);
+      queue_pattern (desc, &define_insn_tail, read_md_filename, lineno);
       break;
 
     case DEFINE_COND_EXEC:
-      queue_pattern (desc, &define_cond_exec_tail, lineno);
+      queue_pattern (desc, &define_cond_exec_tail, read_md_filename, lineno);
       break;
 
     case DEFINE_ATTR:
-      queue_pattern (desc, &define_attr_tail, lineno);
+    case DEFINE_ENUM_ATTR:
+      queue_pattern (desc, &define_attr_tail, read_md_filename, lineno);
+      break;
+
+    case DEFINE_PREDICATE:
+    case DEFINE_SPECIAL_PREDICATE:
+    case DEFINE_CONSTRAINT:
+    case DEFINE_REGISTER_CONSTRAINT:
+    case DEFINE_MEMORY_CONSTRAINT:
+    case DEFINE_ADDRESS_CONSTRAINT:
+      queue_pattern (desc, &define_pred_tail, read_md_filename, lineno);
       break;
 
     case DEFINE_INSN_AND_SPLIT:
       {
 	const char *split_cond;
 	rtx split;
+	rtvec attr;
 	int i;
+	struct queue_elem *insn_elem;
+	struct queue_elem *split_elem;
 
-	/* Create a split with values from the insn_and_split. */
+	/* Create a split with values from the insn_and_split.  */
 	split = rtx_alloc (DEFINE_SPLIT);
 
 	i = XVECLEN (desc, 1);
@@ -192,33 +214,30 @@ process_rtx (desc, lineno)
 	split_cond = XSTR (desc, 4);
 	if (split_cond[0] == '&' && split_cond[1] == '&')
 	  {
-	    const char *insn_cond = XSTR (desc, 2);
-	    size_t insn_cond_len = strlen (insn_cond);
-	    size_t split_cond_len = strlen (split_cond);
-	    char *combined;
-
-	    combined = (char *) xmalloc (insn_cond_len + split_cond_len + 1);
-	    memcpy (combined, insn_cond, insn_cond_len);
-	    memcpy (combined + insn_cond_len, split_cond, split_cond_len + 1);
-
-	    split_cond = combined;
+	    copy_md_ptr_loc (split_cond + 2, split_cond);
+	    split_cond = join_c_conditions (XSTR (desc, 2), split_cond + 2);
 	  }
 	XSTR (split, 1) = split_cond;
 	XVEC (split, 2) = XVEC (desc, 5);
 	XSTR (split, 3) = XSTR (desc, 6);
 
 	/* Fix up the DEFINE_INSN.  */
+	attr = XVEC (desc, 7);
 	PUT_CODE (desc, DEFINE_INSN);
-	XVEC (desc, 4) = XVEC (desc, 7);
+	XVEC (desc, 4) = attr;
 
 	/* Queue them.  */
-	queue_pattern (desc, &define_insn_tail, lineno);
-	queue_pattern (split, &other_tail, lineno);
+	insn_elem
+	  = queue_pattern (desc, &define_insn_tail, read_md_filename,
+			   lineno);
+	split_elem
+	  = queue_pattern (split, &other_tail, read_md_filename, lineno);
+	insn_elem->split = split_elem;
 	break;
       }
 
     default:
-      queue_pattern (desc, &other_tail, lineno);
+      queue_pattern (desc, &other_tail, read_md_filename, lineno);
       break;
     }
 }
@@ -227,8 +246,7 @@ process_rtx (desc, lineno)
    a DEFINE_INSN.  */
 
 static int
-is_predicable (elem)
-     struct queue_elem *elem;
+is_predicable (struct queue_elem *elem)
 {
   rtvec vec = XVEC (elem->data, 4);
   const char *value;
@@ -253,9 +271,8 @@ is_predicable (elem)
 	case SET_ATTR_ALTERNATIVE:
 	  if (strcmp (XSTR (sub, 0), "predicable") == 0)
 	    {
-	      message_with_line (elem->lineno,
-				 "multiple alternatives for `predicable'");
-	      errors = 1;
+	      error_with_line (elem->lineno,
+			       "multiple alternatives for `predicable'");
 	      return 0;
 	    }
 	  break;
@@ -274,13 +291,12 @@ is_predicable (elem)
 	  /* ??? It would be possible to handle this if we really tried.
 	     It's not easy though, and I'm not going to bother until it
 	     really proves necessary.  */
-	  message_with_line (elem->lineno,
-			     "non-constant value for `predicable'");
-	  errors = 1;
+	  error_with_line (elem->lineno,
+			   "non-constant value for `predicable'");
 	  return 0;
 
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
     }
 
@@ -293,9 +309,7 @@ is_predicable (elem)
      to do this.  Delay this until we've got the basics solid.  */
   if (strchr (value, ',') != NULL)
     {
-      message_with_line (elem->lineno,
-			 "multiple alternatives for `predicable'");
-      errors = 1;
+      error_with_line (elem->lineno, "multiple alternatives for `predicable'");
       return 0;
     }
 
@@ -305,10 +319,8 @@ is_predicable (elem)
   if (strcmp (value, predicable_false) == 0)
     return 0;
 
-  message_with_line (elem->lineno,
-		     "Unknown value `%s' for `predicable' attribute",
-		     value);
-  errors = 1;
+  error_with_line (elem->lineno,
+		   "unknown value `%s' for `predicable' attribute", value);
   return 0;
 }
 
@@ -316,41 +328,36 @@ is_predicable (elem)
    and its default.  */
 
 static void
-identify_predicable_attribute ()
+identify_predicable_attribute (void)
 {
   struct queue_elem *elem;
-  char *true, *false;
+  char *p_true, *p_false;
   const char *value;
-  size_t len;
 
   /* Look for the DEFINE_ATTR for `predicable', which must exist.  */
   for (elem = define_attr_queue; elem ; elem = elem->next)
     if (strcmp (XSTR (elem->data, 0), "predicable") == 0)
       goto found;
 
-  message_with_line (define_cond_exec_queue->lineno,
-		     "Attribute `predicable' not defined");
-  errors = 1;
+  error_with_line (define_cond_exec_queue->lineno,
+		   "attribute `predicable' not defined");
   return;
 
  found:
   value = XSTR (elem->data, 1);
-  len = strlen (value);
-  false = (char *) xmalloc (len + 1);
-  memcpy (false, value, len + 1);
-
-  true = strchr (false, ',');
-  if (true == NULL || strchr (++true, ',') != NULL)
+  p_false = xstrdup (value);
+  p_true = strchr (p_false, ',');
+  if (p_true == NULL || strchr (++p_true, ',') != NULL)
     {
-      message_with_line (elem->lineno,
-			 "Attribute `predicable' is not a boolean");
-      errors = 1;
+      error_with_line (elem->lineno, "attribute `predicable' is not a boolean");
+      if (p_false)
+        free (p_false);
       return;
     }
-  true[-1] = '\0';
+  p_true[-1] = '\0';
 
-  predicable_true = true;
-  predicable_false = false;
+  predicable_true = p_true;
+  predicable_false = p_false;
 
   switch (GET_CODE (XEXP (elem->data, 2)))
     {
@@ -359,36 +366,36 @@ identify_predicable_attribute ()
       break;
 
     case CONST:
-      message_with_line (elem->lineno,
-			 "Attribute `predicable' cannot be const");
-      errors = 1;
+      error_with_line (elem->lineno, "attribute `predicable' cannot be const");
+      if (p_false)
+	free (p_false);
       return;
 
     default:
-      message_with_line (elem->lineno,
-			 "Attribute `predicable' must have a constant default");
-      errors = 1;
+      error_with_line (elem->lineno,
+		       "attribute `predicable' must have a constant default");
+      if (p_false)
+	free (p_false);
       return;
     }
 
-  if (strcmp (value, true) == 0)
+  if (strcmp (value, p_true) == 0)
     predicable_default = 1;
-  else if (strcmp (value, false) == 0)
+  else if (strcmp (value, p_false) == 0)
     predicable_default = 0;
   else
     {
-      message_with_line (elem->lineno,
-			 "Unknown value `%s' for `predicable' attribute",
-			 value);
-      errors = 1;
+      error_with_line (elem->lineno,
+		       "unknown value `%s' for `predicable' attribute", value);
+      if (p_false)
+	free (p_false);
     }
 }
 
 /* Return the number of alternatives in constraint S.  */
 
 static int
-n_alternatives (s)
-     const char *s;
+n_alternatives (const char *s)
 {
   int n = 1;
 
@@ -403,9 +410,7 @@ n_alternatives (s)
    operands.  */
 
 static void
-collect_insn_data (pattern, palt, pmax)
-     rtx pattern;
-     int *palt, *pmax;
+collect_insn_data (rtx pattern, int *palt, int *pmax)
 {
   const char *fmt;
   enum rtx_code code;
@@ -417,12 +422,11 @@ collect_insn_data (pattern, palt, pmax)
     case MATCH_OPERAND:
       i = n_alternatives (XSTR (pattern, 2));
       *palt = (i > *palt ? i : *palt);
-      /* FALLTHRU */
+      /* Fall through.  */
 
     case MATCH_OPERATOR:
     case MATCH_SCRATCH:
     case MATCH_PARALLEL:
-    case MATCH_INSN:
       i = XINT (pattern, 0);
       if (i > *pmax)
 	*pmax = i;
@@ -445,25 +449,23 @@ collect_insn_data (pattern, palt, pmax)
 	case 'V':
 	  if (XVEC (pattern, i) == NULL)
 	    break;
-	  /* FALLTHRU */
+	  /* Fall through.  */
 	case 'E':
 	  for (j = XVECLEN (pattern, i) - 1; j >= 0; --j)
 	    collect_insn_data (XVECEXP (pattern, i, j), palt, pmax);
 	  break;
 
-	case 'i': case 'w': case '0': case 's': case 'S':
+	case 'i': case 'w': case '0': case 's': case 'S': case 'T':
 	  break;
 
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
     }
 }
 
 static rtx
-alter_predicate_for_insn (pattern, alt, max_op, lineno)
-     rtx pattern;
-     int alt, max_op, lineno;
+alter_predicate_for_insn (rtx pattern, int alt, int max_op, int lineno)
 {
   const char *fmt;
   enum rtx_code code;
@@ -478,10 +480,8 @@ alter_predicate_for_insn (pattern, alt, max_op, lineno)
 
 	if (n_alternatives (c) != 1)
 	  {
-	    message_with_line (lineno,
-			       "Too many alternatives for operand %d",
-			       XINT (pattern, 0));
-	    errors = 1;
+	    error_with_line (lineno, "too many alternatives for operand %d",
+			     XINT (pattern, 0));
 	    return NULL;
 	  }
 
@@ -490,7 +490,7 @@ alter_predicate_for_insn (pattern, alt, max_op, lineno)
 	  {
 	    size_t c_len = strlen (c);
 	    size_t len = alt * (c_len + 1);
-	    char *new_c = (char *) xmalloc (len);
+	    char *new_c = XNEWVEC(char, len);
 
 	    memcpy (new_c, c, c_len);
 	    for (i = 1; i < alt; ++i)
@@ -502,12 +502,11 @@ alter_predicate_for_insn (pattern, alt, max_op, lineno)
 	    XSTR (pattern, 2) = new_c;
 	  }
       }
-      /* FALLTHRU */
+      /* Fall through.  */
 
     case MATCH_OPERATOR:
     case MATCH_SCRATCH:
     case MATCH_PARALLEL:
-    case MATCH_INSN:
       XINT (pattern, 0) += max_op;
       break;
 
@@ -544,7 +543,7 @@ alter_predicate_for_insn (pattern, alt, max_op, lineno)
 	  break;
 
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
     }
 
@@ -552,75 +551,54 @@ alter_predicate_for_insn (pattern, alt, max_op, lineno)
 }
 
 static const char *
-alter_test_for_insn (ce_elem, insn_elem)
-     struct queue_elem *ce_elem, *insn_elem;
+alter_test_for_insn (struct queue_elem *ce_elem,
+		     struct queue_elem *insn_elem)
 {
-  const char *ce_test, *insn_test;
-  char *new_test;
-  size_t len, ce_len, insn_len;
-
-  ce_test = XSTR (ce_elem->data, 1);
-  insn_test = XSTR (insn_elem->data, 2);
-  if (!ce_test || *ce_test == '\0')
-    return insn_test;
-  if (!insn_test || *insn_test == '\0')
-    return ce_test;
-
-  ce_len = strlen (ce_test);
-  insn_len = strlen (insn_test);
-  len = 1 + ce_len + 1 + 4 + 1 + insn_len + 1 + 1;
-  new_test = (char *) xmalloc (len);
-
-  sprintf (new_test, "(%s) && (%s)", ce_test, insn_test);
-
-  return new_test;
+  return join_c_conditions (XSTR (ce_elem->data, 1),
+			    XSTR (insn_elem->data, 2));
 }
 
-/* Adjust all of the operand numbers in OLD to match the shift they'll
+/* Adjust all of the operand numbers in SRC to match the shift they'll
    get from an operand displacement of DISP.  Return a pointer after the
    adjusted string.  */
 
 static char *
-shift_output_template (new, old, disp)
-     char *new;
-     const char *old;
-     int disp;
+shift_output_template (char *dest, const char *src, int disp)
 {
-  while (*old)
+  while (*src)
     {
-      char c = *old++;
-      *new++ = c;
+      char c = *src++;
+      *dest++ = c;
       if (c == '%')
 	{
-	  c = *old++;
+	  c = *src++;
 	  if (ISDIGIT ((unsigned char) c))
 	    c += disp;
-	  else if (ISUPPER ((unsigned char) c)
-		   || ISLOWER ((unsigned char) c))
+	  else if (ISALPHA (c))
 	    {
-	      *new++ = c;
-	      c = *old++ + disp;
+	      *dest++ = c;
+	      c = *src++ + disp;
 	    }
-	  *new++ = c;
+	  *dest++ = c;
 	}
     }
 
-  return new;
+  return dest;
 }
 
 static const char *
-alter_output_for_insn (ce_elem, insn_elem, alt, max_op)
-     struct queue_elem *ce_elem, *insn_elem;
-     int alt, max_op;
+alter_output_for_insn (struct queue_elem *ce_elem,
+		       struct queue_elem *insn_elem,
+		       int alt, int max_op)
 {
   const char *ce_out, *insn_out;
-  char *new, *p;
+  char *result, *p;
   size_t len, ce_len, insn_len;
 
   /* ??? Could coordinate with genoutput to not duplicate code here.  */
 
   ce_out = XSTR (ce_elem->data, 2);
-  insn_out = XSTR (insn_elem->data, 3);
+  insn_out = XTMPL (insn_elem->data, 3);
   if (!ce_out || *ce_out == '\0')
     return insn_out;
 
@@ -634,7 +612,7 @@ alter_output_for_insn (ce_elem, insn_elem, alt, max_op)
   if (*insn_out == '@')
     {
       len = (ce_len + 1) * alt + insn_len + 1;
-      p = new = xmalloc (len);
+      p = result = XNEWVEC(char, len);
 
       do
 	{
@@ -658,27 +636,28 @@ alter_output_for_insn (ce_elem, insn_elem, alt, max_op)
   else
     {
       len = ce_len + 1 + insn_len + 1;
-      new = xmalloc (len);
+      result = XNEWVEC (char, len);
 
-      p = shift_output_template (new, ce_out, max_op);
+      p = shift_output_template (result, ce_out, max_op);
       *p++ = ' ';
       memcpy (p, insn_out, insn_len + 1);
     }
 
-  return new;
+  return result;
 }
 
 /* Replicate insns as appropriate for the given DEFINE_COND_EXEC.  */
 
 static void
-process_one_cond_exec (ce_elem)
-     struct queue_elem *ce_elem;
+process_one_cond_exec (struct queue_elem *ce_elem)
 {
   struct queue_elem *insn_elem;
   for (insn_elem = define_insn_queue; insn_elem ; insn_elem = insn_elem->next)
     {
       int alternatives, max_operand;
-      rtx pred, insn, pattern;
+      rtx pred, insn, pattern, split;
+      char *new_name;
+      int i;
 
       if (! is_predicable (insn_elem))
 	continue;
@@ -690,9 +669,7 @@ process_one_cond_exec (ce_elem)
 
       if (XVECLEN (ce_elem->data, 0) != 1)
 	{
-	  message_with_line (ce_elem->lineno,
-			     "too many patterns in predicate");
-	  errors = 1;
+	  error_with_line (ce_elem->lineno, "too many patterns in predicate");
 	  return;
 	}
 
@@ -704,7 +681,9 @@ process_one_cond_exec (ce_elem)
 
       /* Construct a new pattern for the new insn.  */
       insn = copy_rtx (insn_elem->data);
-      XSTR (insn, 0) = "";
+      new_name = XNEWVAR (char, strlen XSTR (insn_elem->data, 0) + 4);
+      sprintf (new_name, "*p %s", XSTR (insn_elem->data, 0));
+      XSTR (insn, 0) = new_name;
       pattern = rtx_alloc (COND_EXEC);
       XEXP (pattern, 0) = pred;
       if (XVECLEN (insn, 1) == 1)
@@ -722,7 +701,7 @@ process_one_cond_exec (ce_elem)
 	}
 
       XSTR (insn, 2) = alter_test_for_insn (ce_elem, insn_elem);
-      XSTR (insn, 3) = alter_output_for_insn (ce_elem, insn_elem,
+      XTMPL (insn, 3) = alter_output_for_insn (ce_elem, insn_elem,
 					      alternatives, max_operand);
 
       /* ??? Set `predicable' to false.  Not crucial since it's really
@@ -739,7 +718,42 @@ process_one_cond_exec (ce_elem)
 	 patterns into the define_insn chain just after their generator
 	 is something we'll have to experiment with.  */
 
-      queue_pattern (insn, &other_tail, insn_elem->lineno);
+      queue_pattern (insn, &other_tail, insn_elem->filename,
+		     insn_elem->lineno);
+
+      if (!insn_elem->split)
+	continue;
+
+      /* If the original insn came from a define_insn_and_split,
+	 generate a new split to handle the predicated insn.  */
+      split = copy_rtx (insn_elem->split->data);
+      /* Predicate the pattern matched by the split.  */
+      pattern = rtx_alloc (COND_EXEC);
+      XEXP (pattern, 0) = pred;
+      if (XVECLEN (split, 0) == 1)
+	{
+	  XEXP (pattern, 1) = XVECEXP (split, 0, 0);
+	  XVECEXP (split, 0, 0) = pattern;
+	  PUT_NUM_ELEM (XVEC (split, 0), 1);
+	}
+      else
+	{
+	  XEXP (pattern, 1) = rtx_alloc (PARALLEL);
+	  XVEC (XEXP (pattern, 1), 0) = XVEC (split, 0);
+	  XVEC (split, 0) = rtvec_alloc (1);
+	  XVECEXP (split, 0, 0) = pattern;
+	}
+      /* Predicate all of the insns generated by the split.  */
+      for (i = 0; i < XVECLEN (split, 2); i++)
+	{
+	  pattern = rtx_alloc (COND_EXEC);
+	  XEXP (pattern, 0) = pred;
+	  XEXP (pattern, 1) = XVECEXP (split, 2, i);
+	  XVECEXP (split, 2, i) = pattern;
+	}
+      /* Add the new split to the queue.  */
+      queue_pattern (split, &other_tail, read_md_filename,
+		     insn_elem->split->lineno);
     }
 }
 
@@ -747,76 +761,289 @@ process_one_cond_exec (ce_elem)
    patterns appropriately.  */
 
 static void
-process_define_cond_exec ()
+process_define_cond_exec (void)
 {
   struct queue_elem *elem;
 
   identify_predicable_attribute ();
-  if (errors)
+  if (have_error)
     return;
 
   for (elem = define_cond_exec_queue; elem ; elem = elem->next)
     process_one_cond_exec (elem);
 }
 
-/* The entry point for initializing the reader.  */
+/* A read_md_files callback for reading an rtx.  */
 
-int
-init_md_reader (filename)
-     const char *filename;
+static void
+rtx_handle_directive (int lineno, const char *rtx_name)
+{
+  rtx queue, x;
+
+  if (read_rtx (rtx_name, &queue))
+    for (x = queue; x; x = XEXP (x, 1))
+      process_rtx (XEXP (x, 0), lineno);
+}
+
+/* Comparison function for the mnemonic hash table.  */
+
+static int
+htab_eq_string (const void *s1, const void *s2)
+{
+  return strcmp ((const char*)s1, (const char*)s2) == 0;
+}
+
+/* Add mnemonic STR with length LEN to the mnemonic hash table
+   MNEMONIC_HTAB.  A trailing zero end character is appendend to STR
+   and a permanent heap copy of STR is created.  */
+
+static void
+add_mnemonic_string (htab_t mnemonic_htab, const char *str, int len)
+{
+  char *new_str;
+  void **slot;
+  char *str_zero = (char*)alloca (len + 1);
+
+  memcpy (str_zero, str, len);
+  str_zero[len] = '\0';
+
+  slot = htab_find_slot (mnemonic_htab, str_zero, INSERT);
+
+  if (*slot)
+    return;
+
+  /* Not found; create a permanent copy and add it to the hash table.  */
+  new_str = XNEWVAR (char, len + 1);
+  memcpy (new_str, str_zero, len + 1);
+  *slot = new_str;
+}
+
+/* Scan INSN for mnemonic strings and add them to the mnemonic hash
+   table in MNEMONIC_HTAB.
+
+   The mnemonics cannot be found if they are emitted using C code.
+
+   If a mnemonic string contains ';' or a newline the string assumed
+   to consist of more than a single instruction.  The attribute value
+   will then be set to the user defined default value.  */
+
+static void
+gen_mnemonic_setattr (htab_t mnemonic_htab, rtx insn)
 {
-  FILE *input_file;
-  int c;
+  const char *template_code, *cp;
+  int i;
+  int vec_len;
+  rtx set_attr;
+  char *attr_name;
+  rtvec new_vec;
+
+  template_code = XTMPL (insn, 3);
+
+  /* Skip patterns which use C code to emit the template.  */
+  if (template_code[0] == '*')
+    return;
 
-  read_rtx_filename = filename;
-  input_file = fopen (filename, "r");
-  if (input_file == 0)
+  if (template_code[0] == '@')
+    cp = &template_code[1];
+  else
+    cp = &template_code[0];
+
+  for (i = 0; *cp; )
     {
-      perror (filename);
-      return FATAL_EXIT_CODE;
+      const char *ep, *sp;
+      int size = 0;
+
+      while (ISSPACE (*cp))
+	cp++;
+
+      for (ep = sp = cp; !IS_VSPACE (*ep) && *ep != '\0'; ++ep)
+	if (!ISSPACE (*ep))
+	  sp = ep + 1;
+
+      if (i > 0)
+	obstack_1grow (&string_obstack, ',');
+
+      while (cp < sp && ((*cp >= '0' && *cp <= '9')
+			 || (*cp >= 'a' && *cp <= 'z')))
+
+	{
+	  obstack_1grow (&string_obstack, *cp);
+	  cp++;
+	  size++;
+	}
+
+      while (cp < sp)
+	{
+	  if (*cp == ';' || (*cp == '\\' && cp[1] == 'n'))
+	    {
+	      /* Don't set a value if there are more than one
+		 instruction in the string.  */
+	      obstack_next_free (&string_obstack) =
+		obstack_next_free (&string_obstack) - size;
+	      size = 0;
+
+	      cp = sp;
+	      break;
+	    }
+	  cp++;
+	}
+      if (size == 0)
+	obstack_1grow (&string_obstack, '*');
+      else
+	add_mnemonic_string (mnemonic_htab,
+			     obstack_next_free (&string_obstack) - size,
+			     size);
+      i++;
     }
 
-  obstack_init (rtl_obstack);
-  errors = 0;
-  sequence_num = 0;
+  /* An insn definition might emit an empty string.  */
+  if (obstack_object_size (&string_obstack) == 0)
+    return;
 
-  /* Read the entire file.  */
-  while (1)
-    {
-      rtx desc;
-      int lineno;
+  obstack_1grow (&string_obstack, '\0');
+
+  set_attr = rtx_alloc (SET_ATTR);
+  XSTR (set_attr, 1) = XOBFINISH (&string_obstack, char *);
+  attr_name = XNEWVAR (char, strlen (MNEMONIC_ATTR_NAME) + 1);
+  strcpy (attr_name, MNEMONIC_ATTR_NAME);
+  XSTR (set_attr, 0) = attr_name;
+
+  if (!XVEC (insn, 4))
+    vec_len = 0;
+  else
+    vec_len = XVECLEN (insn, 4);
+
+  new_vec = rtvec_alloc (vec_len + 1);
+  for (i = 0; i < vec_len; i++)
+    RTVEC_ELT (new_vec, i) = XVECEXP (insn, 4, i);
+  RTVEC_ELT (new_vec, vec_len) = set_attr;
+  XVEC (insn, 4) = new_vec;
+}
 
-      c = read_skip_spaces (input_file);
-      if (c == EOF)
+/* This function is called for the elements in the mnemonic hashtable
+   and generates a comma separated list of the mnemonics.  */
+
+static int
+mnemonic_htab_callback (void **slot, void *info ATTRIBUTE_UNUSED)
+{
+  obstack_grow (&string_obstack, (char*)*slot, strlen ((char*)*slot));
+  obstack_1grow (&string_obstack, ',');
+  return 1;
+}
+
+/* Generate (set_attr "mnemonic" "..") RTXs and append them to every
+   insn definition in case the back end requests it by defining the
+   mnemonic attribute.  The values for the attribute will be extracted
+   from the output patterns of the insn definitions as far as
+   possible.  */
+
+static void
+gen_mnemonic_attr (void)
+{
+  struct queue_elem *elem;
+  rtx mnemonic_attr = NULL;
+  htab_t mnemonic_htab;
+  const char *str, *p;
+  int i;
+
+  if (have_error)
+    return;
+
+  /* Look for the DEFINE_ATTR for `mnemonic'.  */
+  for (elem = define_attr_queue; elem != *define_attr_tail; elem = elem->next)
+    if (GET_CODE (elem->data) == DEFINE_ATTR
+	&& strcmp (XSTR (elem->data, 0), MNEMONIC_ATTR_NAME) == 0)
+      {
+	mnemonic_attr = elem->data;
 	break;
+      }
+
+  /* A (define_attr "mnemonic" "...") indicates that the back-end
+     wants a mnemonic attribute to be generated.  */
+  if (!mnemonic_attr)
+    return;
 
-      ungetc (c, input_file);
-      lineno = read_rtx_lineno;
-      desc = read_rtx (input_file);
-      process_rtx (desc, lineno);
+  mnemonic_htab = htab_create_alloc (MNEMONIC_HTAB_SIZE, htab_hash_string,
+				     htab_eq_string, 0, xcalloc, free);
+
+  for (elem = define_insn_queue; elem; elem = elem->next)
+    {
+      rtx insn = elem->data;
+      bool found = false;
+
+      /* Check if the insn definition already has
+	 (set_attr "mnemonic" ...).  */
+      if (XVEC (insn, 4))
+ 	for (i = 0; i < XVECLEN (insn, 4); i++)
+	  if (strcmp (XSTR (XVECEXP (insn, 4, i), 0), MNEMONIC_ATTR_NAME) == 0)
+	    {
+	      found = true;
+	      break;
+	    }
+
+      if (!found)
+	gen_mnemonic_setattr (mnemonic_htab, insn);
     }
-  fclose (input_file);
+
+  /* Add the user defined values to the hash table.  */
+  str = XSTR (mnemonic_attr, 1);
+  while ((p = scan_comma_elt (&str)) != NULL)
+    add_mnemonic_string (mnemonic_htab, p, str - p);
+
+  htab_traverse (mnemonic_htab, mnemonic_htab_callback, NULL);
+
+  /* Replace the last ',' with the zero end character.  */
+  *((char *)obstack_next_free (&string_obstack) - 1) = '\0';
+  XSTR (mnemonic_attr, 1) = XOBFINISH (&string_obstack, char *);
+}
+
+/* The entry point for initializing the reader.  */
+
+bool
+init_rtx_reader_args_cb (int argc, char **argv,
+			 bool (*parse_opt) (const char *))
+{
+  /* Prepare to read input.  */
+  condition_table = htab_create (500, hash_c_test, cmp_c_test, NULL);
+  init_predicate_table ();
+  obstack_init (rtl_obstack);
+  sequence_num = 0;
+
+  read_md_files (argc, argv, parse_opt, rtx_handle_directive);
 
   /* Process define_cond_exec patterns.  */
   if (define_cond_exec_queue != NULL)
     process_define_cond_exec ();
 
-  return errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
+  if (define_attr_queue != NULL)
+    gen_mnemonic_attr ();
+
+  return !have_error;
 }
 
+/* Programs that don't have their own options can use this entry point
+   instead.  */
+bool
+init_rtx_reader_args (int argc, char **argv)
+{
+  return init_rtx_reader_args_cb (argc, argv, 0);
+}
+
 /* The entry point for reading a single rtx from an md file.  */
 
 rtx
-read_md_rtx (lineno, seqnr)
-     int *lineno;
-     int *seqnr;
+read_md_rtx (int *lineno, int *seqnr)
 {
   struct queue_elem **queue, *elem;
   rtx desc;
 
+ discard:
+
   /* Read all patterns from a given queue before moving on to the next.  */
   if (define_attr_queue != NULL)
     queue = &define_attr_queue;
+  else if (define_pred_queue != NULL)
+    queue = &define_pred_queue;
   else if (define_insn_queue != NULL)
     queue = &define_insn_queue;
   else if (other_queue != NULL)
@@ -827,19 +1054,39 @@ read_md_rtx (lineno, seqnr)
   elem = *queue;
   *queue = elem->next;
   desc = elem->data;
+  read_md_filename = elem->filename;
   *lineno = elem->lineno;
   *seqnr = sequence_num;
 
   free (elem);
 
+  /* Discard insn patterns which we know can never match (because
+     their C test is provably always false).  If insn_elision is
+     false, our caller needs to see all the patterns.  Note that the
+     elided patterns are never counted by the sequence numbering; it
+     it is the caller's responsibility, when insn_elision is false, not
+     to use elided pattern numbers for anything.  */
   switch (GET_CODE (desc))
     {
     case DEFINE_INSN:
     case DEFINE_EXPAND:
+      if (maybe_eval_c_test (XSTR (desc, 2)) != 0)
+	sequence_num++;
+      else if (insn_elision)
+	goto discard;
+
+      /* *seqnr is used here so the name table will match caller's
+	 idea of insn numbering, whether or not elision is active.  */
+      record_insn_name (*seqnr, XSTR (desc, 0));
+      break;
+
     case DEFINE_SPLIT:
     case DEFINE_PEEPHOLE:
     case DEFINE_PEEPHOLE2:
-      sequence_num++;
+      if (maybe_eval_c_test (XSTR (desc, 1)) != 0)
+	sequence_num++;
+      else if (insn_elision)
+	    goto discard;
       break;
 
     default:
@@ -849,39 +1096,274 @@ read_md_rtx (lineno, seqnr)
   return desc;
 }
 
-/* Until we can use the versions in libiberty.  */
-char *
-xstrdup (input)
-  const char *input;
+/* Helper functions for insn elision.  */
+
+/* Compute a hash function of a c_test structure, which is keyed
+   by its ->expr field.  */
+hashval_t
+hash_c_test (const void *x)
 {
-  register size_t len = strlen (input) + 1;
-  register char *output = xmalloc (len);
-  memcpy (output, input, len);
-  return output;
+  const struct c_test *a = (const struct c_test *) x;
+  const unsigned char *base, *s = (const unsigned char *) a->expr;
+  hashval_t hash;
+  unsigned char c;
+  unsigned int len;
+
+  base = s;
+  hash = 0;
+
+  while ((c = *s++) != '\0')
+    {
+      hash += c + (c << 17);
+      hash ^= hash >> 2;
+    }
+
+  len = s - base;
+  hash += len + (len << 17);
+  hash ^= hash >> 2;
+
+  return hash;
 }
 
-PTR
-xrealloc (old, size)
-  PTR old;
-  size_t size;
+/* Compare two c_test expression structures.  */
+int
+cmp_c_test (const void *x, const void *y)
+{
+  const struct c_test *a = (const struct c_test *) x;
+  const struct c_test *b = (const struct c_test *) y;
+
+  return !strcmp (a->expr, b->expr);
+}
+
+/* Given a string representing a C test expression, look it up in the
+   condition_table and report whether or not its value is known
+   at compile time.  Returns a tristate: 1 for known true, 0 for
+   known false, -1 for unknown.  */
+int
+maybe_eval_c_test (const char *expr)
+{
+  const struct c_test *test;
+  struct c_test dummy;
+
+  if (expr[0] == 0)
+    return 1;
+
+  dummy.expr = expr;
+  test = (const struct c_test *)htab_find (condition_table, &dummy);
+  if (!test)
+    return -1;
+  return test->value;
+}
+
+/* Record the C test expression EXPR in the condition_table, with
+   value VAL.  Duplicates clobber previous entries.  */
+
+void
+add_c_test (const char *expr, int value)
+{
+  struct c_test *test;
+
+  if (expr[0] == 0)
+    return;
+
+  test = XNEW (struct c_test);
+  test->expr = expr;
+  test->value = value;
+
+  *(htab_find_slot (condition_table, test, INSERT)) = test;
+}
+
+/* For every C test, call CALLBACK with two arguments: a pointer to
+   the condition structure and INFO.  Stops when CALLBACK returns zero.  */
+void
+traverse_c_tests (htab_trav callback, void *info)
+{
+  if (condition_table)
+    htab_traverse (condition_table, callback, info);
+}
+
+/* Helper functions for define_predicate and define_special_predicate
+   processing.  Shared between genrecog.c and genpreds.c.  */
+
+static htab_t predicate_table;
+struct pred_data *first_predicate;
+static struct pred_data **last_predicate = &first_predicate;
+
+static hashval_t
+hash_struct_pred_data (const void *ptr)
 {
-  register PTR ptr;
-  if (old)
-    ptr = (PTR) realloc (old, size);
+  return htab_hash_string (((const struct pred_data *)ptr)->name);
+}
+
+static int
+eq_struct_pred_data (const void *a, const void *b)
+{
+  return !strcmp (((const struct pred_data *)a)->name,
+		  ((const struct pred_data *)b)->name);
+}
+
+struct pred_data *
+lookup_predicate (const char *name)
+{
+  struct pred_data key;
+  key.name = name;
+  return (struct pred_data *) htab_find (predicate_table, &key);
+}
+
+/* Record that predicate PRED can accept CODE.  */
+
+void
+add_predicate_code (struct pred_data *pred, enum rtx_code code)
+{
+  if (!pred->codes[code])
+    {
+      pred->num_codes++;
+      pred->codes[code] = true;
+
+      if (GET_RTX_CLASS (code) != RTX_CONST_OBJ)
+	pred->allows_non_const = true;
+
+      if (code != REG
+	  && code != SUBREG
+	  && code != MEM
+	  && code != CONCAT
+	  && code != PARALLEL
+	  && code != STRICT_LOW_PART)
+	pred->allows_non_lvalue = true;
+
+      if (pred->num_codes == 1)
+	pred->singleton = code;
+      else if (pred->num_codes == 2)
+	pred->singleton = UNKNOWN;
+    }
+}
+
+void
+add_predicate (struct pred_data *pred)
+{
+  void **slot = htab_find_slot (predicate_table, pred, INSERT);
+  if (*slot)
+    {
+      error ("duplicate predicate definition for '%s'", pred->name);
+      return;
+    }
+  *slot = pred;
+  *last_predicate = pred;
+  last_predicate = &pred->next;
+}
+
+/* This array gives the initial content of the predicate table.  It
+   has entries for all predicates defined in recog.c.  */
+
+struct std_pred_table
+{
+  const char *name;
+  bool special;
+  bool allows_const_p;
+  RTX_CODE codes[NUM_RTX_CODE];
+};
+
+static const struct std_pred_table std_preds[] = {
+  {"general_operand", false, true, {SUBREG, REG, MEM}},
+  {"address_operand", true, true, {SUBREG, REG, MEM, PLUS, MINUS, MULT}},
+  {"register_operand", false, false, {SUBREG, REG}},
+  {"pmode_register_operand", true, false, {SUBREG, REG}},
+  {"scratch_operand", false, false, {SCRATCH, REG}},
+  {"immediate_operand", false, true, {UNKNOWN}},
+  {"const_int_operand", false, false, {CONST_INT}},
+  {"const_double_operand", false, false, {CONST_INT, CONST_DOUBLE}},
+  {"nonimmediate_operand", false, false, {SUBREG, REG, MEM}},
+  {"nonmemory_operand", false, true, {SUBREG, REG}},
+  {"push_operand", false, false, {MEM}},
+  {"pop_operand", false, false, {MEM}},
+  {"memory_operand", false, false, {SUBREG, MEM}},
+  {"indirect_operand", false, false, {SUBREG, MEM}},
+  {"ordered_comparison_operator", false, false, {EQ, NE,
+						 LE, LT, GE, GT,
+						 LEU, LTU, GEU, GTU}},
+  {"comparison_operator", false, false, {EQ, NE,
+					 LE, LT, GE, GT,
+					 LEU, LTU, GEU, GTU,
+					 UNORDERED, ORDERED,
+					 UNEQ, UNGE, UNGT,
+					 UNLE, UNLT, LTGT}}
+};
+#define NUM_KNOWN_STD_PREDS ARRAY_SIZE (std_preds)
+
+/* Initialize the table of predicate definitions, starting with
+   the information we have on generic predicates.  */
+
+static void
+init_predicate_table (void)
+{
+  size_t i, j;
+  struct pred_data *pred;
+
+  predicate_table = htab_create_alloc (37, hash_struct_pred_data,
+				       eq_struct_pred_data, 0,
+				       xcalloc, free);
+
+  for (i = 0; i < NUM_KNOWN_STD_PREDS; i++)
+    {
+      pred = XCNEW (struct pred_data);
+      pred->name = std_preds[i].name;
+      pred->special = std_preds[i].special;
+
+      for (j = 0; std_preds[i].codes[j] != 0; j++)
+	add_predicate_code (pred, std_preds[i].codes[j]);
+
+      if (std_preds[i].allows_const_p)
+	for (j = 0; j < NUM_RTX_CODE; j++)
+	  if (GET_RTX_CLASS (j) == RTX_CONST_OBJ)
+	    add_predicate_code (pred, (enum rtx_code) j);
+
+      add_predicate (pred);
+    }
+}
+
+/* These functions allow linkage with print-rtl.c.  Also, some generators
+   like to annotate their output with insn names.  */
+
+/* Holds an array of names indexed by insn_code_number.  */
+static char **insn_name_ptr = 0;
+static int insn_name_ptr_size = 0;
+
+const char *
+get_insn_name (int code)
+{
+  if (code < insn_name_ptr_size)
+    return insn_name_ptr[code];
   else
-    ptr = (PTR) malloc (size);
-  if (!ptr)
-    fatal ("virtual memory exhausted");
-  return ptr;
+    return NULL;
 }
 
-PTR
-xmalloc (size)
-  size_t size;
+static void
+record_insn_name (int code, const char *name)
 {
-  register PTR val = (PTR) malloc (size);
+  static const char *last_real_name = "insn";
+  static int last_real_code = 0;
+  char *new_name;
+
+  if (insn_name_ptr_size <= code)
+    {
+      int new_size;
+      new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
+      insn_name_ptr = XRESIZEVEC (char *, insn_name_ptr, new_size);
+      memset (insn_name_ptr + insn_name_ptr_size, 0,
+	      sizeof(char *) * (new_size - insn_name_ptr_size));
+      insn_name_ptr_size = new_size;
+    }
+
+  if (!name || name[0] == '\0')
+    {
+      new_name = XNEWVAR (char, strlen (last_real_name) + 10);
+      sprintf (new_name, "%s+%d", last_real_name, code - last_real_code);
+    }
+  else
+    {
+      last_real_name = new_name = xstrdup (name);
+      last_real_code = code;
+    }
 
-  if (val == 0)
-    fatal ("virtual memory exhausted");
-  return val;
+  insn_name_ptr[code] = new_name;
 }