X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fgensupport.c;h=1fb45c0835f165439cebe4618cae1702ca169cb0;hp=9c46ded7922068cbc5770ac592c01038becc6194;hb=b98c35c607c0cac7532f0a03c16415c9a950bdf7;hpb=ee582a61a63edc4257e8bb2f52ab65356f165249

diff --git a/gcc/gensupport.c b/gcc/gensupport.c
index 9c46ded7922..1fb45c0835f 100644
--- a/gcc/gensupport.c
+++ b/gcc/gensupport.c
@@ -1,5 +1,6 @@
 /* Support routines for the various generation passes.
-   Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2002, 2003, 2004
+   Free Software Foundation, Inc.
 
    This file is part of GCC.
 
@@ -34,6 +35,8 @@ int target_flags;
 
 int insn_elision = 1;
 
+const char *in_fname;
+
 static struct obstack obstack;
 struct obstack *rtl_obstack = &obstack;
 
@@ -57,10 +60,15 @@ struct queue_elem
   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;
 };
 
 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;
@@ -68,8 +76,8 @@ 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 ***,
-				   const char *, int));
+static struct queue_elem *queue_pattern (rtx, struct queue_elem ***,
+					 const char *, int);
 
 /* Current maximum length of directory names in the search path
    for include files.  (Altered as we get more of them.)  */
@@ -87,30 +95,31 @@ struct file_name_list *first_dir_md_include = 0;  /* First dir to search */
 struct file_name_list *first_bracket_include = 0;
 struct file_name_list *last_dir_md_include = 0;        /* Last in chain */
 
-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 void process_include PARAMS ((rtx, int));
-static char *save_string PARAMS ((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 process_include (rtx, int);
+static char *save_string (const char *, int);
+static void init_predicate_table (void);
 
 void
 message_with_line (int lineno, const char *msg, ...)
 {
   va_list ap;
-  
+
   va_start (ap, msg);
 
   fprintf (stderr, "%s:%d: ", read_rtx_filename, lineno);
@@ -124,9 +133,8 @@ message_with_line (int lineno, const char *msg, ...)
    the gensupport programs.  */
 
 rtx
-gen_rtx_CONST_INT (mode, arg)
-     enum machine_mode mode ATTRIBUTE_UNUSED;
-     HOST_WIDE_INT arg;
+gen_rtx_CONST_INT (enum machine_mode ARG_UNUSED (mode),
+		   HOST_WIDE_INT arg)
 {
   rtx rt = rtx_alloc (CONST_INT);
 
@@ -134,29 +142,28 @@ gen_rtx_CONST_INT (mode, 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, filename, lineno)
-     rtx pattern;
-     struct queue_elem ***list_tail;
-     const char *filename;
-     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)
 {
   int i, j;
   const char *format_ptr;
@@ -186,13 +193,11 @@ remove_constraints (part)
       }
 }
 
-/* Process an include file assuming that it lives in gcc/config/{target}/ 
+/* Process an include file assuming that it lives in gcc/config/{target}/
    if the include looks like (include "file").  */
 
 static void
-process_include (desc, lineno)
-     rtx desc;
-     int lineno;
+process_include (rtx desc, int lineno)
 {
   const char *filename = XSTR (desc, 0);
   const char *old_filename;
@@ -201,7 +206,7 @@ process_include (desc, lineno)
   FILE *input_file;
 
   /* If specified file name is absolute, skip the include stack.  */
-  if (! IS_ABSOLUTE_PATHNAME (filename))
+  if (! IS_ABSOLUTE_PATH (filename))
     {
       struct file_name_list *stackp;
 
@@ -212,7 +217,7 @@ process_include (desc, lineno)
 
 	  pathname = concat (stackp->fname, sep, filename, NULL);
 	  input_file = fopen (pathname, "r");
-	  if (input_file != NULL) 
+	  if (input_file != NULL)
 	    goto success;
 	  free (pathname);
 	}
@@ -241,20 +246,8 @@ process_include (desc, lineno)
   read_rtx_lineno = 1;
 
   /* Read the entire file.  */
-  while (1)
-    {
-      rtx desc;
-      int c;
-
-      c = read_skip_spaces (input_file);
-      if (c == EOF)
-	break;
-
-      ungetc (c, input_file);
-      lineno = read_rtx_lineno;
-      desc = read_rtx (input_file);
-      process_rtx (desc, lineno);
-    }
+  while (read_rtx (input_file, &desc, &lineno))
+    process_rtx (desc, lineno);
 
   /* Do not free pathname.  It is attached to the various rtx queue
      elements.  */
@@ -265,12 +258,10 @@ process_include (desc, lineno)
   fclose (input_file);
 }
 
-/* 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))
     {
@@ -286,6 +277,11 @@ process_rtx (desc, lineno)
       queue_pattern (desc, &define_attr_tail, read_rtx_filename, lineno);
       break;
 
+    case DEFINE_PREDICATE:
+    case DEFINE_SPECIAL_PREDICATE:
+      queue_pattern (desc, &define_pred_tail, read_rtx_filename, lineno);
+      break;
+
     case INCLUDE:
       process_include (desc, lineno);
       break;
@@ -296,6 +292,8 @@ process_rtx (desc, lineno)
 	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.  */
 	split = rtx_alloc (DEFINE_SPLIT);
@@ -323,8 +321,12 @@ process_rtx (desc, lineno)
 	XVEC (desc, 4) = attr;
 
 	/* Queue them.  */
-	queue_pattern (desc, &define_insn_tail, read_rtx_filename, lineno);
-	queue_pattern (split, &other_tail, read_rtx_filename, lineno);
+	insn_elem
+	  = queue_pattern (desc, &define_insn_tail, read_rtx_filename, 
+			   lineno);
+	split_elem
+	  = queue_pattern (split, &other_tail, read_rtx_filename, lineno);
+	insn_elem->split = split_elem;
 	break;
       }
 
@@ -338,8 +340,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;
@@ -391,7 +392,7 @@ is_predicable (elem)
 	  return 0;
 
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
     }
 
@@ -427,7 +428,7 @@ is_predicable (elem)
    and its default.  */
 
 static void
-identify_predicable_attribute ()
+identify_predicable_attribute (void)
 {
   struct queue_elem *elem;
   char *p_true, *p_false;
@@ -494,8 +495,7 @@ identify_predicable_attribute ()
 /* Return the number of alternatives in constraint S.  */
 
 static int
-n_alternatives (s)
-     const char *s;
+n_alternatives (const char *s)
 {
   int n = 1;
 
@@ -510,9 +510,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;
@@ -524,12 +522,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;
@@ -552,7 +549,7 @@ 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);
@@ -562,15 +559,13 @@ collect_insn_data (pattern, palt, pmax)
 	  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;
@@ -597,7 +592,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)
@@ -609,12 +604,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;
 
@@ -651,7 +645,7 @@ alter_predicate_for_insn (pattern, alt, max_op, lineno)
 	  break;
 
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
     }
 
@@ -659,8 +653,8 @@ 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;
 
@@ -674,44 +668,41 @@ alter_test_for_insn (ce_elem, insn_elem)
   return concat ("(", ce_test, ") && (", insn_test, ")", NULL);
 }
 
-/* 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 (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.  */
@@ -731,7 +722,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
 	{
@@ -755,27 +746,27 @@ 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;
+      int i;
 
       if (! is_predicable (insn_elem))
 	continue;
@@ -838,6 +829,40 @@ process_one_cond_exec (ce_elem)
 
       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_rtx_filename, 
+		     insn_elem->split->lineno);
     }
 }
 
@@ -845,7 +870,7 @@ process_one_cond_exec (ce_elem)
    patterns appropriately.  */
 
 static void
-process_define_cond_exec ()
+process_define_cond_exec (void)
 {
   struct queue_elem *elem;
 
@@ -858,11 +883,9 @@ process_define_cond_exec ()
 }
 
 static char *
-save_string (s, len)
-     const char *s;
-     int len;
+save_string (const char *s, int len)
 {
-  register char *result = xmalloc (len + 1);
+  char *result = XNEWVEC (char, len + 1);
 
   memcpy (result, s, len);
   result[len] = 0;
@@ -873,21 +896,22 @@ save_string (s, len)
 /* The entry point for initializing the reader.  */
 
 int
-init_md_reader_args (argc, argv)
-     int argc;
-     char **argv;
+init_md_reader_args_cb (int argc, char **argv, bool (*parse_opt)(const char *))
 {
-  int i;
-  const char *in_fname;
+  FILE *input_file;
+  int i, lineno;
+  size_t ix;
+  char *lastsl;
+  rtx desc;
 
-  max_include_len = 0;
-  in_fname = NULL;
   for (i = 1; i < argc; i++)
     {
       if (argv[i][0] != '-')
 	{
-	  if (in_fname == NULL)
-	    in_fname = argv[i];
+	  if (in_fname)
+	    fatal ("too many input files");
+
+	  in_fname = argv[i];
 	}
       else
 	{
@@ -898,8 +922,7 @@ init_md_reader_args (argc, argv)
 	      {
 		struct file_name_list *dirtmp;
 
-		dirtmp = (struct file_name_list *)
-		  xmalloc (sizeof (struct file_name_list));
+		dirtmp = XNEW (struct file_name_list);
 		dirtmp->next = 0;	/* New one goes on the end */
 		if (first_dir_md_include == 0)
 		  first_dir_md_include = dirtmp;
@@ -917,34 +940,28 @@ init_md_reader_args (argc, argv)
 	      }
 	      break;
 	    default:
-	      fatal ("invalid option `%s'", argv[i]);
+	      /* The program may have provided a callback so it can
+		 accept its own options.  */
+	      if (parse_opt && parse_opt (argv[i]))
+		break;
 
+	      fatal ("invalid option `%s'", argv[i]);
 	    }
 	}
     }
-    return init_md_reader (in_fname);
-}
-
-/* The entry point for initializing the reader.  */
 
-int
-init_md_reader (filename)
-     const char *filename;
-{
-  FILE *input_file;
-  int c;
-  size_t i;
-  char *lastsl;
+  if (!in_fname)
+    fatal ("no input file name");
 
-  lastsl = strrchr (filename, '/');
-  if (lastsl != NULL) 
-    base_dir = save_string (filename, lastsl - filename + 1 );
+  lastsl = strrchr (in_fname, '/');
+  if (lastsl != NULL)
+    base_dir = save_string (in_fname, lastsl - in_fname + 1 );
 
-  read_rtx_filename = filename;
-  input_file = fopen (filename, "r");
+  read_rtx_filename = in_fname;
+  input_file = fopen (in_fname, "r");
   if (input_file == 0)
     {
-      perror (filename);
+      perror (in_fname);
       return FATAL_EXIT_CODE;
     }
 
@@ -952,29 +969,19 @@ init_md_reader (filename)
   condition_table = htab_create (n_insn_conditions,
 				 hash_c_test, cmp_c_test, NULL);
 
-  for (i = 0; i < n_insn_conditions; i++)
-    *(htab_find_slot (condition_table, (PTR) &insn_conditions[i], INSERT))
-      = (PTR) &insn_conditions[i];
+  for (ix = 0; ix < n_insn_conditions; ix++)
+    *(htab_find_slot (condition_table, &insn_conditions[ix], INSERT))
+      = (void *) &insn_conditions[ix];
+
+  init_predicate_table ();
 
   obstack_init (rtl_obstack);
   errors = 0;
   sequence_num = 0;
 
   /* Read the entire file.  */
-  while (1)
-    {
-      rtx desc;
-      int lineno;
-
-      c = read_skip_spaces (input_file);
-      if (c == EOF)
-        break;
-
-      ungetc (c, input_file);
-      lineno = read_rtx_lineno;
-      desc = read_rtx (input_file);
-      process_rtx (desc, lineno);
-    }
+  while (read_rtx (input_file, &desc, &lineno))
+    process_rtx (desc, lineno);
   fclose (input_file);
 
   /* Process define_cond_exec patterns.  */
@@ -984,12 +991,18 @@ init_md_reader (filename)
   return errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
 }
 
+/* Programs that don't have their own options can use this entry point
+   instead.  */
+int
+init_md_reader_args (int argc, char **argv)
+{
+  return init_md_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;
@@ -999,6 +1012,8 @@ read_md_rtx (lineno, seqnr)
   /* 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)
@@ -1052,8 +1067,7 @@ read_md_rtx (lineno, seqnr)
 /* Compute a hash function of a c_test structure, which is keyed
    by its ->expr field.  */
 hashval_t
-hash_c_test (x)
-     const PTR x;
+hash_c_test (const void *x)
 {
   const struct c_test *a = (const struct c_test *) x;
   const unsigned char *base, *s = (const unsigned char *) a->expr;
@@ -1079,9 +1093,7 @@ hash_c_test (x)
 
 /* Compare two c_test expression structures.  */
 int
-cmp_c_test (x, y)
-     const PTR x;
-     const PTR y;
+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;
@@ -1094,8 +1106,7 @@ cmp_c_test (x, y)
    at compile time.  Returns a tristate: 1 for known true, 0 for
    known false, -1 for unknown.  */
 int
-maybe_eval_c_test (expr)
-     const char *expr;
+maybe_eval_c_test (const char *expr)
 {
   const struct c_test *test;
   struct c_test dummy;
@@ -1107,9 +1118,8 @@ maybe_eval_c_test (expr)
     return -1;
 
   dummy.expr = expr;
-  test = (const struct c_test *) htab_find (condition_table, &dummy);
-  if (!test)
-    abort ();
+  test = (const struct c_test *)htab_find (condition_table, &dummy);
+  gcc_assert (test);
 
   return test->value;
 }
@@ -1117,8 +1127,7 @@ maybe_eval_c_test (expr)
 /* Given a string, return the number of comma-separated elements in it.
    Return 0 for the null string.  */
 int
-n_comma_elts (s)
-     const char *s;
+n_comma_elts (const char *s)
 {
   int n;
 
@@ -1139,8 +1148,7 @@ n_comma_elts (s)
    a comma and an element is ignored.  */
 
 const char *
-scan_comma_elt (pstr)
-     const char **pstr;
+scan_comma_elt (const char **pstr)
 {
   const char *start;
   const char *p = *pstr;
@@ -1161,3 +1169,154 @@ scan_comma_elt (pstr)
   *pstr = p;
   return start;
 }
+
+/* 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)
+{
+  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 htab_find (predicate_table, &key);
+}
+
+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.  The back end
+   can define PREDICATE_CODES to give additional entries for the
+   table; this is considered an obsolete mechanism (use
+   define_predicate instead).  */
+
+struct old_pred_table
+{
+  const char *name;
+  RTX_CODE codes[NUM_RTX_CODE];
+};
+
+static const struct old_pred_table old_preds[] = {
+  {"general_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
+		       LABEL_REF, SUBREG, REG, MEM }},
+  {"address_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
+		       LABEL_REF, SUBREG, REG, MEM,
+		       PLUS, MINUS, MULT}},
+  {"register_operand", {SUBREG, REG}},
+  {"pmode_register_operand", {SUBREG, REG}},
+  {"scratch_operand", {SCRATCH, REG}},
+  {"immediate_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
+			 LABEL_REF}},
+  {"const_int_operand", {CONST_INT}},
+  {"const_double_operand", {CONST_INT, CONST_DOUBLE}},
+  {"nonimmediate_operand", {SUBREG, REG, MEM}},
+  {"nonmemory_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
+			 LABEL_REF, SUBREG, REG}},
+  {"push_operand", {MEM}},
+  {"pop_operand", {MEM}},
+  {"memory_operand", {SUBREG, MEM}},
+  {"indirect_operand", {SUBREG, MEM}},
+  {"comparison_operator", {EQ, NE, LE, LT, GE, GT, LEU, LTU, GEU, GTU,
+			   UNORDERED, ORDERED, UNEQ, UNGE, UNGT, UNLE,
+			   UNLT, LTGT}},
+#ifdef PREDICATE_CODES
+  PREDICATE_CODES
+#endif
+};
+#define NUM_KNOWN_OLD_PREDS ARRAY_SIZE (old_preds)
+
+/* This table gives the initial set of special predicates.  It has
+   entries for all special predicates defined in recog.c.  The back
+   end can define SPECIAL_MODE_PREDICATES to give additional entries
+   for the table; this is considered an obsolete mechanism (use
+   define_special_predicate instead).  */
+static const char *const old_special_pred_table[] = {
+  "address_operand",
+  "pmode_register_operand",
+#ifdef SPECIAL_MODE_PREDICATES
+  SPECIAL_MODE_PREDICATES
+#endif
+};
+
+#define NUM_OLD_SPECIAL_MODE_PREDS ARRAY_SIZE (old_special_pred_table)
+
+/* Initialize the table of predicate definitions, starting with
+   the information we have on generic predicates, and the old-style
+   PREDICATE_CODES definitions.  */
+
+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_OLD_PREDS; i++)
+    {
+      pred = xcalloc (sizeof (struct pred_data), 1);
+      pred->name = old_preds[i].name;
+
+      for (j = 0; old_preds[i].codes[j] != 0; j++)
+	{
+	  enum rtx_code code = old_preds[i].codes[j];
+
+	  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 (j == 1)
+	pred->singleton = old_preds[i].codes[0];
+      
+      add_predicate (pred);
+    }
+
+  for (i = 0; i < NUM_OLD_SPECIAL_MODE_PREDS; i++)
+    {
+      pred = lookup_predicate (old_special_pred_table[i]);
+      if (!pred)
+	{
+	  error ("old-style special predicate list refers "
+		 "to unknown predicate '%s'", old_special_pred_table[i]);
+	  continue;
+	}
+      pred->special = true;
+    }
+}