Daily bump.
[official-gcc.git] / gcc / genpreds.c
blobeba3e1472c9222379d7c7506ca631168ebef1c68
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-2014 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 #include "bconfig.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "errors.h"
29 #include "obstack.h"
30 #include "read-md.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 error_with_line (lineno, "%s: invalid character in path "
70 "string '%s'", name, XSTR (exp, 1));
71 return true;
75 /* fall through */
77 /* These need no special checking. */
78 case MATCH_OPERAND:
79 case MATCH_TEST:
80 return false;
82 default:
83 error_with_line (lineno,
84 "%s: cannot use '%s' in a predicate expression",
85 name, GET_RTX_NAME (GET_CODE (exp)));
86 return true;
90 /* Predicates are defined with (define_predicate) or
91 (define_special_predicate) expressions in the machine description. */
92 static void
93 process_define_predicate (rtx defn, int lineno)
95 validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno);
98 /* Given a predicate, if it has an embedded C block, write the block
99 out as a static inline subroutine, and augment the RTL test with a
100 match_test that calls that subroutine. For instance,
102 (define_predicate "basereg_operand"
103 (match_operand 0 "register_operand")
105 if (GET_CODE (op) == SUBREG)
106 op = SUBREG_REG (op);
107 return REG_POINTER (op);
110 becomes
112 static inline int basereg_operand_1(rtx op, enum machine_mode mode)
114 if (GET_CODE (op) == SUBREG)
115 op = SUBREG_REG (op);
116 return REG_POINTER (op);
119 (define_predicate "basereg_operand"
120 (and (match_operand 0 "register_operand")
121 (match_test "basereg_operand_1 (op, mode)")))
123 The only wart is that there's no way to insist on a { } string in
124 an RTL template, so we have to handle "" strings. */
127 static void
128 write_predicate_subfunction (struct pred_data *p)
130 const char *match_test_str;
131 rtx match_test_exp, and_exp;
133 if (p->c_block[0] == '\0')
134 return;
136 /* Construct the function-call expression. */
137 obstack_grow (rtl_obstack, p->name, strlen (p->name));
138 obstack_grow (rtl_obstack, "_1 (op, mode)",
139 sizeof "_1 (op, mode)");
140 match_test_str = XOBFINISH (rtl_obstack, const char *);
142 /* Add the function-call expression to the complete expression to be
143 evaluated. */
144 match_test_exp = rtx_alloc (MATCH_TEST);
145 XSTR (match_test_exp, 0) = match_test_str;
147 and_exp = rtx_alloc (AND);
148 XEXP (and_exp, 0) = p->exp;
149 XEXP (and_exp, 1) = match_test_exp;
151 p->exp = and_exp;
153 printf ("static inline int\n"
154 "%s_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n",
155 p->name);
156 print_md_ptr_loc (p->c_block);
157 if (p->c_block[0] == '{')
158 fputs (p->c_block, stdout);
159 else
160 printf ("{\n %s\n}", p->c_block);
161 fputs ("\n\n", stdout);
164 /* Given a predicate expression EXP, from form NAME, determine whether
165 it refers to the variable given as VAR. */
166 static bool
167 needs_variable (rtx exp, const char *var)
169 switch (GET_CODE (exp))
171 /* Ternary, binary, unary expressions need a variable if
172 any of their subexpressions do. */
173 case IF_THEN_ELSE:
174 if (needs_variable (XEXP (exp, 2), var))
175 return true;
176 /* else fall through */
177 case AND:
178 case IOR:
179 if (needs_variable (XEXP (exp, 1), var))
180 return true;
181 /* else fall through */
182 case NOT:
183 return needs_variable (XEXP (exp, 0), var);
185 /* MATCH_CODE uses "op", but nothing else. */
186 case MATCH_CODE:
187 return !strcmp (var, "op");
189 /* MATCH_OPERAND uses "op" and may use "mode". */
190 case MATCH_OPERAND:
191 if (!strcmp (var, "op"))
192 return true;
193 if (!strcmp (var, "mode") && GET_MODE (exp) == VOIDmode)
194 return true;
195 return false;
197 /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
198 case MATCH_TEST:
200 const char *p = XSTR (exp, 0);
201 const char *q = strstr (p, var);
202 if (!q)
203 return false;
204 if (q != p && (ISALNUM (q[-1]) || q[-1] == '_'))
205 return false;
206 q += strlen (var);
207 if (ISALNUM (q[0]) || q[0] == '_')
208 return false;
210 return true;
212 default:
213 gcc_unreachable ();
217 /* Given an RTL expression EXP, find all subexpressions which we may
218 assume to perform mode tests. Normal MATCH_OPERAND does;
219 MATCH_CODE does if it applies to the whole expression and accepts
220 CONST_INT or CONST_DOUBLE; and we have to assume that MATCH_TEST
221 does not. These combine in almost-boolean fashion - the only
222 exception is that (not X) must be assumed not to perform a mode
223 test, whether or not X does.
225 The mark is the RTL /v flag, which is true for subexpressions which
226 do *not* perform mode tests.
228 #define NO_MODE_TEST(EXP) RTX_FLAG (EXP, volatil)
229 static void
230 mark_mode_tests (rtx exp)
232 switch (GET_CODE (exp))
234 case MATCH_OPERAND:
236 struct pred_data *p = lookup_predicate (XSTR (exp, 1));
237 if (!p)
238 error ("reference to undefined predicate '%s'", XSTR (exp, 1));
239 else if (p->special || GET_MODE (exp) != VOIDmode)
240 NO_MODE_TEST (exp) = 1;
242 break;
244 case MATCH_CODE:
245 if (XSTR (exp, 1)[0] != '\0'
246 || (!strstr (XSTR (exp, 0), "const_int")
247 && !strstr (XSTR (exp, 0), "const_double")))
248 NO_MODE_TEST (exp) = 1;
249 break;
251 case MATCH_TEST:
252 case NOT:
253 NO_MODE_TEST (exp) = 1;
254 break;
256 case AND:
257 mark_mode_tests (XEXP (exp, 0));
258 mark_mode_tests (XEXP (exp, 1));
260 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
261 && NO_MODE_TEST (XEXP (exp, 1)));
262 break;
264 case IOR:
265 mark_mode_tests (XEXP (exp, 0));
266 mark_mode_tests (XEXP (exp, 1));
268 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
269 || NO_MODE_TEST (XEXP (exp, 1)));
270 break;
272 case IF_THEN_ELSE:
273 /* A ? B : C does a mode test if (one of A and B) does a mode
274 test, and C does too. */
275 mark_mode_tests (XEXP (exp, 0));
276 mark_mode_tests (XEXP (exp, 1));
277 mark_mode_tests (XEXP (exp, 2));
279 NO_MODE_TEST (exp) = ((NO_MODE_TEST (XEXP (exp, 0))
280 && NO_MODE_TEST (XEXP (exp, 1)))
281 || NO_MODE_TEST (XEXP (exp, 2)));
282 break;
284 default:
285 gcc_unreachable ();
289 /* Determine whether the expression EXP is a MATCH_CODE that should
290 be written as a switch statement. */
291 static bool
292 generate_switch_p (rtx exp)
294 return GET_CODE (exp) == MATCH_CODE
295 && strchr (XSTR (exp, 0), ',');
298 /* Given a predicate, work out where in its RTL expression to add
299 tests for proper modes. Special predicates do not get any such
300 tests. We try to avoid adding tests when we don't have to; in
301 particular, other normal predicates can be counted on to do it for
302 us. */
304 static void
305 add_mode_tests (struct pred_data *p)
307 rtx match_test_exp, and_exp;
308 rtx *pos;
310 /* Don't touch special predicates. */
311 if (p->special)
312 return;
314 mark_mode_tests (p->exp);
316 /* If the whole expression already tests the mode, we're done. */
317 if (!NO_MODE_TEST (p->exp))
318 return;
320 match_test_exp = rtx_alloc (MATCH_TEST);
321 XSTR (match_test_exp, 0) = "mode == VOIDmode || GET_MODE (op) == mode";
322 and_exp = rtx_alloc (AND);
323 XEXP (and_exp, 1) = match_test_exp;
325 /* It is always correct to rewrite p->exp as
327 (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode"))
329 but there are a couple forms where we can do better. If the
330 top-level pattern is an IOR, and one of the two branches does test
331 the mode, we can wrap just the branch that doesn't. Likewise, if
332 we have an IF_THEN_ELSE, and one side of it tests the mode, we can
333 wrap just the side that doesn't. And, of course, we can repeat this
334 descent as many times as it works. */
336 pos = &p->exp;
337 for (;;)
339 rtx subexp = *pos;
341 switch (GET_CODE (subexp))
343 case AND:
344 /* The switch code generation in write_predicate_stmts prefers
345 rtx code tests to be at the top of the expression tree. So
346 push this AND down into the second operand of an existing
347 AND expression. */
348 if (generate_switch_p (XEXP (subexp, 0)))
349 pos = &XEXP (subexp, 1);
350 goto break_loop;
352 case IOR:
354 int test0 = NO_MODE_TEST (XEXP (subexp, 0));
355 int test1 = NO_MODE_TEST (XEXP (subexp, 1));
357 gcc_assert (test0 || test1);
359 if (test0 && test1)
360 goto break_loop;
361 pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1);
363 break;
365 case IF_THEN_ELSE:
367 int test0 = NO_MODE_TEST (XEXP (subexp, 0));
368 int test1 = NO_MODE_TEST (XEXP (subexp, 1));
369 int test2 = NO_MODE_TEST (XEXP (subexp, 2));
371 gcc_assert ((test0 && test1) || test2);
373 if (test0 && test1 && test2)
374 goto break_loop;
375 if (test0 && test1)
376 /* Must put it on the dependent clause, not the
377 controlling expression, or we change the meaning of
378 the test. */
379 pos = &XEXP (subexp, 1);
380 else
381 pos = &XEXP (subexp, 2);
383 break;
385 default:
386 goto break_loop;
389 break_loop:
390 XEXP (and_exp, 0) = *pos;
391 *pos = and_exp;
394 /* PATH is a string describing a path from the root of an RTL
395 expression to an inner subexpression to be tested. Output
396 code which computes the subexpression from the variable
397 holding the root of the expression. */
398 static void
399 write_extract_subexp (const char *path)
401 int len = strlen (path);
402 int i;
404 /* We first write out the operations (XEXP or XVECEXP) in reverse
405 order, then write "op", then the indices in forward order. */
406 for (i = len - 1; i >= 0; i--)
408 if (ISLOWER (path[i]))
409 fputs ("XVECEXP (", stdout);
410 else if (ISDIGIT (path[i]))
411 fputs ("XEXP (", stdout);
412 else
413 gcc_unreachable ();
416 fputs ("op", stdout);
418 for (i = 0; i < len; i++)
420 if (ISLOWER (path[i]))
421 printf (", 0, %d)", path[i] - 'a');
422 else if (ISDIGIT (path[i]))
423 printf (", %d)", path[i] - '0');
424 else
425 gcc_unreachable ();
429 /* CODES is a list of RTX codes. Write out an expression which
430 determines whether the operand has one of those codes. */
431 static void
432 write_match_code (const char *path, const char *codes)
434 const char *code;
436 while ((code = scan_comma_elt (&codes)) != 0)
438 fputs ("GET_CODE (", stdout);
439 write_extract_subexp (path);
440 fputs (") == ", stdout);
441 while (code < codes)
443 putchar (TOUPPER (*code));
444 code++;
447 if (*codes == ',')
448 fputs (" || ", stdout);
452 /* EXP is an RTL (sub)expression for a predicate. Recursively
453 descend the expression and write out an equivalent C expression. */
454 static void
455 write_predicate_expr (rtx exp)
457 switch (GET_CODE (exp))
459 case AND:
460 putchar ('(');
461 write_predicate_expr (XEXP (exp, 0));
462 fputs (") && (", stdout);
463 write_predicate_expr (XEXP (exp, 1));
464 putchar (')');
465 break;
467 case IOR:
468 putchar ('(');
469 write_predicate_expr (XEXP (exp, 0));
470 fputs (") || (", stdout);
471 write_predicate_expr (XEXP (exp, 1));
472 putchar (')');
473 break;
475 case NOT:
476 fputs ("!(", stdout);
477 write_predicate_expr (XEXP (exp, 0));
478 putchar (')');
479 break;
481 case IF_THEN_ELSE:
482 putchar ('(');
483 write_predicate_expr (XEXP (exp, 0));
484 fputs (") ? (", stdout);
485 write_predicate_expr (XEXP (exp, 1));
486 fputs (") : (", stdout);
487 write_predicate_expr (XEXP (exp, 2));
488 putchar (')');
489 break;
491 case MATCH_OPERAND:
492 if (GET_MODE (exp) == VOIDmode)
493 printf ("%s (op, mode)", XSTR (exp, 1));
494 else
495 printf ("%s (op, %smode)", XSTR (exp, 1), mode_name[GET_MODE (exp)]);
496 break;
498 case MATCH_CODE:
499 write_match_code (XSTR (exp, 1), XSTR (exp, 0));
500 break;
502 case MATCH_TEST:
503 print_c_condition (XSTR (exp, 0));
504 break;
506 default:
507 gcc_unreachable ();
511 /* Write the MATCH_CODE expression EXP as a switch statement. */
513 static void
514 write_match_code_switch (rtx exp)
516 const char *codes = XSTR (exp, 0);
517 const char *path = XSTR (exp, 1);
518 const char *code;
520 fputs (" switch (GET_CODE (", stdout);
521 write_extract_subexp (path);
522 fputs ("))\n {\n", stdout);
524 while ((code = scan_comma_elt (&codes)) != 0)
526 fputs (" case ", stdout);
527 while (code < codes)
529 putchar (TOUPPER (*code));
530 code++;
532 fputs (":\n", stdout);
536 /* Given a predicate expression EXP, write out a sequence of stmts
537 to evaluate it. This is similar to write_predicate_expr but can
538 generate efficient switch statements. */
540 static void
541 write_predicate_stmts (rtx exp)
543 switch (GET_CODE (exp))
545 case MATCH_CODE:
546 if (generate_switch_p (exp))
548 write_match_code_switch (exp);
549 puts (" return true;\n"
550 " default:\n"
551 " break;\n"
552 " }\n"
553 " return false;");
554 return;
556 break;
558 case AND:
559 if (generate_switch_p (XEXP (exp, 0)))
561 write_match_code_switch (XEXP (exp, 0));
562 puts (" break;\n"
563 " default:\n"
564 " return false;\n"
565 " }");
566 exp = XEXP (exp, 1);
568 break;
570 case IOR:
571 if (generate_switch_p (XEXP (exp, 0)))
573 write_match_code_switch (XEXP (exp, 0));
574 puts (" return true;\n"
575 " default:\n"
576 " break;\n"
577 " }");
578 exp = XEXP (exp, 1);
580 break;
582 case NOT:
583 if (generate_switch_p (XEXP (exp, 0)))
585 write_match_code_switch (XEXP (exp, 0));
586 puts (" return false;\n"
587 " default:\n"
588 " break;\n"
589 " }\n"
590 " return true;");
591 return;
593 break;
595 default:
596 break;
599 fputs (" return ",stdout);
600 write_predicate_expr (exp);
601 fputs (";\n", stdout);
604 /* Given a predicate, write out a complete C function to compute it. */
605 static void
606 write_one_predicate_function (struct pred_data *p)
608 if (!p->exp)
609 return;
611 write_predicate_subfunction (p);
612 add_mode_tests (p);
614 /* A normal predicate can legitimately not look at enum machine_mode
615 if it accepts only CONST_INTs and/or CONST_DOUBLEs. */
616 printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n{\n",
617 p->name);
618 write_predicate_stmts (p->exp);
619 fputs ("}\n\n", stdout);
622 /* Constraints fall into two categories: register constraints
623 (define_register_constraint), and others (define_constraint,
624 define_memory_constraint, define_address_constraint). We
625 work out automatically which of the various old-style macros
626 they correspond to, and produce appropriate code. They all
627 go in the same hash table so we can verify that there are no
628 duplicate names. */
630 /* All data from one constraint definition. */
631 struct constraint_data
633 struct constraint_data *next_this_letter;
634 struct constraint_data *next_textual;
635 const char *name;
636 const char *c_name; /* same as .name unless mangling is necessary */
637 size_t namelen;
638 const char *regclass; /* for register constraints */
639 rtx exp; /* for other constraints */
640 unsigned int lineno; /* line of definition */
641 unsigned int is_register : 1;
642 unsigned int is_const_int : 1;
643 unsigned int is_const_dbl : 1;
644 unsigned int is_extra : 1;
645 unsigned int is_memory : 1;
646 unsigned int is_address : 1;
649 /* Overview of all constraints beginning with a given letter. */
651 static struct constraint_data *
652 constraints_by_letter_table[1<<CHAR_BIT];
654 /* For looking up all the constraints in the order that they appeared
655 in the machine description. */
656 static struct constraint_data *first_constraint;
657 static struct constraint_data **last_constraint_ptr = &first_constraint;
659 #define FOR_ALL_CONSTRAINTS(iter_) \
660 for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
662 /* These letters, and all names beginning with them, are reserved for
663 generic constraints.
664 The 'm' constraint is not mentioned here since that constraint
665 letter can be overridden by the back end by defining the
666 TARGET_MEM_CONSTRAINT macro. */
667 static const char generic_constraint_letters[] = "EFVXginoprs";
669 /* Machine-independent code expects that constraints with these
670 (initial) letters will allow only (a subset of all) CONST_INTs. */
672 static const char const_int_constraints[] = "IJKLMNOP";
674 /* Machine-independent code expects that constraints with these
675 (initial) letters will allow only (a subset of all) CONST_DOUBLEs. */
677 static const char const_dbl_constraints[] = "GH";
679 /* Summary data used to decide whether to output various functions and
680 macro definitions. */
681 static unsigned int constraint_max_namelen;
682 static bool have_register_constraints;
683 static bool have_memory_constraints;
684 static bool have_address_constraints;
685 static bool have_extra_constraints;
686 static bool have_const_int_constraints;
687 static bool have_const_dbl_constraints;
689 /* Convert NAME, which contains angle brackets and/or underscores, to
690 a string that can be used as part of a C identifier. The string
691 comes from the rtl_obstack. */
692 static const char *
693 mangle (const char *name)
695 for (; *name; name++)
696 switch (*name)
698 case '_': obstack_grow (rtl_obstack, "__", 2); break;
699 case '<': obstack_grow (rtl_obstack, "_l", 2); break;
700 case '>': obstack_grow (rtl_obstack, "_g", 2); break;
701 default: obstack_1grow (rtl_obstack, *name); break;
704 obstack_1grow (rtl_obstack, '\0');
705 return XOBFINISH (rtl_obstack, const char *);
708 /* Add one constraint, of any sort, to the tables. NAME is its name;
709 REGCLASS is the register class, if any; EXP is the expression to
710 test, if any; IS_MEMORY and IS_ADDRESS indicate memory and address
711 constraints, respectively; LINENO is the line number from the MD reader.
712 Not all combinations of arguments are valid; most importantly, REGCLASS
713 is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only
714 meaningful for constraints with EXP.
716 This function enforces all syntactic and semantic rules about what
717 constraints can be defined. */
719 static void
720 add_constraint (const char *name, const char *regclass,
721 rtx exp, bool is_memory, bool is_address,
722 int lineno)
724 struct constraint_data *c, **iter, **slot;
725 const char *p;
726 bool need_mangled_name = false;
727 bool is_const_int;
728 bool is_const_dbl;
729 size_t namelen;
731 if (exp && validate_exp (exp, name, lineno))
732 return;
734 if (!ISALPHA (name[0]) && name[0] != '_')
736 if (name[1] == '\0')
737 error_with_line (lineno, "constraint name '%s' is not "
738 "a letter or underscore", name);
739 else
740 error_with_line (lineno, "constraint name '%s' does not begin "
741 "with a letter or underscore", name);
742 return;
744 for (p = name; *p; p++)
745 if (!ISALNUM (*p))
747 if (*p == '<' || *p == '>' || *p == '_')
748 need_mangled_name = true;
749 else
751 error_with_line (lineno,
752 "constraint name '%s' must be composed of "
753 "letters, digits, underscores, and "
754 "angle brackets", name);
755 return;
759 if (strchr (generic_constraint_letters, name[0]))
761 if (name[1] == '\0')
762 error_with_line (lineno, "constraint letter '%s' cannot be "
763 "redefined by the machine description", name);
764 else
765 error_with_line (lineno, "constraint name '%s' cannot be defined by "
766 "the machine description, as it begins with '%c'",
767 name, name[0]);
768 return;
772 namelen = strlen (name);
773 slot = &constraints_by_letter_table[(unsigned int)name[0]];
774 for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
776 /* This causes slot to end up pointing to the
777 next_this_letter field of the last constraint with a name
778 of equal or greater length than the new constraint; hence
779 the new constraint will be inserted after all previous
780 constraints with names of the same length. */
781 if ((*iter)->namelen >= namelen)
782 slot = iter;
784 if (!strcmp ((*iter)->name, name))
786 error_with_line (lineno, "redefinition of constraint '%s'", name);
787 message_with_line ((*iter)->lineno, "previous definition is here");
788 return;
790 else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
792 error_with_line (lineno, "defining constraint '%s' here", name);
793 message_with_line ((*iter)->lineno, "renders constraint '%s' "
794 "(defined here) a prefix", (*iter)->name);
795 return;
797 else if (!strncmp ((*iter)->name, name, namelen))
799 error_with_line (lineno, "constraint '%s' is a prefix", name);
800 message_with_line ((*iter)->lineno, "of constraint '%s' "
801 "(defined here)", (*iter)->name);
802 return;
806 is_const_int = strchr (const_int_constraints, name[0]) != 0;
807 is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
809 if (is_const_int || is_const_dbl)
811 enum rtx_code appropriate_code
812 = is_const_int ? CONST_INT : CONST_DOUBLE;
814 /* Consider relaxing this requirement in the future. */
815 if (regclass
816 || GET_CODE (exp) != AND
817 || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
818 || strcmp (XSTR (XEXP (exp, 0), 0),
819 GET_RTX_NAME (appropriate_code)))
821 if (name[1] == '\0')
822 error_with_line (lineno, "constraint letter '%c' is reserved "
823 "for %s constraints",
824 name[0], GET_RTX_NAME (appropriate_code));
825 else
826 error_with_line (lineno, "constraint names beginning with '%c' "
827 "(%s) are reserved for %s constraints",
828 name[0], name, GET_RTX_NAME (appropriate_code));
829 return;
832 if (is_memory)
834 if (name[1] == '\0')
835 error_with_line (lineno, "constraint letter '%c' cannot be a "
836 "memory constraint", name[0]);
837 else
838 error_with_line (lineno, "constraint name '%s' begins with '%c', "
839 "and therefore cannot be a memory constraint",
840 name, name[0]);
841 return;
843 else if (is_address)
845 if (name[1] == '\0')
846 error_with_line (lineno, "constraint letter '%c' cannot be a "
847 "memory constraint", name[0]);
848 else
849 error_with_line (lineno, "constraint name '%s' begins with '%c', "
850 "and therefore cannot be a memory constraint",
851 name, name[0]);
852 return;
857 c = XOBNEW (rtl_obstack, struct constraint_data);
858 c->name = name;
859 c->c_name = need_mangled_name ? mangle (name) : name;
860 c->lineno = lineno;
861 c->namelen = namelen;
862 c->regclass = regclass;
863 c->exp = exp;
864 c->is_register = regclass != 0;
865 c->is_const_int = is_const_int;
866 c->is_const_dbl = is_const_dbl;
867 c->is_extra = !(regclass || is_const_int || is_const_dbl);
868 c->is_memory = is_memory;
869 c->is_address = is_address;
871 c->next_this_letter = *slot;
872 *slot = c;
874 /* Insert this constraint in the list of all constraints in textual
875 order. */
876 c->next_textual = 0;
877 *last_constraint_ptr = c;
878 last_constraint_ptr = &c->next_textual;
880 constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
881 have_register_constraints |= c->is_register;
882 have_const_int_constraints |= c->is_const_int;
883 have_const_dbl_constraints |= c->is_const_dbl;
884 have_extra_constraints |= c->is_extra;
885 have_memory_constraints |= c->is_memory;
886 have_address_constraints |= c->is_address;
889 /* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or
890 DEFINE_ADDRESS_CONSTRAINT expression, C. */
891 static void
892 process_define_constraint (rtx c, int lineno)
894 add_constraint (XSTR (c, 0), 0, XEXP (c, 2),
895 GET_CODE (c) == DEFINE_MEMORY_CONSTRAINT,
896 GET_CODE (c) == DEFINE_ADDRESS_CONSTRAINT,
897 lineno);
900 /* Process a DEFINE_REGISTER_CONSTRAINT expression, C. */
901 static void
902 process_define_register_constraint (rtx c, int lineno)
904 add_constraint (XSTR (c, 0), XSTR (c, 1), 0, false, false, lineno);
907 /* Write out an enumeration with one entry per machine-specific
908 constraint. */
909 static void
910 write_enum_constraint_num (void)
912 struct constraint_data *c;
914 fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout);
915 fputs ("enum constraint_num\n"
916 "{\n"
917 " CONSTRAINT__UNKNOWN = 0", stdout);
918 FOR_ALL_CONSTRAINTS (c)
919 printf (",\n CONSTRAINT_%s", c->c_name);
920 puts (",\n CONSTRAINT__LIMIT\n};\n");
923 /* Write out a function which looks at a string and determines what
924 constraint name, if any, it begins with. */
925 static void
926 write_lookup_constraint (void)
928 unsigned int i;
929 puts ("enum constraint_num\n"
930 "lookup_constraint (const char *str)\n"
931 "{\n"
932 " switch (str[0])\n"
933 " {");
935 for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
937 struct constraint_data *c = constraints_by_letter_table[i];
938 if (!c)
939 continue;
941 printf (" case '%c':\n", i);
942 if (c->namelen == 1)
943 printf (" return CONSTRAINT_%s;\n", c->c_name);
944 else
948 printf (" if (!strncmp (str + 1, \"%s\", %lu))\n"
949 " return CONSTRAINT_%s;\n",
950 c->name + 1, (unsigned long int) c->namelen - 1,
951 c->c_name);
952 c = c->next_this_letter;
954 while (c);
955 puts (" break;");
959 puts (" default: break;\n"
960 " }\n"
961 " return CONSTRAINT__UNKNOWN;\n"
962 "}\n");
965 /* Write out a function which looks at a string and determines what
966 the constraint name length is. */
967 static void
968 write_insn_constraint_len (void)
970 unsigned int i;
972 puts ("static inline size_t\n"
973 "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n"
974 "{\n"
975 " switch (fc)\n"
976 " {");
978 for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
980 struct constraint_data *c = constraints_by_letter_table[i];
982 if (!c
983 || c->namelen == 1)
984 continue;
986 /* Constraints with multiple characters should have the same
987 length. */
989 struct constraint_data *c2 = c->next_this_letter;
990 size_t len = c->namelen;
991 while (c2)
993 if (c2->namelen != len)
994 error ("Multi-letter constraints with first letter '%c' "
995 "should have same length", i);
996 c2 = c2->next_this_letter;
1000 printf (" case '%c': return %lu;\n",
1001 i, (unsigned long int) c->namelen);
1004 puts (" default: break;\n"
1005 " }\n"
1006 " return 1;\n"
1007 "}\n");
1010 /* Write out the function which computes the register class corresponding
1011 to a register constraint. */
1012 static void
1013 write_regclass_for_constraint (void)
1015 struct constraint_data *c;
1017 puts ("enum reg_class\n"
1018 "regclass_for_constraint (enum constraint_num c)\n"
1019 "{\n"
1020 " switch (c)\n"
1021 " {");
1023 FOR_ALL_CONSTRAINTS (c)
1024 if (c->is_register)
1025 printf (" case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
1027 puts (" default: break;\n"
1028 " }\n"
1029 " return NO_REGS;\n"
1030 "}\n");
1033 /* Write out the functions which compute whether a given value matches
1034 a given non-register constraint. */
1035 static void
1036 write_tm_constrs_h (void)
1038 struct constraint_data *c;
1040 printf ("\
1041 /* Generated automatically by the program '%s'\n\
1042 from the machine description file '%s'. */\n\n", progname, in_fname);
1044 puts ("\
1045 #ifndef GCC_TM_CONSTRS_H\n\
1046 #define GCC_TM_CONSTRS_H\n");
1048 FOR_ALL_CONSTRAINTS (c)
1049 if (!c->is_register)
1051 bool needs_ival = needs_variable (c->exp, "ival");
1052 bool needs_hval = needs_variable (c->exp, "hval");
1053 bool needs_lval = needs_variable (c->exp, "lval");
1054 bool needs_rval = needs_variable (c->exp, "rval");
1055 bool needs_mode = (needs_variable (c->exp, "mode")
1056 || needs_hval || needs_lval || needs_rval);
1057 bool needs_op = (needs_variable (c->exp, "op")
1058 || needs_ival || needs_mode);
1060 printf ("static inline bool\n"
1061 "satisfies_constraint_%s (rtx %s)\n"
1062 "{\n", c->c_name,
1063 needs_op ? "op" : "ARG_UNUSED (op)");
1064 if (needs_mode)
1065 puts (" enum machine_mode mode = GET_MODE (op);");
1066 if (needs_ival)
1067 puts (" HOST_WIDE_INT ival = 0;");
1068 if (needs_hval)
1069 puts (" HOST_WIDE_INT hval = 0;");
1070 if (needs_lval)
1071 puts (" unsigned HOST_WIDE_INT lval = 0;");
1072 if (needs_rval)
1073 puts (" const REAL_VALUE_TYPE *rval = 0;");
1075 if (needs_ival)
1076 puts (" if (CONST_INT_P (op))\n"
1077 " ival = INTVAL (op);");
1078 if (needs_hval)
1079 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1080 " hval = CONST_DOUBLE_HIGH (op);");
1081 if (needs_lval)
1082 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1083 " lval = CONST_DOUBLE_LOW (op);");
1084 if (needs_rval)
1085 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
1086 " rval = CONST_DOUBLE_REAL_VALUE (op);");
1088 write_predicate_stmts (c->exp);
1089 fputs ("}\n", stdout);
1091 puts ("#endif /* tm-constrs.h */");
1094 /* Write out the wrapper function, constraint_satisfied_p, that maps
1095 a CONSTRAINT_xxx constant to one of the predicate functions generated
1096 above. */
1097 static void
1098 write_constraint_satisfied_p (void)
1100 struct constraint_data *c;
1102 puts ("bool\n"
1103 "constraint_satisfied_p (rtx op, enum constraint_num c)\n"
1104 "{\n"
1105 " switch (c)\n"
1106 " {");
1108 FOR_ALL_CONSTRAINTS (c)
1109 if (!c->is_register)
1110 printf (" case CONSTRAINT_%s: "
1111 "return satisfies_constraint_%s (op);\n",
1112 c->c_name, c->c_name);
1114 puts (" default: break;\n"
1115 " }\n"
1116 " return false;\n"
1117 "}\n");
1120 /* Write out the function which computes whether a given value matches
1121 a given CONST_INT constraint. This doesn't just forward to
1122 constraint_satisfied_p because caller passes the INTVAL, not the RTX. */
1123 static void
1124 write_insn_const_int_ok_for_constraint (void)
1126 struct constraint_data *c;
1128 puts ("bool\n"
1129 "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1130 "enum constraint_num c)\n"
1131 "{\n"
1132 " switch (c)\n"
1133 " {");
1135 FOR_ALL_CONSTRAINTS (c)
1136 if (c->is_const_int)
1138 printf (" case CONSTRAINT_%s:\n return ", c->c_name);
1139 /* c->exp is guaranteed to be (and (match_code "const_int") (...));
1140 we know at this point that we have a const_int, so we need not
1141 bother with that part of the test. */
1142 write_predicate_expr (XEXP (c->exp, 1));
1143 fputs (";\n\n", stdout);
1146 puts (" default: break;\n"
1147 " }\n"
1148 " return false;\n"
1149 "}\n");
1153 /* Write out the function which computes whether a given constraint is
1154 a memory constraint. */
1155 static void
1156 write_insn_extra_memory_constraint (void)
1158 struct constraint_data *c;
1160 puts ("bool\n"
1161 "insn_extra_memory_constraint (enum constraint_num c)\n"
1162 "{\n"
1163 " switch (c)\n"
1164 " {");
1166 FOR_ALL_CONSTRAINTS (c)
1167 if (c->is_memory)
1168 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name);
1170 puts (" default: break;\n"
1171 " }\n"
1172 " return false;\n"
1173 "}\n");
1176 /* Write out the function which computes whether a given constraint is
1177 an address constraint. */
1178 static void
1179 write_insn_extra_address_constraint (void)
1181 struct constraint_data *c;
1183 puts ("bool\n"
1184 "insn_extra_address_constraint (enum constraint_num c)\n"
1185 "{\n"
1186 " switch (c)\n"
1187 " {");
1189 FOR_ALL_CONSTRAINTS (c)
1190 if (c->is_address)
1191 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name);
1193 puts (" default: break;\n"
1194 " }\n"
1195 " return false;\n"
1196 "}\n");
1200 /* Write tm-preds.h. Unfortunately, it is impossible to forward-declare
1201 an enumeration in portable C, so we have to condition all these
1202 prototypes on HAVE_MACHINE_MODES. */
1203 static void
1204 write_tm_preds_h (void)
1206 struct pred_data *p;
1208 printf ("\
1209 /* Generated automatically by the program '%s'\n\
1210 from the machine description file '%s'. */\n\n", progname, in_fname);
1212 puts ("\
1213 #ifndef GCC_TM_PREDS_H\n\
1214 #define GCC_TM_PREDS_H\n\
1216 #ifdef HAVE_MACHINE_MODES");
1218 FOR_ALL_PREDICATES (p)
1219 printf ("extern int %s (rtx, enum machine_mode);\n", p->name);
1221 puts ("#endif /* HAVE_MACHINE_MODES */\n");
1223 if (constraint_max_namelen > 0)
1225 write_enum_constraint_num ();
1226 puts ("extern enum constraint_num lookup_constraint (const char *);\n"
1227 "extern bool constraint_satisfied_p (rtx, enum constraint_num);\n");
1229 if (constraint_max_namelen > 1)
1231 write_insn_constraint_len ();
1232 puts ("#define CONSTRAINT_LEN(c_,s_) "
1233 "insn_constraint_len (c_,s_)\n");
1235 else
1236 puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1237 if (have_register_constraints)
1238 puts ("extern enum reg_class regclass_for_constraint "
1239 "(enum constraint_num);\n"
1240 "#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n"
1241 " regclass_for_constraint (lookup_constraint (s_))\n"
1242 "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
1243 " regclass_for_constraint (x_)\n");
1244 else
1245 puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS\n"
1246 "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
1247 " NO_REGS\n");
1248 if (have_const_int_constraints)
1249 puts ("extern bool insn_const_int_ok_for_constraint "
1250 "(HOST_WIDE_INT, enum constraint_num);\n"
1251 "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1252 " insn_const_int_ok_for_constraint (v_, "
1253 "lookup_constraint (s_))\n");
1254 if (have_const_dbl_constraints)
1255 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1256 " constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1257 else
1258 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) 0\n");
1259 if (have_extra_constraints)
1260 puts ("#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \\\n"
1261 " constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1262 if (have_memory_constraints)
1263 puts ("extern bool "
1264 "insn_extra_memory_constraint (enum constraint_num);\n"
1265 "#define EXTRA_MEMORY_CONSTRAINT(c_,s_) "
1266 "insn_extra_memory_constraint (lookup_constraint (s_))\n");
1267 else
1268 puts ("#define EXTRA_MEMORY_CONSTRAINT(c_,s_) false\n");
1269 if (have_address_constraints)
1270 puts ("extern bool "
1271 "insn_extra_address_constraint (enum constraint_num);\n"
1272 "#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) "
1273 "insn_extra_address_constraint (lookup_constraint (s_))\n");
1274 else
1275 puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n");
1278 puts ("#endif /* tm-preds.h */");
1281 /* Write insn-preds.c.
1282 N.B. the list of headers to include was copied from genrecog; it
1283 may not be ideal.
1285 FUTURE: Write #line markers referring back to the machine
1286 description. (Can't practically do this now since we don't know
1287 the line number of the C block - just the line number of the enclosing
1288 expression.) */
1289 static void
1290 write_insn_preds_c (void)
1292 struct pred_data *p;
1294 printf ("\
1295 /* Generated automatically by the program '%s'\n\
1296 from the machine description file '%s'. */\n\n", progname, in_fname);
1298 puts ("\
1299 #include \"config.h\"\n\
1300 #include \"system.h\"\n\
1301 #include \"coretypes.h\"\n\
1302 #include \"tm.h\"\n\
1303 #include \"rtl.h\"\n\
1304 #include \"tree.h\"\n\
1305 #include \"varasm.h\"\n\
1306 #include \"stor-layout.h\"\n\
1307 #include \"calls.h\"\n\
1308 #include \"tm_p.h\"\n\
1309 #include \"function.h\"\n\
1310 #include \"insn-config.h\"\n\
1311 #include \"recog.h\"\n\
1312 #include \"output.h\"\n\
1313 #include \"flags.h\"\n\
1314 #include \"hard-reg-set.h\"\n\
1315 #include \"resource.h\"\n\
1316 #include \"diagnostic-core.h\"\n\
1317 #include \"reload.h\"\n\
1318 #include \"regs.h\"\n\
1319 #include \"tm-constrs.h\"\n");
1321 FOR_ALL_PREDICATES (p)
1322 write_one_predicate_function (p);
1324 if (constraint_max_namelen > 0)
1326 write_lookup_constraint ();
1327 if (have_register_constraints)
1328 write_regclass_for_constraint ();
1329 write_constraint_satisfied_p ();
1331 if (have_const_int_constraints)
1332 write_insn_const_int_ok_for_constraint ();
1334 if (have_memory_constraints)
1335 write_insn_extra_memory_constraint ();
1336 if (have_address_constraints)
1337 write_insn_extra_address_constraint ();
1341 /* Argument parsing. */
1342 static bool gen_header;
1343 static bool gen_constrs;
1345 static bool
1346 parse_option (const char *opt)
1348 if (!strcmp (opt, "-h"))
1350 gen_header = true;
1351 return 1;
1353 else if (!strcmp (opt, "-c"))
1355 gen_constrs = true;
1356 return 1;
1358 else
1359 return 0;
1362 /* Master control. */
1364 main (int argc, char **argv)
1366 rtx defn;
1367 int pattern_lineno, next_insn_code = 0;
1369 progname = argv[0];
1370 if (argc <= 1)
1371 fatal ("no input file name");
1372 if (!init_rtx_reader_args_cb (argc, argv, parse_option))
1373 return FATAL_EXIT_CODE;
1375 while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0)
1376 switch (GET_CODE (defn))
1378 case DEFINE_PREDICATE:
1379 case DEFINE_SPECIAL_PREDICATE:
1380 process_define_predicate (defn, pattern_lineno);
1381 break;
1383 case DEFINE_CONSTRAINT:
1384 case DEFINE_MEMORY_CONSTRAINT:
1385 case DEFINE_ADDRESS_CONSTRAINT:
1386 process_define_constraint (defn, pattern_lineno);
1387 break;
1389 case DEFINE_REGISTER_CONSTRAINT:
1390 process_define_register_constraint (defn, pattern_lineno);
1391 break;
1393 default:
1394 break;
1397 if (gen_header)
1398 write_tm_preds_h ();
1399 else if (gen_constrs)
1400 write_tm_constrs_h ();
1401 else
1402 write_insn_preds_c ();
1404 if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
1405 return FATAL_EXIT_CODE;
1407 return SUCCESS_EXIT_CODE;