* config.gcc (cygwin tm_file): Add cygwin-stdint.h.
[official-gcc.git] / gcc / genpreds.c
bloba1232e9573f01c7285e2c6b3e26b6df94d3b8830
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, 2007, 2008, 2009
6 Free Software Foundation, Inc.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
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"
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. */
37 static bool
38 validate_exp (rtx exp, const char *name, int lineno)
40 if (exp == 0)
42 message_with_line (lineno, "%s: must give a predicate expression", name);
43 return true;
46 switch (GET_CODE (exp))
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);
61 /* MATCH_CODE might have a syntax error in its path expression. */
62 case MATCH_CODE:
64 const char *p;
65 for (p = XSTR (exp, 1); *p; p++)
67 if (!ISDIGIT (*p) && !ISLOWER (*p))
69 message_with_line (lineno, "%s: invalid character in path "
70 "string '%s'", name, XSTR (exp, 1));
71 have_error = 1;
72 return true;
76 /* fall through */
78 /* These need no special checking. */
79 case MATCH_OPERAND:
80 case MATCH_TEST:
81 return false;
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;
92 /* Predicates are defined with (define_predicate) or
93 (define_special_predicate) expressions in the machine description. */
94 static void
95 process_define_predicate (rtx defn, int lineno)
97 struct pred_data *pred;
98 const char *p;
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;
106 if (validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno))
107 return;
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);
114 if (GET_CODE (defn) == DEFINE_SPECIAL_PREDICATE)
115 pred->special = true;
117 add_predicate (pred);
118 return;
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;
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,
132 (define_predicate "basereg_operand"
133 (match_operand 0 "register_operand")
135 if (GET_CODE (op) == SUBREG)
136 op = SUBREG_REG (op);
137 return REG_POINTER (op);
140 becomes
142 static inline int basereg_operand_1(rtx op, enum machine_mode mode)
144 if (GET_CODE (op) == SUBREG)
145 op = SUBREG_REG (op);
146 return REG_POINTER (op);
149 (define_predicate "basereg_operand"
150 (and (match_operand 0 "register_operand")
151 (match_test "basereg_operand_1 (op, mode)")))
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. */
157 static void
158 write_predicate_subfunction (struct pred_data *p)
160 const char *match_test_str;
161 rtx match_test_exp, and_exp;
163 if (p->c_block[0] == '\0')
164 return;
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 *);
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;
177 and_exp = rtx_alloc (AND);
178 XEXP (and_exp, 0) = p->exp;
179 XEXP (and_exp, 1) = match_test_exp;
181 p->exp = and_exp;
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);
194 /* Given a predicate expression EXP, from form NAME, determine whether
195 it refers to the variable given as VAR. */
196 static bool
197 needs_variable (rtx exp, const char *var)
199 switch (GET_CODE (exp))
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);
215 /* MATCH_CODE uses "op", but nothing else. */
216 case MATCH_CODE:
217 return !strcmp (var, "op");
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;
227 /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
228 case MATCH_TEST:
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;
240 return true;
242 default:
243 gcc_unreachable ();
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.
255 The mark is the RTL /v flag, which is true for subexpressions which
256 do *not* perform mode tests.
258 #define NO_MODE_TEST(EXP) RTX_FLAG (EXP, volatil)
259 static void
260 mark_mode_tests (rtx exp)
262 switch (GET_CODE (exp))
264 case MATCH_OPERAND:
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;
272 break;
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;
281 case MATCH_TEST:
282 case NOT:
283 NO_MODE_TEST (exp) = 1;
284 break;
286 case AND:
287 mark_mode_tests (XEXP (exp, 0));
288 mark_mode_tests (XEXP (exp, 1));
290 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
291 && NO_MODE_TEST (XEXP (exp, 1)));
292 break;
294 case IOR:
295 mark_mode_tests (XEXP (exp, 0));
296 mark_mode_tests (XEXP (exp, 1));
298 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
299 || NO_MODE_TEST (XEXP (exp, 1)));
300 break;
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));
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;
314 default:
315 gcc_unreachable ();
319 /* Determine whether the expression EXP is a MATCH_CODE that should
320 be written as a switch statement. */
321 static bool
322 generate_switch_p (rtx exp)
324 return GET_CODE (exp) == MATCH_CODE
325 && strchr (XSTR (exp, 0), ',');
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. */
334 static void
335 add_mode_tests (struct pred_data *p)
337 rtx match_test_exp, and_exp;
338 rtx *pos;
340 /* Don't touch special predicates. */
341 if (p->special)
342 return;
344 mark_mode_tests (p->exp);
346 /* If the whole expression already tests the mode, we're done. */
347 if (!NO_MODE_TEST (p->exp))
348 return;
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;
355 /* It is always correct to rewrite p->exp as
357 (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode"))
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. */
366 pos = &p->exp;
367 for (;;)
369 rtx subexp = *pos;
371 switch (GET_CODE (subexp))
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;
382 case IOR:
384 int test0 = NO_MODE_TEST (XEXP (subexp, 0));
385 int test1 = NO_MODE_TEST (XEXP (subexp, 1));
387 gcc_assert (test0 || test1);
389 if (test0 && test1)
390 goto break_loop;
391 pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1);
393 break;
395 case IF_THEN_ELSE:
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));
401 gcc_assert ((test0 && test1) || test2);
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);
413 break;
415 default:
416 goto break_loop;
419 break_loop:
420 XEXP (and_exp, 0) = *pos;
421 *pos = and_exp;
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. */
428 static void
429 write_extract_subexp (const char *path)
431 int len = strlen (path);
432 int i;
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--)
438 if (ISLOWER (path[i]))
439 fputs ("XVECEXP (", stdout);
440 else if (ISDIGIT (path[i]))
441 fputs ("XEXP (", stdout);
442 else
443 gcc_unreachable ();
446 fputs ("op", stdout);
448 for (i = 0; i < len; i++)
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 ();
459 /* CODES is a list of RTX codes. Write out an expression which
460 determines whether the operand has one of those codes. */
461 static void
462 write_match_code (const char *path, const char *codes)
464 const char *code;
466 while ((code = scan_comma_elt (&codes)) != 0)
468 fputs ("GET_CODE (", stdout);
469 write_extract_subexp (path);
470 fputs (") == ", stdout);
471 while (code < codes)
473 putchar (TOUPPER (*code));
474 code++;
477 if (*codes == ',')
478 fputs (" || ", stdout);
482 /* EXP is an RTL (sub)expression for a predicate. Recursively
483 descend the expression and write out an equivalent C expression. */
484 static void
485 write_predicate_expr (rtx exp)
487 switch (GET_CODE (exp))
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;
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;
505 case NOT:
506 fputs ("!(", stdout);
507 write_predicate_expr (XEXP (exp, 0));
508 putchar (')');
509 break;
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;
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;
528 case MATCH_CODE:
529 write_match_code (XSTR (exp, 1), XSTR (exp, 0));
530 break;
532 case MATCH_TEST:
533 print_c_condition (XSTR (exp, 0));
534 break;
536 default:
537 gcc_unreachable ();
541 /* Write the MATCH_CODE expression EXP as a switch statement. */
543 static void
544 write_match_code_switch (rtx exp)
546 const char *codes = XSTR (exp, 0);
547 const char *path = XSTR (exp, 1);
548 const char *code;
550 fputs (" switch (GET_CODE (", stdout);
551 write_extract_subexp (path);
552 fputs ("))\n {\n", stdout);
554 while ((code = scan_comma_elt (&codes)) != 0)
556 fputs (" case ", stdout);
557 while (code < codes)
559 putchar (TOUPPER (*code));
560 code++;
562 fputs(":\n", stdout);
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. */
570 static void
571 write_predicate_stmts (rtx exp)
573 switch (GET_CODE (exp))
575 case MATCH_CODE:
576 if (generate_switch_p (exp))
578 write_match_code_switch (exp);
579 puts (" return true;\n"
580 " default:\n"
581 " break;\n"
582 " }\n"
583 " return false;");
584 return;
586 break;
588 case AND:
589 if (generate_switch_p (XEXP (exp, 0)))
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);
598 break;
600 case IOR:
601 if (generate_switch_p (XEXP (exp, 0)))
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);
610 break;
612 case NOT:
613 if (generate_switch_p (XEXP (exp, 0)))
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;
623 break;
625 default:
626 break;
629 fputs(" return ",stdout);
630 write_predicate_expr (exp);
631 fputs(";\n", stdout);
634 /* Given a predicate, write out a complete C function to compute it. */
635 static void
636 write_one_predicate_function (struct pred_data *p)
638 if (!p->exp)
639 return;
641 write_predicate_subfunction (p);
642 add_mode_tests (p);
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);
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. */
660 /* All data from one constraint definition. */
661 struct constraint_data
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;
679 /* Overview of all constraints beginning with a given letter. */
681 static struct constraint_data *
682 constraints_by_letter_table[1<<CHAR_BIT];
684 /* For looking up all the constraints in the order that they appeared
685 in the machine description. */
686 static struct constraint_data *first_constraint;
687 static struct constraint_data **last_constraint_ptr = &first_constraint;
689 #define FOR_ALL_CONSTRAINTS(iter_) \
690 for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
692 /* These letters, and all names beginning with them, are reserved for
693 generic constraints.
694 The 'm' constraint is not mentioned here since that constraint
695 letter can be overridden by the back end by defining the
696 TARGET_MEM_CONSTRAINT macro. */
697 static const char generic_constraint_letters[] = "EFVXginoprs";
699 /* Machine-independent code expects that constraints with these
700 (initial) letters will allow only (a subset of all) CONST_INTs. */
702 static const char const_int_constraints[] = "IJKLMNOP";
704 /* Machine-independent code expects that constraints with these
705 (initial) letters will allow only (a subset of all) CONST_DOUBLEs. */
707 static const char const_dbl_constraints[] = "GH";
709 /* Summary data used to decide whether to output various functions and
710 macro definitions. */
711 static unsigned int constraint_max_namelen;
712 static bool have_register_constraints;
713 static bool have_memory_constraints;
714 static bool have_address_constraints;
715 static bool have_extra_constraints;
716 static bool have_const_int_constraints;
717 static bool have_const_dbl_constraints;
719 /* Convert NAME, which contains angle brackets and/or underscores, to
720 a string that can be used as part of a C identifier. The string
721 comes from the rtl_obstack. */
722 static const char *
723 mangle (const char *name)
725 for (; *name; name++)
726 switch (*name)
728 case '_': obstack_grow (rtl_obstack, "__", 2); break;
729 case '<': obstack_grow (rtl_obstack, "_l", 2); break;
730 case '>': obstack_grow (rtl_obstack, "_g", 2); break;
731 default: obstack_1grow (rtl_obstack, *name); break;
734 obstack_1grow (rtl_obstack, '\0');
735 return XOBFINISH (rtl_obstack, const char *);
738 /* Add one constraint, of any sort, to the tables. NAME is its name;
739 REGCLASS is the register class, if any; EXP is the expression to
740 test, if any; IS_MEMORY and IS_ADDRESS indicate memory and address
741 constraints, respectively; LINENO is the line number from the MD reader.
742 Not all combinations of arguments are valid; most importantly, REGCLASS
743 is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only
744 meaningful for constraints with EXP.
746 This function enforces all syntactic and semantic rules about what
747 constraints can be defined. */
749 static void
750 add_constraint (const char *name, const char *regclass,
751 rtx exp, bool is_memory, bool is_address,
752 int lineno)
754 struct constraint_data *c, **iter, **slot;
755 const char *p;
756 bool need_mangled_name = false;
757 bool is_const_int;
758 bool is_const_dbl;
759 size_t namelen;
761 if (exp && validate_exp (exp, name, lineno))
762 return;
764 if (!ISALPHA (name[0]) && name[0] != '_')
766 if (name[1] == '\0')
767 message_with_line (lineno, "constraint name '%s' is not "
768 "a letter or underscore", name);
769 else
770 message_with_line (lineno, "constraint name '%s' does not begin "
771 "with a letter or underscore", name);
772 have_error = 1;
773 return;
775 for (p = name; *p; p++)
776 if (!ISALNUM (*p))
778 if (*p == '<' || *p == '>' || *p == '_')
779 need_mangled_name = true;
780 else
782 message_with_line (lineno,
783 "constraint name '%s' must be composed of "
784 "letters, digits, underscores, and "
785 "angle brackets", name);
786 have_error = 1;
787 return;
791 if (strchr (generic_constraint_letters, name[0]))
793 if (name[1] == '\0')
794 message_with_line (lineno, "constraint letter '%s' cannot be "
795 "redefined by the machine description", name);
796 else
797 message_with_line (lineno, "constraint name '%s' cannot be defined by "
798 "the machine description, as it begins with '%c'",
799 name, name[0]);
800 have_error = 1;
801 return;
805 namelen = strlen (name);
806 slot = &constraints_by_letter_table[(unsigned int)name[0]];
807 for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
809 /* This causes slot to end up pointing to the
810 next_this_letter field of the last constraint with a name
811 of equal or greater length than the new constraint; hence
812 the new constraint will be inserted after all previous
813 constraints with names of the same length. */
814 if ((*iter)->namelen >= namelen)
815 slot = iter;
817 if (!strcmp ((*iter)->name, name))
819 message_with_line (lineno, "redefinition of constraint '%s'", name);
820 message_with_line ((*iter)->lineno, "previous definition is here");
821 have_error = 1;
822 return;
824 else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
826 message_with_line (lineno, "defining constraint '%s' here", name);
827 message_with_line ((*iter)->lineno, "renders constraint '%s' "
828 "(defined here) a prefix", (*iter)->name);
829 have_error = 1;
830 return;
832 else if (!strncmp ((*iter)->name, name, namelen))
834 message_with_line (lineno, "constraint '%s' is a prefix", name);
835 message_with_line ((*iter)->lineno, "of constraint '%s' "
836 "(defined here)", (*iter)->name);
837 have_error = 1;
838 return;
842 is_const_int = strchr (const_int_constraints, name[0]) != 0;
843 is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
845 if (is_const_int || is_const_dbl)
847 enum rtx_code appropriate_code
848 = is_const_int ? CONST_INT : CONST_DOUBLE;
850 /* Consider relaxing this requirement in the future. */
851 if (regclass
852 || GET_CODE (exp) != AND
853 || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
854 || strcmp (XSTR (XEXP (exp, 0), 0),
855 GET_RTX_NAME (appropriate_code)))
857 if (name[1] == '\0')
858 message_with_line (lineno, "constraint letter '%c' is reserved "
859 "for %s constraints",
860 name[0], GET_RTX_NAME (appropriate_code));
861 else
862 message_with_line (lineno, "constraint names beginning with '%c' "
863 "(%s) are reserved for %s constraints",
864 name[0], name,
865 GET_RTX_NAME (appropriate_code));
867 have_error = 1;
868 return;
871 if (is_memory)
873 if (name[1] == '\0')
874 message_with_line (lineno, "constraint letter '%c' cannot be a "
875 "memory constraint", name[0]);
876 else
877 message_with_line (lineno, "constraint name '%s' begins with '%c', "
878 "and therefore cannot be a memory constraint",
879 name, name[0]);
881 have_error = 1;
882 return;
884 else if (is_address)
886 if (name[1] == '\0')
887 message_with_line (lineno, "constraint letter '%c' cannot be a "
888 "memory constraint", name[0]);
889 else
890 message_with_line (lineno, "constraint name '%s' begins with '%c', "
891 "and therefore cannot be a memory constraint",
892 name, name[0]);
894 have_error = 1;
895 return;
900 c = XOBNEW (rtl_obstack, struct constraint_data);
901 c->name = name;
902 c->c_name = need_mangled_name ? mangle (name) : name;
903 c->lineno = lineno;
904 c->namelen = namelen;
905 c->regclass = regclass;
906 c->exp = exp;
907 c->is_register = regclass != 0;
908 c->is_const_int = is_const_int;
909 c->is_const_dbl = is_const_dbl;
910 c->is_extra = !(regclass || is_const_int || is_const_dbl);
911 c->is_memory = is_memory;
912 c->is_address = is_address;
914 c->next_this_letter = *slot;
915 *slot = c;
917 /* Insert this constraint in the list of all constraints in textual
918 order. */
919 c->next_textual = 0;
920 *last_constraint_ptr = c;
921 last_constraint_ptr = &c->next_textual;
923 constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
924 have_register_constraints |= c->is_register;
925 have_const_int_constraints |= c->is_const_int;
926 have_const_dbl_constraints |= c->is_const_dbl;
927 have_extra_constraints |= c->is_extra;
928 have_memory_constraints |= c->is_memory;
929 have_address_constraints |= c->is_address;
932 /* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or
933 DEFINE_ADDRESS_CONSTRAINT expression, C. */
934 static void
935 process_define_constraint (rtx c, int lineno)
937 add_constraint (XSTR (c, 0), 0, XEXP (c, 2),
938 GET_CODE (c) == DEFINE_MEMORY_CONSTRAINT,
939 GET_CODE (c) == DEFINE_ADDRESS_CONSTRAINT,
940 lineno);
943 /* Process a DEFINE_REGISTER_CONSTRAINT expression, C. */
944 static void
945 process_define_register_constraint (rtx c, int lineno)
947 add_constraint (XSTR (c, 0), XSTR (c, 1), 0, false, false, lineno);
950 /* Write out an enumeration with one entry per machine-specific
951 constraint. */
952 static void
953 write_enum_constraint_num (void)
955 struct constraint_data *c;
957 fputs ("enum constraint_num\n"
958 "{\n"
959 " CONSTRAINT__UNKNOWN = 0", stdout);
960 FOR_ALL_CONSTRAINTS (c)
961 printf (",\n CONSTRAINT_%s", c->c_name);
962 puts (",\n CONSTRAINT__LIMIT\n};\n");
965 /* Write out a function which looks at a string and determines what
966 constraint name, if any, it begins with. */
967 static void
968 write_lookup_constraint (void)
970 unsigned int i;
971 puts ("enum constraint_num\n"
972 "lookup_constraint (const char *str)\n"
973 "{\n"
974 " switch (str[0])\n"
975 " {");
977 for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
979 struct constraint_data *c = constraints_by_letter_table[i];
980 if (!c)
981 continue;
983 printf (" case '%c':\n", i);
984 if (c->namelen == 1)
985 printf (" return CONSTRAINT_%s;\n", c->c_name);
986 else
990 printf (" if (!strncmp (str, \"%s\", %lu))\n"
991 " return CONSTRAINT_%s;\n",
992 c->name, (unsigned long int) c->namelen, c->c_name);
993 c = c->next_this_letter;
995 while (c);
996 puts (" break;");
1000 puts (" default: break;\n"
1001 " }\n"
1002 " return CONSTRAINT__UNKNOWN;\n"
1003 "}\n");
1006 /* Write out a function which looks at a string and determines what
1007 the constraint name length is. */
1008 static void
1009 write_insn_constraint_len (void)
1011 unsigned int i;
1013 puts ("static inline size_t\n"
1014 "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n"
1015 "{\n"
1016 " switch (fc)\n"
1017 " {");
1019 for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
1021 struct constraint_data *c = constraints_by_letter_table[i];
1023 if (!c
1024 || c->namelen == 1)
1025 continue;
1027 /* Constraints with multiple characters should have the same
1028 length. */
1030 struct constraint_data *c2 = c->next_this_letter;
1031 size_t len = c->namelen;
1032 while (c2)
1034 if (c2->namelen != len)
1035 error ("Multi-letter constraints with first letter '%c' "
1036 "should have same length", i);
1037 c2 = c2->next_this_letter;
1041 printf (" case '%c': return %lu;\n",
1042 i, (unsigned long int) c->namelen);
1045 puts (" default: break;\n"
1046 " }\n"
1047 " return 1;\n"
1048 "}\n");
1051 /* Write out the function which computes the register class corresponding
1052 to a register constraint. */
1053 static void
1054 write_regclass_for_constraint (void)
1056 struct constraint_data *c;
1058 puts ("enum reg_class\n"
1059 "regclass_for_constraint (enum constraint_num c)\n"
1060 "{\n"
1061 " switch (c)\n"
1062 " {");
1064 FOR_ALL_CONSTRAINTS (c)
1065 if (c->is_register)
1066 printf (" case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
1068 puts (" default: break;\n"
1069 " }\n"
1070 " return NO_REGS;\n"
1071 "}\n");
1074 /* Write out the functions which compute whether a given value matches
1075 a given non-register constraint. */
1076 static void
1077 write_tm_constrs_h (void)
1079 struct constraint_data *c;
1081 printf ("\
1082 /* Generated automatically by the program '%s'\n\
1083 from the machine description file '%s'. */\n\n", progname, in_fname);
1085 puts ("\
1086 #ifndef GCC_TM_CONSTRS_H\n\
1087 #define GCC_TM_CONSTRS_H\n");
1089 FOR_ALL_CONSTRAINTS (c)
1090 if (!c->is_register)
1092 bool needs_ival = needs_variable (c->exp, "ival");
1093 bool needs_hval = needs_variable (c->exp, "hval");
1094 bool needs_lval = needs_variable (c->exp, "lval");
1095 bool needs_rval = needs_variable (c->exp, "rval");
1096 bool needs_mode = (needs_variable (c->exp, "mode")
1097 || needs_hval || needs_lval || needs_rval);
1098 bool needs_op = (needs_variable (c->exp, "op")
1099 || needs_ival || needs_mode);
1101 printf ("static inline bool\n"
1102 "satisfies_constraint_%s (rtx %s)\n"
1103 "{\n", c->c_name,
1104 needs_op ? "op" : "ARG_UNUSED (op)");
1105 if (needs_mode)
1106 puts (" enum machine_mode mode = GET_MODE (op);");
1107 if (needs_ival)
1108 puts (" HOST_WIDE_INT ival = 0;");
1109 if (needs_hval)
1110 puts (" HOST_WIDE_INT hval = 0;");
1111 if (needs_lval)
1112 puts (" unsigned HOST_WIDE_INT lval = 0;");
1113 if (needs_rval)
1114 puts (" const REAL_VALUE_TYPE *rval = 0;");
1116 if (needs_ival)
1117 puts (" if (GET_CODE (op) == CONST_INT)\n"
1118 " ival = INTVAL (op);");
1119 if (needs_hval)
1120 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1121 " hval = CONST_DOUBLE_HIGH (op);");
1122 if (needs_lval)
1123 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1124 " lval = CONST_DOUBLE_LOW (op);");
1125 if (needs_rval)
1126 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
1127 " rval = CONST_DOUBLE_REAL_VALUE (op);");
1129 write_predicate_stmts (c->exp);
1130 fputs ("}\n", stdout);
1132 puts ("#endif /* tm-constrs.h */");
1135 /* Write out the wrapper function, constraint_satisfied_p, that maps
1136 a CONSTRAINT_xxx constant to one of the predicate functions generated
1137 above. */
1138 static void
1139 write_constraint_satisfied_p (void)
1141 struct constraint_data *c;
1143 puts ("bool\n"
1144 "constraint_satisfied_p (rtx op, enum constraint_num c)\n"
1145 "{\n"
1146 " switch (c)\n"
1147 " {");
1149 FOR_ALL_CONSTRAINTS (c)
1150 if (!c->is_register)
1151 printf (" case CONSTRAINT_%s: "
1152 "return satisfies_constraint_%s (op);\n",
1153 c->c_name, c->c_name);
1155 puts (" default: break;\n"
1156 " }\n"
1157 " return false;\n"
1158 "}\n");
1161 /* Write out the function which computes whether a given value matches
1162 a given CONST_INT constraint. This doesn't just forward to
1163 constraint_satisfied_p because caller passes the INTVAL, not the RTX. */
1164 static void
1165 write_insn_const_int_ok_for_constraint (void)
1167 struct constraint_data *c;
1169 puts ("bool\n"
1170 "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1171 "enum constraint_num c)\n"
1172 "{\n"
1173 " switch (c)\n"
1174 " {");
1176 FOR_ALL_CONSTRAINTS (c)
1177 if (c->is_const_int)
1179 printf (" case CONSTRAINT_%s:\n return ", c->c_name);
1180 /* c->exp is guaranteed to be (and (match_code "const_int") (...));
1181 we know at this point that we have a const_int, so we need not
1182 bother with that part of the test. */
1183 write_predicate_expr (XEXP (c->exp, 1));
1184 fputs (";\n\n", stdout);
1187 puts (" default: break;\n"
1188 " }\n"
1189 " return false;\n"
1190 "}\n");
1194 /* Write out the function which computes whether a given constraint is
1195 a memory constraint. */
1196 static void
1197 write_insn_extra_memory_constraint (void)
1199 struct constraint_data *c;
1201 puts ("bool\n"
1202 "insn_extra_memory_constraint (enum constraint_num c)\n"
1203 "{\n"
1204 " switch (c)\n"
1205 " {");
1207 FOR_ALL_CONSTRAINTS (c)
1208 if (c->is_memory)
1209 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name);
1211 puts (" default: break;\n"
1212 " }\n"
1213 " return false;\n"
1214 "}\n");
1217 /* Write out the function which computes whether a given constraint is
1218 an address constraint. */
1219 static void
1220 write_insn_extra_address_constraint (void)
1222 struct constraint_data *c;
1224 puts ("bool\n"
1225 "insn_extra_address_constraint (enum constraint_num c)\n"
1226 "{\n"
1227 " switch (c)\n"
1228 " {");
1230 FOR_ALL_CONSTRAINTS (c)
1231 if (c->is_address)
1232 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name);
1234 puts (" default: break;\n"
1235 " }\n"
1236 " return false;\n"
1237 "}\n");
1241 /* Write tm-preds.h. Unfortunately, it is impossible to forward-declare
1242 an enumeration in portable C, so we have to condition all these
1243 prototypes on HAVE_MACHINE_MODES. */
1244 static void
1245 write_tm_preds_h (void)
1247 struct pred_data *p;
1249 printf ("\
1250 /* Generated automatically by the program '%s'\n\
1251 from the machine description file '%s'. */\n\n", progname, in_fname);
1253 puts ("\
1254 #ifndef GCC_TM_PREDS_H\n\
1255 #define GCC_TM_PREDS_H\n\
1257 #ifdef HAVE_MACHINE_MODES");
1259 FOR_ALL_PREDICATES (p)
1260 printf ("extern int %s (rtx, enum machine_mode);\n", p->name);
1262 puts ("#endif /* HAVE_MACHINE_MODES */\n");
1264 if (constraint_max_namelen > 0)
1266 write_enum_constraint_num ();
1267 puts ("extern enum constraint_num lookup_constraint (const char *);\n"
1268 "extern bool constraint_satisfied_p (rtx, enum constraint_num);\n");
1270 if (constraint_max_namelen > 1)
1272 write_insn_constraint_len ();
1273 puts ("#define CONSTRAINT_LEN(c_,s_) "
1274 "insn_constraint_len (c_,s_)\n");
1276 else
1277 puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1278 if (have_register_constraints)
1279 puts ("extern enum reg_class regclass_for_constraint "
1280 "(enum constraint_num);\n"
1281 "#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n"
1282 " regclass_for_constraint (lookup_constraint (s_))\n");
1283 else
1284 puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS");
1285 if (have_const_int_constraints)
1286 puts ("extern bool insn_const_int_ok_for_constraint "
1287 "(HOST_WIDE_INT, enum constraint_num);\n"
1288 "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1289 " insn_const_int_ok_for_constraint (v_, "
1290 "lookup_constraint (s_))\n");
1291 if (have_const_dbl_constraints)
1292 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1293 " constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1294 else
1295 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) 0\n");
1296 if (have_extra_constraints)
1297 puts ("#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \\\n"
1298 " constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1299 if (have_memory_constraints)
1300 puts ("extern bool "
1301 "insn_extra_memory_constraint (enum constraint_num);\n"
1302 "#define EXTRA_MEMORY_CONSTRAINT(c_,s_) "
1303 "insn_extra_memory_constraint (lookup_constraint (s_))\n");
1304 else
1305 puts ("#define EXTRA_MEMORY_CONSTRAINT(c_,s_) false\n");
1306 if (have_address_constraints)
1307 puts ("extern bool "
1308 "insn_extra_address_constraint (enum constraint_num);\n"
1309 "#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) "
1310 "insn_extra_address_constraint (lookup_constraint (s_))\n");
1311 else
1312 puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n");
1315 puts ("#endif /* tm-preds.h */");
1318 /* Write insn-preds.c.
1319 N.B. the list of headers to include was copied from genrecog; it
1320 may not be ideal.
1322 FUTURE: Write #line markers referring back to the machine
1323 description. (Can't practically do this now since we don't know
1324 the line number of the C block - just the line number of the enclosing
1325 expression.) */
1326 static void
1327 write_insn_preds_c (void)
1329 struct pred_data *p;
1331 printf ("\
1332 /* Generated automatically by the program '%s'\n\
1333 from the machine description file '%s'. */\n\n", progname, in_fname);
1335 puts ("\
1336 #include \"config.h\"\n\
1337 #include \"system.h\"\n\
1338 #include \"coretypes.h\"\n\
1339 #include \"tm.h\"\n\
1340 #include \"rtl.h\"\n\
1341 #include \"tree.h\"\n\
1342 #include \"tm_p.h\"\n\
1343 #include \"function.h\"\n\
1344 #include \"insn-config.h\"\n\
1345 #include \"recog.h\"\n\
1346 #include \"real.h\"\n\
1347 #include \"output.h\"\n\
1348 #include \"flags.h\"\n\
1349 #include \"hard-reg-set.h\"\n\
1350 #include \"resource.h\"\n\
1351 #include \"toplev.h\"\n\
1352 #include \"reload.h\"\n\
1353 #include \"regs.h\"\n\
1354 #include \"tm-constrs.h\"\n");
1356 FOR_ALL_PREDICATES (p)
1357 write_one_predicate_function (p);
1359 if (constraint_max_namelen > 0)
1361 write_lookup_constraint ();
1362 if (have_register_constraints)
1363 write_regclass_for_constraint ();
1364 write_constraint_satisfied_p ();
1366 if (have_const_int_constraints)
1367 write_insn_const_int_ok_for_constraint ();
1369 if (have_memory_constraints)
1370 write_insn_extra_memory_constraint ();
1371 if (have_address_constraints)
1372 write_insn_extra_address_constraint ();
1376 /* Argument parsing. */
1377 static bool gen_header;
1378 static bool gen_constrs;
1380 static bool
1381 parse_option (const char *opt)
1383 if (!strcmp (opt, "-h"))
1385 gen_header = true;
1386 return 1;
1388 else if (!strcmp (opt, "-c"))
1390 gen_constrs = true;
1391 return 1;
1393 else
1394 return 0;
1397 /* Master control. */
1399 main (int argc, char **argv)
1401 rtx defn;
1402 int pattern_lineno, next_insn_code = 0;
1404 progname = argv[0];
1405 if (argc <= 1)
1406 fatal ("no input file name");
1407 if (init_md_reader_args_cb (argc, argv, parse_option) != SUCCESS_EXIT_CODE)
1408 return FATAL_EXIT_CODE;
1410 while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0)
1411 switch (GET_CODE (defn))
1413 case DEFINE_PREDICATE:
1414 case DEFINE_SPECIAL_PREDICATE:
1415 process_define_predicate (defn, pattern_lineno);
1416 break;
1418 case DEFINE_CONSTRAINT:
1419 case DEFINE_MEMORY_CONSTRAINT:
1420 case DEFINE_ADDRESS_CONSTRAINT:
1421 process_define_constraint (defn, pattern_lineno);
1422 break;
1424 case DEFINE_REGISTER_CONSTRAINT:
1425 process_define_register_constraint (defn, pattern_lineno);
1426 break;
1428 default:
1429 break;
1432 if (gen_header)
1433 write_tm_preds_h ();
1434 else if (gen_constrs)
1435 write_tm_constrs_h ();
1436 else
1437 write_insn_preds_c ();
1439 if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
1440 return FATAL_EXIT_CODE;
1442 return SUCCESS_EXIT_CODE;