1/* Generate from machine description:
2   - prototype declarations for operand predicates (tm-preds.h)
3   - function definitions of operand predicates, if defined new-style
4     (insn-preds.c)
5   Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GCC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING.  If not, write to
21the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22Boston, MA 02110-1301, USA.  */
23
24#include "bconfig.h"
25#include "system.h"
26#include "coretypes.h"
27#include "tm.h"
28#include "rtl.h"
29#include "errors.h"
30#include "obstack.h"
31#include "gensupport.h"
32
33/* Given a predicate expression EXP, from form NAME at line LINENO,
34   verify that it does not contain any RTL constructs which are not
35   valid in predicate definitions.  Returns true if EXP is
36   INvalid; issues error messages, caller need not.  */
37static bool
38validate_exp (rtx exp, const char *name, int lineno)
39{
40  if (exp == 0)
41    {
42      message_with_line (lineno, "%s: must give a predicate expression", name);
43      return true;
44    }
45
46  switch (GET_CODE (exp))
47    {
48      /* Ternary, binary, unary expressions: recurse into subexpressions.  */
49    case IF_THEN_ELSE:
50      if (validate_exp (XEXP (exp, 2), name, lineno))
51	return true;
52      /* else fall through */
53    case AND:
54    case IOR:
55      if (validate_exp (XEXP (exp, 1), name, lineno))
56	return true;
57      /* else fall through */
58    case NOT:
59      return validate_exp (XEXP (exp, 0), name, lineno);
60
61      /* MATCH_CODE might have a syntax error in its path expression.  */
62    case MATCH_CODE:
63      {
64	const char *p;
65	for (p = XSTR (exp, 1); *p; p++)
66	  {
67	    if (!ISDIGIT (*p) && !ISLOWER (*p))
68	      {
69		message_with_line (lineno, "%s: invalid character in path "
70				   "string '%s'", name, XSTR (exp, 1));
71		have_error = 1;
72		return true;
73	      }
74	  }
75      }
76      /* fall through */
77
78      /* These need no special checking.  */
79    case MATCH_OPERAND:
80    case MATCH_TEST:
81      return false;
82
83    default:
84      message_with_line (lineno,
85			 "%s: cannot use '%s' in a predicate expression",
86			 name, GET_RTX_NAME (GET_CODE (exp)));
87      have_error = 1;
88      return true;
89    }
90}
91
92/* Predicates are defined with (define_predicate) or
93   (define_special_predicate) expressions in the machine description.  */
94static void
95process_define_predicate (rtx defn, int lineno)
96{
97  struct pred_data *pred;
98  const char *p;
99
100  if (!ISALPHA (XSTR (defn, 0)[0]) && XSTR (defn, 0)[0] != '_')
101    goto bad_name;
102  for (p = XSTR (defn, 0) + 1; *p; p++)
103    if (!ISALNUM (*p) && *p != '_')
104      goto bad_name;
105
106  if (validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno))
107    return;
108
109  pred = XCNEW (struct pred_data);
110  pred->name = XSTR (defn, 0);
111  pred->exp = XEXP (defn, 1);
112  pred->c_block = XSTR (defn, 2);
113
114  if (GET_CODE (defn) == DEFINE_SPECIAL_PREDICATE)
115    pred->special = true;
116
117  add_predicate (pred);
118  return;
119
120 bad_name:
121  message_with_line (lineno,
122		     "%s: predicate name must be a valid C function name",
123		     XSTR (defn, 0));
124  have_error = 1;
125  return;
126}
127
128/* Given a predicate, if it has an embedded C block, write the block
129   out as a static inline subroutine, and augment the RTL test with a
130   match_test that calls that subroutine.  For instance,
131
132       (define_predicate "basereg_operand"
133         (match_operand 0 "register_operand")
134       {
135         if (GET_CODE (op) == SUBREG)
136           op = SUBREG_REG (op);
137         return REG_POINTER (op);
138       })
139
140   becomes
141
142       static inline int basereg_operand_1(rtx op, enum machine_mode mode)
143       {
144         if (GET_CODE (op) == SUBREG)
145           op = SUBREG_REG (op);
146         return REG_POINTER (op);
147       }
148
149       (define_predicate "basereg_operand"
150         (and (match_operand 0 "register_operand")
151	      (match_test "basereg_operand_1 (op, mode)")))
152
153   The only wart is that there's no way to insist on a { } string in
154   an RTL template, so we have to handle "" strings.  */
155
156
157static void
158write_predicate_subfunction (struct pred_data *p)
159{
160  const char *match_test_str;
161  rtx match_test_exp, and_exp;
162
163  if (p->c_block[0] == '\0')
164    return;
165
166  /* Construct the function-call expression.  */
167  obstack_grow (rtl_obstack, p->name, strlen (p->name));
168  obstack_grow (rtl_obstack, "_1 (op, mode)",
169		sizeof "_1 (op, mode)");
170  match_test_str = XOBFINISH (rtl_obstack, const char *);
171
172  /* Add the function-call expression to the complete expression to be
173     evaluated.  */
174  match_test_exp = rtx_alloc (MATCH_TEST);
175  XSTR (match_test_exp, 0) = match_test_str;
176
177  and_exp = rtx_alloc (AND);
178  XEXP (and_exp, 0) = p->exp;
179  XEXP (and_exp, 1) = match_test_exp;
180
181  p->exp = and_exp;
182
183  printf ("static inline int\n"
184	  "%s_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n",
185	  p->name);
186  print_rtx_ptr_loc (p->c_block);
187  if (p->c_block[0] == '{')
188    fputs (p->c_block, stdout);
189  else
190    printf ("{\n  %s\n}", p->c_block);
191  fputs ("\n\n", stdout);
192}
193
194/* Given a predicate expression EXP, from form NAME, determine whether
195   it refers to the variable given as VAR.  */
196static bool
197needs_variable (rtx exp, const char *var)
198{
199  switch (GET_CODE (exp))
200    {
201      /* Ternary, binary, unary expressions need a variable if
202	 any of their subexpressions do.  */
203    case IF_THEN_ELSE:
204      if (needs_variable (XEXP (exp, 2), var))
205	return true;
206      /* else fall through */
207    case AND:
208    case IOR:
209      if (needs_variable (XEXP (exp, 1), var))
210	return true;
211      /* else fall through */
212    case NOT:
213      return needs_variable (XEXP (exp, 0), var);
214
215      /* MATCH_CODE uses "op", but nothing else.  */
216    case MATCH_CODE:
217      return !strcmp (var, "op");
218
219      /* MATCH_OPERAND uses "op" and may use "mode".  */
220    case MATCH_OPERAND:
221      if (!strcmp (var, "op"))
222	return true;
223      if (!strcmp (var, "mode") && GET_MODE (exp) == VOIDmode)
224	return true;
225      return false;
226
227      /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
228    case MATCH_TEST:
229      {
230	const char *p = XSTR (exp, 0);
231	const char *q = strstr (p, var);
232	if (!q)
233	  return false;
234	if (q != p && (ISALNUM (q[-1]) || q[-1] == '_'))
235	  return false;
236	q += strlen (var);
237	if (ISALNUM (q[0] || q[0] == '_'))
238	  return false;
239      }
240      return true;
241
242    default:
243      gcc_unreachable ();
244    }
245}
246
247/* Given an RTL expression EXP, find all subexpressions which we may
248   assume to perform mode tests.  Normal MATCH_OPERAND does;
249   MATCH_CODE does if it applies to the whole expression and accepts
250   CONST_INT or CONST_DOUBLE; and we have to assume that MATCH_TEST
251   does not.  These combine in almost-boolean fashion - the only
252   exception is that (not X) must be assumed not to perform a mode
253   test, whether or not X does.
254
255   The mark is the RTL /v flag, which is true for subexpressions which
256   do *not* perform mode tests.
257*/
258#define NO_MODE_TEST(EXP) RTX_FLAG (EXP, volatil)
259static void
260mark_mode_tests (rtx exp)
261{
262  switch (GET_CODE (exp))
263    {
264    case MATCH_OPERAND:
265      {
266	struct pred_data *p = lookup_predicate (XSTR (exp, 1));
267	if (!p)
268	  error ("reference to undefined predicate '%s'", XSTR (exp, 1));
269	else if (p->special || GET_MODE (exp) != VOIDmode)
270	  NO_MODE_TEST (exp) = 1;
271      }
272      break;
273
274    case MATCH_CODE:
275      if (XSTR (exp, 1)[0] != '\0'
276	  || (!strstr (XSTR (exp, 0), "const_int")
277	      && !strstr (XSTR (exp, 0), "const_double")))
278	NO_MODE_TEST (exp) = 1;
279      break;
280
281    case MATCH_TEST:
282    case NOT:
283      NO_MODE_TEST (exp) = 1;
284      break;
285
286    case AND:
287      mark_mode_tests (XEXP (exp, 0));
288      mark_mode_tests (XEXP (exp, 1));
289
290      NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
291			    && NO_MODE_TEST (XEXP (exp, 1)));
292      break;
293
294    case IOR:
295      mark_mode_tests (XEXP (exp, 0));
296      mark_mode_tests (XEXP (exp, 1));
297
298      NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
299			    || NO_MODE_TEST (XEXP (exp, 1)));
300      break;
301
302    case IF_THEN_ELSE:
303      /* A ? B : C does a mode test if (one of A and B) does a mode
304	 test, and C does too.  */
305      mark_mode_tests (XEXP (exp, 0));
306      mark_mode_tests (XEXP (exp, 1));
307      mark_mode_tests (XEXP (exp, 2));
308
309      NO_MODE_TEST (exp) = ((NO_MODE_TEST (XEXP (exp, 0))
310			     && NO_MODE_TEST (XEXP (exp, 1)))
311			    || NO_MODE_TEST (XEXP (exp, 2)));
312      break;
313
314    default:
315      gcc_unreachable ();
316    }
317}
318
319/* Determine whether the expression EXP is a MATCH_CODE that should
320   be written as a switch statement.  */
321static bool
322generate_switch_p (rtx exp)
323{
324  return GET_CODE (exp) == MATCH_CODE
325	 && strchr (XSTR (exp, 0), ',');
326}
327
328/* Given a predicate, work out where in its RTL expression to add
329   tests for proper modes.  Special predicates do not get any such
330   tests.  We try to avoid adding tests when we don't have to; in
331   particular, other normal predicates can be counted on to do it for
332   us.  */
333
334static void
335add_mode_tests (struct pred_data *p)
336{
337  rtx match_test_exp, and_exp;
338  rtx *pos;
339
340  /* Don't touch special predicates.  */
341  if (p->special)
342    return;
343
344  mark_mode_tests (p->exp);
345
346  /* If the whole expression already tests the mode, we're done.  */
347  if (!NO_MODE_TEST (p->exp))
348    return;
349
350  match_test_exp = rtx_alloc (MATCH_TEST);
351  XSTR (match_test_exp, 0) = "mode == VOIDmode || GET_MODE (op) == mode";
352  and_exp = rtx_alloc (AND);
353  XEXP (and_exp, 1) = match_test_exp;
354
355  /* It is always correct to rewrite p->exp as
356
357        (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode"))
358
359     but there are a couple forms where we can do better.  If the
360     top-level pattern is an IOR, and one of the two branches does test
361     the mode, we can wrap just the branch that doesn't.  Likewise, if
362     we have an IF_THEN_ELSE, and one side of it tests the mode, we can
363     wrap just the side that doesn't.  And, of course, we can repeat this
364     descent as many times as it works.  */
365
366  pos = &p->exp;
367  for (;;)
368    {
369      rtx subexp = *pos;
370
371      switch (GET_CODE (subexp))
372	{
373	case AND:
374	  /* The switch code generation in write_predicate_stmts prefers
375	     rtx code tests to be at the top of the expression tree.  So
376	     push this AND down into the second operand of an existing
377	     AND expression.  */
378	  if (generate_switch_p (XEXP (subexp, 0)))
379	    pos = &XEXP (subexp, 1);
380	  goto break_loop;
381
382	case IOR:
383	  {
384	    int test0 = NO_MODE_TEST (XEXP (subexp, 0));
385	    int test1 = NO_MODE_TEST (XEXP (subexp, 1));
386
387	    gcc_assert (test0 || test1);
388
389	    if (test0 && test1)
390	      goto break_loop;
391	    pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1);
392	  }
393	  break;
394
395	case IF_THEN_ELSE:
396	  {
397	    int test0 = NO_MODE_TEST (XEXP (subexp, 0));
398	    int test1 = NO_MODE_TEST (XEXP (subexp, 1));
399	    int test2 = NO_MODE_TEST (XEXP (subexp, 2));
400
401	    gcc_assert ((test0 && test1) || test2);
402
403	    if (test0 && test1 && test2)
404	      goto break_loop;
405	    if (test0 && test1)
406	      /* Must put it on the dependent clause, not the
407	      	 controlling expression, or we change the meaning of
408	      	 the test.  */
409	      pos = &XEXP (subexp, 1);
410	    else
411	      pos = &XEXP (subexp, 2);
412	  }
413	  break;
414
415	default:
416	  goto break_loop;
417	}
418    }
419 break_loop:
420  XEXP (and_exp, 0) = *pos;
421  *pos = and_exp;
422}
423
424/* PATH is a string describing a path from the root of an RTL
425   expression to an inner subexpression to be tested.  Output
426   code which computes the subexpression from the variable
427   holding the root of the expression.  */
428static void
429write_extract_subexp (const char *path)
430{
431  int len = strlen (path);
432  int i;
433
434  /* We first write out the operations (XEXP or XVECEXP) in reverse
435     order, then write "op", then the indices in forward order.  */
436  for (i = len - 1; i >= 0; i--)
437    {
438      if (ISLOWER (path[i]))
439	fputs ("XVECEXP (", stdout);
440      else if (ISDIGIT (path[i]))
441	fputs ("XEXP (", stdout);
442      else
443	gcc_unreachable ();
444    }
445
446  fputs ("op", stdout);
447
448  for (i = 0; i < len; i++)
449    {
450      if (ISLOWER (path[i]))
451	printf (", 0, %d)", path[i] - 'a');
452      else if (ISDIGIT (path[i]))
453	printf (", %d)", path[i] - '0');
454      else
455	gcc_unreachable ();
456    }
457}
458
459/* CODES is a list of RTX codes.  Write out an expression which
460   determines whether the operand has one of those codes.  */
461static void
462write_match_code (const char *path, const char *codes)
463{
464  const char *code;
465
466  while ((code = scan_comma_elt (&codes)) != 0)
467    {
468      fputs ("GET_CODE (", stdout);
469      write_extract_subexp (path);
470      fputs (") == ", stdout);
471      while (code < codes)
472	{
473	  putchar (TOUPPER (*code));
474	  code++;
475	}
476
477      if (*codes == ',')
478	fputs (" || ", stdout);
479    }
480}
481
482/* EXP is an RTL (sub)expression for a predicate.  Recursively
483   descend the expression and write out an equivalent C expression.  */
484static void
485write_predicate_expr (rtx exp)
486{
487  switch (GET_CODE (exp))
488    {
489    case AND:
490      putchar ('(');
491      write_predicate_expr (XEXP (exp, 0));
492      fputs (") && (", stdout);
493      write_predicate_expr (XEXP (exp, 1));
494      putchar (')');
495      break;
496
497    case IOR:
498      putchar ('(');
499      write_predicate_expr (XEXP (exp, 0));
500      fputs (") || (", stdout);
501      write_predicate_expr (XEXP (exp, 1));
502      putchar (')');
503      break;
504
505    case NOT:
506      fputs ("!(", stdout);
507      write_predicate_expr (XEXP (exp, 0));
508      putchar (')');
509      break;
510
511    case IF_THEN_ELSE:
512      putchar ('(');
513      write_predicate_expr (XEXP (exp, 0));
514      fputs (") ? (", stdout);
515      write_predicate_expr (XEXP (exp, 1));
516      fputs (") : (", stdout);
517      write_predicate_expr (XEXP (exp, 2));
518      putchar (')');
519      break;
520
521    case MATCH_OPERAND:
522      if (GET_MODE (exp) == VOIDmode)
523        printf ("%s (op, mode)", XSTR (exp, 1));
524      else
525        printf ("%s (op, %smode)", XSTR (exp, 1), mode_name[GET_MODE (exp)]);
526      break;
527
528    case MATCH_CODE:
529      write_match_code (XSTR (exp, 1), XSTR (exp, 0));
530      break;
531
532    case MATCH_TEST:
533      print_c_condition (XSTR (exp, 0));
534      break;
535
536    default:
537      gcc_unreachable ();
538    }
539}
540
541/* Write the MATCH_CODE expression EXP as a switch statement.  */
542
543static void
544write_match_code_switch (rtx exp)
545{
546  const char *codes = XSTR (exp, 0);
547  const char *path = XSTR (exp, 1);
548  const char *code;
549
550  fputs ("  switch (GET_CODE (", stdout);
551  write_extract_subexp (path);
552  fputs ("))\n    {\n", stdout);
553
554  while ((code = scan_comma_elt (&codes)) != 0)
555    {
556      fputs ("    case ", stdout);
557      while (code < codes)
558	{
559	  putchar (TOUPPER (*code));
560	  code++;
561	}
562      fputs(":\n", stdout);
563    }
564}
565
566/* Given a predicate expression EXP, write out a sequence of stmts
567   to evaluate it.  This is similar to write_predicate_expr but can
568   generate efficient switch statements.  */
569
570static void
571write_predicate_stmts (rtx exp)
572{
573  switch (GET_CODE (exp))
574    {
575    case MATCH_CODE:
576      if (generate_switch_p (exp))
577	{
578	  write_match_code_switch (exp);
579	  puts ("      return true;\n"
580		"    default:\n"
581		"      break;\n"
582		"    }\n"
583		"  return false;");
584	  return;
585	}
586      break;
587
588    case AND:
589      if (generate_switch_p (XEXP (exp, 0)))
590	{
591	  write_match_code_switch (XEXP (exp, 0));
592	  puts ("      break;\n"
593		"    default:\n"
594		"      return false;\n"
595		"    }");
596	  exp = XEXP (exp, 1);
597	}
598      break;
599
600    case IOR:
601      if (generate_switch_p (XEXP (exp, 0)))
602	{
603	  write_match_code_switch (XEXP (exp, 0));
604	  puts ("      return true;\n"
605		"    default:\n"
606		"      break;\n"
607		"    }");
608	  exp = XEXP (exp, 1);
609	}
610      break;
611
612    case NOT:
613      if (generate_switch_p (XEXP (exp, 0)))
614	{
615	  write_match_code_switch (XEXP (exp, 0));
616	  puts ("      return false;\n"
617		"    default:\n"
618		"      break;\n"
619		"    }\n"
620		"  return true;");
621	  return;
622	}
623      break;
624
625    default:
626      break;
627    }
628
629  fputs("  return ",stdout);
630  write_predicate_expr (exp);
631  fputs(";\n", stdout);
632}
633
634/* Given a predicate, write out a complete C function to compute it.  */
635static void
636write_one_predicate_function (struct pred_data *p)
637{
638  if (!p->exp)
639    return;
640
641  write_predicate_subfunction (p);
642  add_mode_tests (p);
643
644  /* A normal predicate can legitimately not look at enum machine_mode
645     if it accepts only CONST_INTs and/or CONST_DOUBLEs.  */
646  printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n{\n",
647	  p->name);
648  write_predicate_stmts (p->exp);
649  fputs ("}\n\n", stdout);
650}
651
652/* Constraints fall into two categories: register constraints
653   (define_register_constraint), and others (define_constraint,
654   define_memory_constraint, define_address_constraint).  We
655   work out automatically which of the various old-style macros
656   they correspond to, and produce appropriate code.  They all
657   go in the same hash table so we can verify that there are no
658   duplicate names.  */
659
660/* All data from one constraint definition.  */
661struct constraint_data
662{
663  struct constraint_data *next_this_letter;
664  struct constraint_data *next_textual;
665  const char *name;
666  const char *c_name;    /* same as .name unless mangling is necessary */
667  size_t namelen;
668  const char *regclass;  /* for register constraints */
669  rtx exp;               /* for other constraints */
670  unsigned int lineno;   /* line of definition */
671  unsigned int is_register  : 1;
672  unsigned int is_const_int : 1;
673  unsigned int is_const_dbl : 1;
674  unsigned int is_extra     : 1;
675  unsigned int is_memory    : 1;
676  unsigned int is_address   : 1;
677};
678
679/* Overview of all constraints beginning with a given letter.  */
680
681static struct constraint_data *
682constraints_by_letter_table[1<<CHAR_BIT];
683
684/* For looking up all the constraints in the order that they appeared
685   in the machine description.  */
686static struct constraint_data *first_constraint;
687static struct constraint_data **last_constraint_ptr = &first_constraint;
688
689#define FOR_ALL_CONSTRAINTS(iter_) \
690  for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
691
692/* These letters, and all names beginning with them, are reserved for
693   generic constraints.  */
694static const char generic_constraint_letters[] = "EFVXgimnoprs";
695
696/* Machine-independent code expects that constraints with these
697   (initial) letters will allow only (a subset of all) CONST_INTs.  */
698
699static const char const_int_constraints[] = "IJKLMNOP";
700
701/* Machine-independent code expects that constraints with these
702   (initial) letters will allow only (a subset of all) CONST_DOUBLEs.  */
703
704static const char const_dbl_constraints[] = "GH";
705
706/* Summary data used to decide whether to output various functions and
707   macro definitions.  */
708static unsigned int constraint_max_namelen;
709static bool have_register_constraints;
710static bool have_memory_constraints;
711static bool have_address_constraints;
712static bool have_extra_constraints;
713static bool have_const_int_constraints;
714static bool have_const_dbl_constraints;
715
716/* Convert NAME, which contains angle brackets and/or underscores, to
717   a string that can be used as part of a C identifier.  The string
718   comes from the rtl_obstack.  */
719static const char *
720mangle (const char *name)
721{
722  for (; *name; name++)
723    switch (*name)
724      {
725      case '_': obstack_grow (rtl_obstack, "__", 2); break;
726      case '<':	obstack_grow (rtl_obstack, "_l", 2); break;
727      case '>':	obstack_grow (rtl_obstack, "_g", 2); break;
728      default: obstack_1grow (rtl_obstack, *name); break;
729      }
730
731  obstack_1grow (rtl_obstack, '\0');
732  return obstack_finish (rtl_obstack);
733}
734
735/* Add one constraint, of any sort, to the tables.  NAME is its name;
736   REGCLASS is the register class, if any; EXP is the expression to
737   test, if any;  IS_MEMORY and IS_ADDRESS indicate memory and address
738   constraints, respectively; LINENO is the line number from the MD reader.
739   Not all combinations of arguments are valid; most importantly, REGCLASS
740   is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only
741   meaningful for constraints with EXP.
742
743   This function enforces all syntactic and semantic rules about what
744   constraints can be defined.  */
745
746static void
747add_constraint (const char *name, const char *regclass,
748		rtx exp, bool is_memory, bool is_address,
749		int lineno)
750{
751  struct constraint_data *c, **iter, **slot;
752  const char *p;
753  bool need_mangled_name = false;
754  bool is_const_int;
755  bool is_const_dbl;
756  size_t namelen;
757
758  if (exp && validate_exp (exp, name, lineno))
759    return;
760
761  if (!ISALPHA (name[0]) && name[0] != '_')
762    {
763      if (name[1] == '\0')
764	message_with_line (lineno, "constraint name '%s' is not "
765			   "a letter or underscore", name);
766      else
767	message_with_line (lineno, "constraint name '%s' does not begin "
768			   "with a letter or underscore", name);
769      have_error = 1;
770      return;
771    }
772  for (p = name; *p; p++)
773    if (!ISALNUM (*p))
774      {
775	if (*p == '<' || *p == '>' || *p == '_')
776	  need_mangled_name = true;
777	else
778	  {
779	    message_with_line (lineno,
780			       "constraint name '%s' must be composed of "
781			       "letters, digits, underscores, and "
782			       "angle brackets", name);
783	    have_error = 1;
784	    return;
785	  }
786      }
787
788  if (strchr (generic_constraint_letters, name[0]))
789    {
790      if (name[1] == '\0')
791	message_with_line (lineno, "constraint letter '%s' cannot be "
792			   "redefined by the machine description", name);
793      else
794	message_with_line (lineno, "constraint name '%s' cannot be defined by "
795			   "the machine description, as it begins with '%c'",
796			   name, name[0]);
797      have_error = 1;
798      return;
799    }
800
801
802  namelen = strlen (name);
803  slot = &constraints_by_letter_table[(unsigned int)name[0]];
804  for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
805    {
806      /* This causes slot to end up pointing to the
807	 next_this_letter field of the last constraint with a name
808	 of equal or greater length than the new constraint; hence
809	 the new constraint will be inserted after all previous
810	 constraints with names of the same length.  */
811      if ((*iter)->namelen >= namelen)
812	slot = iter;
813
814      if (!strcmp ((*iter)->name, name))
815	{
816	  message_with_line (lineno, "redefinition of constraint '%s'", name);
817	  message_with_line ((*iter)->lineno, "previous definition is here");
818	  have_error = 1;
819	  return;
820	}
821      else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
822	{
823	  message_with_line (lineno, "defining constraint '%s' here", name);
824	  message_with_line ((*iter)->lineno, "renders constraint '%s' "
825			     "(defined here) a prefix", (*iter)->name);
826	  have_error = 1;
827	  return;
828	}
829      else if (!strncmp ((*iter)->name, name, namelen))
830	{
831	  message_with_line (lineno, "constraint '%s' is a prefix", name);
832	  message_with_line ((*iter)->lineno, "of constraint '%s' "
833			     "(defined here)", (*iter)->name);
834	  have_error = 1;
835	  return;
836	}
837    }
838
839  is_const_int = strchr (const_int_constraints, name[0]) != 0;
840  is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
841
842  if (is_const_int || is_const_dbl)
843    {
844      enum rtx_code appropriate_code
845	= is_const_int ? CONST_INT : CONST_DOUBLE;
846
847      /* Consider relaxing this requirement in the future.  */
848      if (regclass
849	  || GET_CODE (exp) != AND
850	  || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
851	  || strcmp (XSTR (XEXP (exp, 0), 0),
852		     GET_RTX_NAME (appropriate_code)))
853	{
854	  if (name[1] == '\0')
855	    message_with_line (lineno, "constraint letter '%c' is reserved "
856			       "for %s constraints",
857			       name[0], GET_RTX_NAME (appropriate_code));
858	  else
859	    message_with_line (lineno, "constraint names beginning with '%c' "
860			       "(%s) are reserved for %s constraints",
861			       name[0], name,
862			       GET_RTX_NAME (appropriate_code));
863
864	  have_error = 1;
865	  return;
866	}
867
868      if (is_memory)
869	{
870	  if (name[1] == '\0')
871	    message_with_line (lineno, "constraint letter '%c' cannot be a "
872			       "memory constraint", name[0]);
873	  else
874	    message_with_line (lineno, "constraint name '%s' begins with '%c', "
875			       "and therefore cannot be a memory constraint",
876			       name, name[0]);
877
878	  have_error = 1;
879	  return;
880	}
881      else if (is_address)
882	{
883	  if (name[1] == '\0')
884	    message_with_line (lineno, "constraint letter '%c' cannot be a "
885			       "memory constraint", name[0]);
886	  else
887	    message_with_line (lineno, "constraint name '%s' begins with '%c', "
888			       "and therefore cannot be a memory constraint",
889			       name, name[0]);
890
891	  have_error = 1;
892	  return;
893	}
894    }
895
896
897  c = obstack_alloc (rtl_obstack, sizeof (struct constraint_data));
898  c->name = name;
899  c->c_name = need_mangled_name ? mangle (name) : name;
900  c->lineno = lineno;
901  c->namelen = namelen;
902  c->regclass = regclass;
903  c->exp = exp;
904  c->is_register = regclass != 0;
905  c->is_const_int = is_const_int;
906  c->is_const_dbl = is_const_dbl;
907  c->is_extra = !(regclass || is_const_int || is_const_dbl);
908  c->is_memory = is_memory;
909  c->is_address = is_address;
910
911  c->next_this_letter = *slot;
912  *slot = c;
913
914  /* Insert this constraint in the list of all constraints in textual
915     order.  */
916  c->next_textual = 0;
917  *last_constraint_ptr = c;
918  last_constraint_ptr = &c->next_textual;
919
920  constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
921  have_register_constraints |= c->is_register;
922  have_const_int_constraints |= c->is_const_int;
923  have_const_dbl_constraints |= c->is_const_dbl;
924  have_extra_constraints |= c->is_extra;
925  have_memory_constraints |= c->is_memory;
926  have_address_constraints |= c->is_address;
927}
928
929/* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or
930   DEFINE_ADDRESS_CONSTRAINT expression, C.  */
931static void
932process_define_constraint (rtx c, int lineno)
933{
934  add_constraint (XSTR (c, 0), 0, XEXP (c, 2),
935		  GET_CODE (c) == DEFINE_MEMORY_CONSTRAINT,
936		  GET_CODE (c) == DEFINE_ADDRESS_CONSTRAINT,
937		  lineno);
938}
939
940/* Process a DEFINE_REGISTER_CONSTRAINT expression, C.  */
941static void
942process_define_register_constraint (rtx c, int lineno)
943{
944  add_constraint (XSTR (c, 0), XSTR (c, 1), 0, false, false, lineno);
945}
946
947/* Write out an enumeration with one entry per machine-specific
948   constraint.  */
949static void
950write_enum_constraint_num (void)
951{
952  struct constraint_data *c;
953
954  fputs ("enum constraint_num\n"
955	 "{\n"
956	 "  CONSTRAINT__UNKNOWN = 0", stdout);
957  FOR_ALL_CONSTRAINTS (c)
958    printf (",\n  CONSTRAINT_%s", c->c_name);
959  puts ("\n};\n");
960}
961
962/* Write out a function which looks at a string and determines what
963   constraint name, if any, it begins with.  */
964static void
965write_lookup_constraint (void)
966{
967  unsigned int i;
968  puts ("enum constraint_num\n"
969	"lookup_constraint (const char *str)\n"
970	"{\n"
971	"  switch (str[0])\n"
972	"    {");
973
974  for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
975    {
976      struct constraint_data *c = constraints_by_letter_table[i];
977      if (!c)
978	continue;
979
980      printf ("    case '%c':\n", i);
981      if (c->namelen == 1)
982	printf ("      return CONSTRAINT_%s;\n", c->c_name);
983      else
984	{
985	  do
986	    {
987	      printf ("      if (!strncmp (str, \"%s\", %lu))\n"
988		      "        return CONSTRAINT_%s;\n",
989		      c->name, (unsigned long int) c->namelen, c->c_name);
990	      c = c->next_this_letter;
991	    }
992	  while (c);
993	  puts ("      break;");
994	}
995    }
996
997  puts ("    default: break;\n"
998	"    }\n"
999	"  return CONSTRAINT__UNKNOWN;\n"
1000	"}\n");
1001}
1002
1003/* Write out the function which computes constraint name lengths from
1004   their enumerators. */
1005static void
1006write_insn_constraint_len (void)
1007{
1008  struct constraint_data *c;
1009
1010  if (constraint_max_namelen == 1)
1011    return;
1012
1013  puts ("size_t\n"
1014	"insn_constraint_len (enum constraint_num c)\n"
1015	"{\n"
1016	"  switch (c)\n"
1017	"    {");
1018
1019  FOR_ALL_CONSTRAINTS (c)
1020    if (c->namelen > 1)
1021      printf ("    case CONSTRAINT_%s: return %lu;\n", c->c_name,
1022	      (unsigned long int) c->namelen);
1023
1024  puts ("    default: break;\n"
1025	"    }\n"
1026	"  return 1;\n"
1027	"}\n");
1028}
1029
1030/* Write out the function which computes the register class corresponding
1031   to a register constraint.  */
1032static void
1033write_regclass_for_constraint (void)
1034{
1035  struct constraint_data *c;
1036
1037  puts ("enum reg_class\n"
1038	"regclass_for_constraint (enum constraint_num c)\n"
1039	"{\n"
1040	"  switch (c)\n"
1041	"    {");
1042
1043  FOR_ALL_CONSTRAINTS (c)
1044    if (c->is_register)
1045      printf ("    case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
1046
1047  puts ("    default: break;\n"
1048	"    }\n"
1049	"  return NO_REGS;\n"
1050	"}\n");
1051}
1052
1053/* Write out the functions which compute whether a given value matches
1054   a given non-register constraint.  */
1055static void
1056write_tm_constrs_h (void)
1057{
1058  struct constraint_data *c;
1059
1060  printf ("\
1061/* Generated automatically by the program '%s'\n\
1062   from the machine description file '%s'.  */\n\n", progname, in_fname);
1063
1064  puts ("\
1065#ifndef GCC_TM_CONSTRS_H\n\
1066#define GCC_TM_CONSTRS_H\n");
1067
1068  FOR_ALL_CONSTRAINTS (c)
1069    if (!c->is_register)
1070      {
1071	bool needs_ival = needs_variable (c->exp, "ival");
1072	bool needs_hval = needs_variable (c->exp, "hval");
1073	bool needs_lval = needs_variable (c->exp, "lval");
1074	bool needs_rval = needs_variable (c->exp, "rval");
1075	bool needs_mode = (needs_variable (c->exp, "mode")
1076			   || needs_hval || needs_lval || needs_rval);
1077	bool needs_op = (needs_variable (c->exp, "op")
1078			 || needs_ival || needs_mode);
1079
1080	printf ("static inline bool\n"
1081		"satisfies_constraint_%s (rtx %s)\n"
1082		"{\n", c->c_name,
1083		needs_op ? "op" : "ARG_UNUSED (op)");
1084	if (needs_mode)
1085	  puts ("enum machine_mode mode = GET_MODE (op);");
1086	if (needs_ival)
1087	  puts ("  HOST_WIDE_INT ival = 0;");
1088	if (needs_hval)
1089	  puts ("  HOST_WIDE_INT hval = 0;");
1090	if (needs_lval)
1091	  puts ("  unsigned HOST_WIDE_INT lval = 0;");
1092	if (needs_rval)
1093	  puts ("  const REAL_VALUE_TYPE *rval = 0;");
1094
1095	if (needs_ival)
1096	  puts ("  if (GET_CODE (op) == CONST_INT)\n"
1097		"    ival = INTVAL (op);");
1098	if (needs_hval)
1099	  puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1100		"    hval = CONST_DOUBLE_HIGH (op);");
1101	if (needs_lval)
1102	  puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1103		"    lval = CONST_DOUBLE_LOW (op);");
1104	if (needs_rval)
1105	  puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
1106		"    rval = CONST_DOUBLE_REAL_VALUE (op);");
1107
1108	write_predicate_stmts (c->exp);
1109	fputs ("}\n", stdout);
1110      }
1111  puts ("#endif /* tm-constrs.h */");
1112}
1113
1114/* Write out the wrapper function, constraint_satisfied_p, that maps
1115   a CONSTRAINT_xxx constant to one of the predicate functions generated
1116   above.  */
1117static void
1118write_constraint_satisfied_p (void)
1119{
1120  struct constraint_data *c;
1121
1122  puts ("bool\n"
1123	"constraint_satisfied_p (rtx op, enum constraint_num c)\n"
1124	"{\n"
1125	"  switch (c)\n"
1126	"    {");
1127
1128  FOR_ALL_CONSTRAINTS (c)
1129    if (!c->is_register)
1130      printf ("    case CONSTRAINT_%s: "
1131	      "return satisfies_constraint_%s (op);\n",
1132	      c->c_name, c->c_name);
1133
1134  puts ("    default: break;\n"
1135	"    }\n"
1136	"  return false;\n"
1137	"}\n");
1138}
1139
1140/* Write out the function which computes whether a given value matches
1141   a given CONST_INT constraint.  This doesn't just forward to
1142   constraint_satisfied_p because caller passes the INTVAL, not the RTX.  */
1143static void
1144write_insn_const_int_ok_for_constraint (void)
1145{
1146  struct constraint_data *c;
1147
1148  puts ("bool\n"
1149	"insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1150	                                  "enum constraint_num c)\n"
1151	"{\n"
1152	"  switch (c)\n"
1153	"    {");
1154
1155  FOR_ALL_CONSTRAINTS (c)
1156    if (c->is_const_int)
1157      {
1158	printf ("    case CONSTRAINT_%s:\n      return ", c->c_name);
1159	/* c->exp is guaranteed to be (and (match_code "const_int") (...));
1160	   we know at this point that we have a const_int, so we need not
1161	   bother with that part of the test.  */
1162	write_predicate_expr (XEXP (c->exp, 1));
1163	fputs (";\n\n", stdout);
1164      }
1165
1166  puts ("    default: break;\n"
1167	"    }\n"
1168	"  return false;\n"
1169	"}\n");
1170}
1171
1172
1173/* Write out the function which computes whether a given constraint is
1174   a memory constraint.  */
1175static void
1176write_insn_extra_memory_constraint (void)
1177{
1178  struct constraint_data *c;
1179
1180  puts ("bool\n"
1181	"insn_extra_memory_constraint (enum constraint_num c)\n"
1182	"{\n"
1183	"  switch (c)\n"
1184	"    {");
1185
1186  FOR_ALL_CONSTRAINTS (c)
1187    if (c->is_memory)
1188      printf ("    case CONSTRAINT_%s:\n      return true;\n\n", c->c_name);
1189
1190  puts ("    default: break;\n"
1191	"    }\n"
1192	"  return false;\n"
1193	"}\n");
1194}
1195
1196/* Write out the function which computes whether a given constraint is
1197   an address constraint.  */
1198static void
1199write_insn_extra_address_constraint (void)
1200{
1201  struct constraint_data *c;
1202
1203  puts ("bool\n"
1204	"insn_extra_address_constraint (enum constraint_num c)\n"
1205	"{\n"
1206	"  switch (c)\n"
1207	"    {");
1208
1209  FOR_ALL_CONSTRAINTS (c)
1210    if (c->is_address)
1211      printf ("    case CONSTRAINT_%s:\n      return true;\n\n", c->c_name);
1212
1213  puts ("    default: break;\n"
1214	"    }\n"
1215	"  return false;\n"
1216	"}\n");
1217}
1218
1219
1220/* Write tm-preds.h.  Unfortunately, it is impossible to forward-declare
1221   an enumeration in portable C, so we have to condition all these
1222   prototypes on HAVE_MACHINE_MODES.  */
1223static void
1224write_tm_preds_h (void)
1225{
1226  struct pred_data *p;
1227
1228  printf ("\
1229/* Generated automatically by the program '%s'\n\
1230   from the machine description file '%s'.  */\n\n", progname, in_fname);
1231
1232  puts ("\
1233#ifndef GCC_TM_PREDS_H\n\
1234#define GCC_TM_PREDS_H\n\
1235\n\
1236#ifdef HAVE_MACHINE_MODES");
1237
1238  FOR_ALL_PREDICATES (p)
1239    printf ("extern int %s (rtx, enum machine_mode);\n", p->name);
1240
1241  puts ("#endif /* HAVE_MACHINE_MODES */\n");
1242
1243  if (constraint_max_namelen > 0)
1244    {
1245      write_enum_constraint_num ();
1246      puts ("extern enum constraint_num lookup_constraint (const char *);\n"
1247	    "extern bool constraint_satisfied_p (rtx, enum constraint_num);\n");
1248
1249      if (constraint_max_namelen > 1)
1250	puts ("extern size_t insn_constraint_len (enum constraint_num);\n"
1251	      "#define CONSTRAINT_LEN(c_,s_) "
1252	      "insn_constraint_len (lookup_constraint (s_))\n");
1253      else
1254	puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1255      if (have_register_constraints)
1256	puts ("extern enum reg_class regclass_for_constraint "
1257	      "(enum constraint_num);\n"
1258	      "#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n"
1259	      "    regclass_for_constraint (lookup_constraint (s_))\n");
1260      else
1261	puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS");
1262      if (have_const_int_constraints)
1263	puts ("extern bool insn_const_int_ok_for_constraint "
1264	      "(HOST_WIDE_INT, enum constraint_num);\n"
1265	      "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1266	      "    insn_const_int_ok_for_constraint (v_, "
1267	      "lookup_constraint (s_))\n");
1268      if (have_const_dbl_constraints)
1269	puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1270	      "    constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1271      else
1272	puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) 0\n");
1273      if (have_extra_constraints)
1274	puts ("#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \\\n"
1275	      "    constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1276      if (have_memory_constraints)
1277	puts ("extern bool "
1278	      "insn_extra_memory_constraint (enum constraint_num);\n"
1279	      "#define EXTRA_MEMORY_CONSTRAINT(c_,s_) "
1280	      "insn_extra_memory_constraint (lookup_constraint (s_))\n");
1281      else
1282	puts ("#define EXTRA_MEMORY_CONSTRAINT(c_,s_) false\n");
1283      if (have_address_constraints)
1284	puts ("extern bool "
1285	      "insn_extra_address_constraint (enum constraint_num);\n"
1286	      "#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) "
1287	      "insn_extra_address_constraint (lookup_constraint (s_))\n");
1288      else
1289	puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n");
1290    }
1291
1292  puts ("#endif /* tm-preds.h */");
1293}
1294
1295/* Write insn-preds.c.
1296   N.B. the list of headers to include was copied from genrecog; it
1297   may not be ideal.
1298
1299   FUTURE: Write #line markers referring back to the machine
1300   description.  (Can't practically do this now since we don't know
1301   the line number of the C block - just the line number of the enclosing
1302   expression.)  */
1303static void
1304write_insn_preds_c (void)
1305{
1306  struct pred_data *p;
1307
1308  printf ("\
1309/* Generated automatically by the program '%s'\n\
1310   from the machine description file '%s'.  */\n\n", progname, in_fname);
1311
1312  puts ("\
1313#include \"config.h\"\n\
1314#include \"system.h\"\n\
1315#include \"coretypes.h\"\n\
1316#include \"tm.h\"\n\
1317#include \"rtl.h\"\n\
1318#include \"tree.h\"\n\
1319#include \"tm_p.h\"\n\
1320#include \"function.h\"\n\
1321#include \"insn-config.h\"\n\
1322#include \"recog.h\"\n\
1323#include \"real.h\"\n\
1324#include \"output.h\"\n\
1325#include \"flags.h\"\n\
1326#include \"hard-reg-set.h\"\n\
1327#include \"resource.h\"\n\
1328#include \"toplev.h\"\n\
1329#include \"reload.h\"\n\
1330#include \"regs.h\"\n\
1331#include \"tm-constrs.h\"\n");
1332
1333  FOR_ALL_PREDICATES (p)
1334    write_one_predicate_function (p);
1335
1336  if (constraint_max_namelen > 0)
1337    {
1338      write_lookup_constraint ();
1339      write_regclass_for_constraint ();
1340      write_constraint_satisfied_p ();
1341
1342      if (constraint_max_namelen > 1)
1343	write_insn_constraint_len ();
1344
1345      if (have_const_int_constraints)
1346	write_insn_const_int_ok_for_constraint ();
1347
1348      if (have_memory_constraints)
1349	write_insn_extra_memory_constraint ();
1350      if (have_address_constraints)
1351	write_insn_extra_address_constraint ();
1352    }
1353}
1354
1355/* Argument parsing.  */
1356static bool gen_header;
1357static bool gen_constrs;
1358
1359static bool
1360parse_option (const char *opt)
1361{
1362  if (!strcmp (opt, "-h"))
1363    {
1364      gen_header = true;
1365      return 1;
1366    }
1367  else if (!strcmp (opt, "-c"))
1368    {
1369      gen_constrs = true;
1370      return 1;
1371    }
1372  else
1373    return 0;
1374}
1375
1376/* Master control.  */
1377int
1378main (int argc, char **argv)
1379{
1380  rtx defn;
1381  int pattern_lineno, next_insn_code = 0;
1382
1383  progname = argv[0];
1384  if (argc <= 1)
1385    fatal ("no input file name");
1386  if (init_md_reader_args_cb (argc, argv, parse_option) != SUCCESS_EXIT_CODE)
1387    return FATAL_EXIT_CODE;
1388
1389  while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0)
1390    switch (GET_CODE (defn))
1391      {
1392      case DEFINE_PREDICATE:
1393      case DEFINE_SPECIAL_PREDICATE:
1394	process_define_predicate (defn, pattern_lineno);
1395	break;
1396
1397      case DEFINE_CONSTRAINT:
1398      case DEFINE_MEMORY_CONSTRAINT:
1399      case DEFINE_ADDRESS_CONSTRAINT:
1400	process_define_constraint (defn, pattern_lineno);
1401	break;
1402
1403      case DEFINE_REGISTER_CONSTRAINT:
1404	process_define_register_constraint (defn, pattern_lineno);
1405	break;
1406
1407      default:
1408	break;
1409      }
1410
1411  if (gen_header)
1412    write_tm_preds_h ();
1413  else if (gen_constrs)
1414    write_tm_constrs_h ();
1415  else
1416    write_insn_preds_c ();
1417
1418  if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
1419    return FATAL_EXIT_CODE;
1420
1421  return SUCCESS_EXIT_CODE;
1422}
1423