1 /* Generate from machine description:
2 - prototype declarations for operand predicates (tm-preds.h)
3 - function definitions of operand predicates, if defined new-style
5 Copyright (C) 2001-2022 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)
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/>. */
25 #include "coretypes.h"
31 #include "gensupport.h"
33 static char general_mem[] = { TARGET_MEM_CONSTRAINT, 0 };
35 /* Given a predicate expression EXP, from form NAME at location LOC,
36 verify that it does not contain any RTL constructs which are not
37 valid in predicate definitions. Returns true if EXP is
38 INvalid; issues error messages, caller need not. */
40 validate_exp (rtx exp, const char *name, file_location loc)
44 message_at (loc, "%s: must give a predicate expression", name);
48 switch (GET_CODE (exp))
50 /* Ternary, binary, unary expressions: recurse into subexpressions. */
52 if (validate_exp (XEXP (exp, 2), name, loc))
57 if (validate_exp (XEXP (exp, 1), name, loc))
61 return validate_exp (XEXP (exp, 0), name, loc);
63 /* MATCH_CODE might have a syntax error in its path expression. */
67 for (p = XSTR (exp, 1); *p; p++)
69 if (!ISDIGIT (*p) && !ISLOWER (*p))
71 error_at (loc, "%s: invalid character in path "
72 "string '%s'", name, XSTR (exp, 1));
79 /* These need no special checking. */
85 error_at (loc, "%s: cannot use '%s' in a predicate expression",
86 name, GET_RTX_NAME (GET_CODE (exp)));
91 /* Predicates are defined with (define_predicate) or
92 (define_special_predicate) expressions in the machine description. */
94 process_define_predicate (md_rtx_info *info)
96 validate_exp (XEXP (info->def, 1), XSTR (info->def, 0), info->loc);
99 /* Given a predicate, if it has an embedded C block, write the block
100 out as a static inline subroutine, and augment the RTL test with a
101 match_test that calls that subroutine. For instance,
103 (define_predicate "basereg_operand"
104 (match_operand 0 "register_operand")
106 if (GET_CODE (op) == SUBREG)
107 op = SUBREG_REG (op);
108 return REG_POINTER (op);
113 static inline bool basereg_operand_1(rtx op, machine_mode mode)
115 if (GET_CODE (op) == SUBREG)
116 op = SUBREG_REG (op);
117 return REG_POINTER (op);
120 (define_predicate "basereg_operand"
121 (and (match_operand 0 "register_operand")
122 (match_test "basereg_operand_1 (op, mode)")))
124 The only wart is that there's no way to insist on a { } string in
125 an RTL template, so we have to handle "" strings. */
129 write_predicate_subfunction (struct pred_data *p)
131 const char *match_test_str;
132 rtx match_test_exp, and_exp;
134 if (p->c_block[0] == '\0')
137 /* Construct the function-call expression. */
138 obstack_grow (rtl_obstack, p->name, strlen (p->name));
139 obstack_grow (rtl_obstack, "_1 (op, mode)",
140 sizeof "_1 (op, mode)");
141 match_test_str = XOBFINISH (rtl_obstack, const char *);
143 /* Add the function-call expression to the complete expression to be
145 match_test_exp = rtx_alloc (MATCH_TEST);
146 XSTR (match_test_exp, 0) = match_test_str;
148 and_exp = rtx_alloc (AND);
149 XEXP (and_exp, 0) = p->exp;
150 XEXP (and_exp, 1) = match_test_exp;
154 printf ("static inline bool\n"
155 "%s_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)\n",
157 rtx_reader_ptr->print_md_ptr_loc (p->c_block);
158 if (p->c_block[0] == '{')
159 fputs (p->c_block, stdout);
161 printf ("{\n %s\n}", p->c_block);
162 fputs ("\n\n", stdout);
165 /* Given a predicate expression EXP, from form NAME, determine whether
166 it refers to the variable given as VAR. */
168 needs_variable (rtx exp, const char *var)
170 switch (GET_CODE (exp))
172 /* Ternary, binary, unary expressions need a variable if
173 any of their subexpressions do. */
175 if (needs_variable (XEXP (exp, 2), var))
180 if (needs_variable (XEXP (exp, 1), var))
184 return needs_variable (XEXP (exp, 0), var);
186 /* MATCH_CODE uses "op", but nothing else. */
188 return !strcmp (var, "op");
190 /* MATCH_OPERAND uses "op" and may use "mode". */
192 if (!strcmp (var, "op"))
194 if (!strcmp (var, "mode") && GET_MODE (exp) == VOIDmode)
198 /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
201 const char *p = XSTR (exp, 0);
202 const char *q = strstr (p, var);
205 if (q != p && (ISALNUM (q[-1]) || q[-1] == '_'))
208 if (ISALNUM (q[0]) || q[0] == '_')
218 /* Given an RTL expression EXP, find all subexpressions which we may
219 assume to perform mode tests. Normal MATCH_OPERAND does;
220 MATCH_CODE doesn't as such (although certain codes always have
221 VOIDmode); and we have to assume that MATCH_TEST does not.
222 These combine in almost-boolean fashion - the only exception is
223 that (not X) must be assumed not to perform a mode test, whether
226 The mark is the RTL /v flag, which is true for subexpressions which
227 do *not* perform mode tests.
229 #define NO_MODE_TEST(EXP) RTX_FLAG (EXP, volatil)
231 mark_mode_tests (rtx exp)
233 switch (GET_CODE (exp))
237 struct pred_data *p = lookup_predicate (XSTR (exp, 1));
239 error ("reference to undefined predicate '%s'", XSTR (exp, 1));
240 else if (p->special || GET_MODE (exp) != VOIDmode)
241 NO_MODE_TEST (exp) = 1;
246 NO_MODE_TEST (exp) = 1;
251 NO_MODE_TEST (exp) = 1;
255 mark_mode_tests (XEXP (exp, 0));
256 mark_mode_tests (XEXP (exp, 1));
258 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
259 && NO_MODE_TEST (XEXP (exp, 1)));
263 mark_mode_tests (XEXP (exp, 0));
264 mark_mode_tests (XEXP (exp, 1));
266 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
267 || NO_MODE_TEST (XEXP (exp, 1)));
271 /* A ? B : C does a mode test if (one of A and B) does a mode
272 test, and C does too. */
273 mark_mode_tests (XEXP (exp, 0));
274 mark_mode_tests (XEXP (exp, 1));
275 mark_mode_tests (XEXP (exp, 2));
277 NO_MODE_TEST (exp) = ((NO_MODE_TEST (XEXP (exp, 0))
278 && NO_MODE_TEST (XEXP (exp, 1)))
279 || NO_MODE_TEST (XEXP (exp, 2)));
287 /* Determine whether the expression EXP is a MATCH_CODE that should
288 be written as a switch statement. */
290 generate_switch_p (rtx exp)
292 return GET_CODE (exp) == MATCH_CODE
293 && strchr (XSTR (exp, 0), ',');
296 /* Given a predicate, work out where in its RTL expression to add
297 tests for proper modes. Special predicates do not get any such
298 tests. We try to avoid adding tests when we don't have to; in
299 particular, other normal predicates can be counted on to do it for
303 add_mode_tests (struct pred_data *p)
305 rtx match_test_exp, and_exp;
308 /* Don't touch special predicates. */
312 /* Check whether the predicate accepts const scalar ints (which always
313 have a stored mode of VOIDmode, but logically have a real mode)
314 and whether it matches anything besides const scalar ints. */
315 bool matches_const_scalar_int_p = false;
316 bool matches_other_p = false;
317 for (int i = 0; i < NUM_RTX_CODE; ++i)
323 /* Special handling for (VOIDmode) LABEL_REFs. */
325 matches_const_scalar_int_p = true;
329 if (!TARGET_SUPPORTS_WIDE_INT)
330 matches_const_scalar_int_p = true;
331 matches_other_p = true;
335 matches_other_p = true;
339 /* There's no need for a mode check if the predicate only accepts
340 constant integers. The code checks in the predicate are enough
341 to establish that the mode is VOIDmode.
343 Note that the predicate itself should check whether a scalar
344 integer is in range of the given mode. */
345 if (!matches_other_p)
348 mark_mode_tests (p->exp);
350 /* If the whole expression already tests the mode, we're done. */
351 if (!NO_MODE_TEST (p->exp))
354 match_test_exp = rtx_alloc (MATCH_TEST);
355 if (matches_const_scalar_int_p)
356 XSTR (match_test_exp, 0) = ("mode == VOIDmode || GET_MODE (op) == mode"
357 " || GET_MODE (op) == VOIDmode");
359 XSTR (match_test_exp, 0) = "mode == VOIDmode || GET_MODE (op) == mode";
360 and_exp = rtx_alloc (AND);
361 XEXP (and_exp, 1) = match_test_exp;
363 /* It is always correct to rewrite p->exp as
365 (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode"))
367 but there are a couple forms where we can do better. If the
368 top-level pattern is an IOR, and one of the two branches does test
369 the mode, we can wrap just the branch that doesn't. Likewise, if
370 we have an IF_THEN_ELSE, and one side of it tests the mode, we can
371 wrap just the side that doesn't. And, of course, we can repeat this
372 descent as many times as it works. */
379 switch (GET_CODE (subexp))
382 /* The switch code generation in write_predicate_stmts prefers
383 rtx code tests to be at the top of the expression tree. So
384 push this AND down into the second operand of an existing
386 if (generate_switch_p (XEXP (subexp, 0)))
387 pos = &XEXP (subexp, 1);
392 int test0 = NO_MODE_TEST (XEXP (subexp, 0));
393 int test1 = NO_MODE_TEST (XEXP (subexp, 1));
395 gcc_assert (test0 || test1);
399 pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1);
405 int test0 = NO_MODE_TEST (XEXP (subexp, 0));
406 int test1 = NO_MODE_TEST (XEXP (subexp, 1));
407 int test2 = NO_MODE_TEST (XEXP (subexp, 2));
409 gcc_assert ((test0 && test1) || test2);
411 if (test0 && test1 && test2)
414 /* Must put it on the dependent clause, not the
415 controlling expression, or we change the meaning of
417 pos = &XEXP (subexp, 1);
419 pos = &XEXP (subexp, 2);
428 XEXP (and_exp, 0) = *pos;
432 /* PATH is a string describing a path from the root of an RTL
433 expression to an inner subexpression to be tested. Output
434 code which computes the subexpression from the variable
435 holding the root of the expression. */
437 write_extract_subexp (const char *path)
439 int len = strlen (path);
442 /* We first write out the operations (XEXP or XVECEXP) in reverse
443 order, then write "op", then the indices in forward order. */
444 for (i = len - 1; i >= 0; i--)
446 if (ISLOWER (path[i]))
447 fputs ("XVECEXP (", stdout);
448 else if (ISDIGIT (path[i]))
449 fputs ("XEXP (", stdout);
454 fputs ("op", stdout);
456 for (i = 0; i < len; i++)
458 if (ISLOWER (path[i]))
459 printf (", 0, %d)", path[i] - 'a');
460 else if (ISDIGIT (path[i]))
461 printf (", %d)", path[i] - '0');
467 /* CODES is a list of RTX codes. Write out an expression which
468 determines whether the operand has one of those codes. */
470 write_match_code (const char *path, const char *codes)
474 while ((code = scan_comma_elt (&codes)) != 0)
476 fputs ("GET_CODE (", stdout);
477 write_extract_subexp (path);
478 fputs (") == ", stdout);
481 putchar (TOUPPER (*code));
486 fputs (" || ", stdout);
490 /* EXP is an RTL (sub)expression for a predicate. Recursively
491 descend the expression and write out an equivalent C expression. */
493 write_predicate_expr (rtx exp)
495 switch (GET_CODE (exp))
499 write_predicate_expr (XEXP (exp, 0));
500 fputs (") && (", stdout);
501 write_predicate_expr (XEXP (exp, 1));
507 write_predicate_expr (XEXP (exp, 0));
508 fputs (") || (", stdout);
509 write_predicate_expr (XEXP (exp, 1));
514 fputs ("!(", stdout);
515 write_predicate_expr (XEXP (exp, 0));
521 write_predicate_expr (XEXP (exp, 0));
522 fputs (") ? (", stdout);
523 write_predicate_expr (XEXP (exp, 1));
524 fputs (") : (", stdout);
525 write_predicate_expr (XEXP (exp, 2));
530 if (GET_MODE (exp) == VOIDmode)
531 printf ("%s (op, mode)", XSTR (exp, 1));
533 printf ("%s (op, %smode)", XSTR (exp, 1), mode_name[GET_MODE (exp)]);
537 write_match_code (XSTR (exp, 1), XSTR (exp, 0));
541 rtx_reader_ptr->print_c_condition (XSTR (exp, 0));
549 /* Write the MATCH_CODE expression EXP as a switch statement. */
552 write_match_code_switch (rtx exp)
554 const char *codes = XSTR (exp, 0);
555 const char *path = XSTR (exp, 1);
558 fputs (" switch (GET_CODE (", stdout);
559 write_extract_subexp (path);
560 fputs ("))\n {\n", stdout);
562 while ((code = scan_comma_elt (&codes)) != 0)
564 fputs (" case ", stdout);
567 putchar (TOUPPER (*code));
570 fputs (":\n", stdout);
574 /* Given a predicate expression EXP, write out a sequence of stmts
575 to evaluate it. This is similar to write_predicate_expr but can
576 generate efficient switch statements. */
579 write_predicate_stmts (rtx exp)
581 switch (GET_CODE (exp))
584 if (generate_switch_p (exp))
586 write_match_code_switch (exp);
587 puts (" return true;\n"
597 if (generate_switch_p (XEXP (exp, 0)))
599 write_match_code_switch (XEXP (exp, 0));
609 if (generate_switch_p (XEXP (exp, 0)))
611 write_match_code_switch (XEXP (exp, 0));
612 puts (" return true;\n"
621 if (generate_switch_p (XEXP (exp, 0)))
623 write_match_code_switch (XEXP (exp, 0));
624 puts (" return false;\n"
637 fputs (" return ",stdout);
638 write_predicate_expr (exp);
639 fputs (";\n", stdout);
642 /* Given a predicate, write out a complete C function to compute it. */
644 write_one_predicate_function (struct pred_data *p)
649 write_predicate_subfunction (p);
652 /* A normal predicate can legitimately not look at machine_mode
653 if it accepts only CONST_INTs and/or CONST_WIDE_INT and/or CONST_DOUBLEs. */
654 printf ("bool\n%s (rtx op, machine_mode mode ATTRIBUTE_UNUSED)\n{\n",
656 write_predicate_stmts (p->exp);
657 fputs ("}\n\n", stdout);
660 /* Constraints fall into two categories: register constraints
661 (define_register_constraint), and others (define_constraint,
662 define_memory_constraint, define_special_memory_constraint,
663 define_relaxed_memory_constraint, define_address_constraint). We work out
664 automatically which of the various old-style macros they correspond to, and
665 produce appropriate code. They all go in the same hash table so we can
666 verify that there are no duplicate names. */
668 /* All data from one constraint definition. */
669 class constraint_data
672 class constraint_data *next_this_letter;
673 class constraint_data *next_textual;
675 const char *c_name; /* same as .name unless mangling is necessary */
676 file_location loc; /* location of definition */
678 const char *regclass; /* for register constraints */
679 rtx exp; /* for other constraints */
680 unsigned int is_register : 1;
681 unsigned int is_const_int : 1;
682 unsigned int is_const_dbl : 1;
683 unsigned int is_extra : 1;
684 unsigned int is_memory : 1;
685 unsigned int is_special_memory: 1;
686 unsigned int is_relaxed_memory: 1;
687 unsigned int is_address : 1;
688 unsigned int maybe_allows_reg : 1;
689 unsigned int maybe_allows_mem : 1;
692 /* Overview of all constraints beginning with a given letter. */
694 static class constraint_data *
695 constraints_by_letter_table[1<<CHAR_BIT];
697 /* For looking up all the constraints in the order that they appeared
698 in the machine description. */
699 static class constraint_data *first_constraint;
700 static class constraint_data **last_constraint_ptr = &first_constraint;
702 #define FOR_ALL_CONSTRAINTS(iter_) \
703 for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
705 /* Contraint letters that have a special meaning and that cannot be used
706 in define*_constraints. */
707 static const char generic_constraint_letters[] = "g";
709 /* Machine-independent code expects that constraints with these
710 (initial) letters will allow only (a subset of all) CONST_INTs. */
712 static const char const_int_constraints[] = "IJKLMNOP";
714 /* Machine-independent code expects that constraints with these
715 (initial) letters will allow only (a subset of all) CONST_DOUBLEs. */
717 static const char const_dbl_constraints[] = "GH";
719 /* Summary data used to decide whether to output various functions and
720 macro definitions. */
721 static unsigned int constraint_max_namelen;
722 static bool have_register_constraints;
723 static bool have_memory_constraints;
724 static bool have_special_memory_constraints;
725 static bool have_relaxed_memory_constraints;
726 static bool have_address_constraints;
727 static bool have_extra_constraints;
728 static bool have_const_int_constraints;
729 static unsigned int num_constraints;
731 static const constraint_data **enum_order;
732 static unsigned int register_start, register_end;
733 static unsigned int satisfied_start;
734 static unsigned int const_int_start, const_int_end;
735 static unsigned int memory_start, memory_end;
736 static unsigned int special_memory_start, special_memory_end;
737 static unsigned int relaxed_memory_start, relaxed_memory_end;
738 static unsigned int address_start, address_end;
739 static unsigned int maybe_allows_none_start, maybe_allows_none_end;
740 static unsigned int maybe_allows_reg_start, maybe_allows_reg_end;
741 static unsigned int maybe_allows_mem_start, maybe_allows_mem_end;
743 /* Convert NAME, which contains angle brackets and/or underscores, to
744 a string that can be used as part of a C identifier. The string
745 comes from the rtl_obstack. */
747 mangle (const char *name)
749 for (; *name; name++)
752 case '_': obstack_grow (rtl_obstack, "__", 2); break;
753 case '<': obstack_grow (rtl_obstack, "_l", 2); break;
754 case '>': obstack_grow (rtl_obstack, "_g", 2); break;
755 default: obstack_1grow (rtl_obstack, *name); break;
758 obstack_1grow (rtl_obstack, '\0');
759 return XOBFINISH (rtl_obstack, const char *);
762 /* Add one constraint, of any sort, to the tables. NAME is its name; REGCLASS
763 is the register class, if any; EXP is the expression to test, if any;
764 IS_MEMORY, IS_SPECIAL_MEMORY, IS_RELAXED_MEMORY and IS_ADDRESS indicate
765 memory, special memory, and address constraints, respectively; LOC is the .md
768 Not all combinations of arguments are valid; most importantly, REGCLASS is
769 mutually exclusive with EXP, and
770 IS_MEMORY/IS_SPECIAL_MEMORY/IS_RELAXED_MEMORY/IS_ADDRESS are only meaningful
771 for constraints with EXP.
773 This function enforces all syntactic and semantic rules about what
774 constraints can be defined. */
777 add_constraint (const char *name, const char *regclass,
778 rtx exp, bool is_memory, bool is_special_memory,
779 bool is_relaxed_memory, bool is_address, file_location loc)
781 class constraint_data *c, **iter, **slot;
783 bool need_mangled_name = false;
788 if (strcmp (name, "TARGET_MEM_CONSTRAINT") == 0)
791 if (exp && validate_exp (exp, name, loc))
794 for (p = name; *p; p++)
797 if (*p == '<' || *p == '>' || *p == '_')
798 need_mangled_name = true;
801 error_at (loc, "constraint name '%s' must be composed of letters,"
802 " digits, underscores, and angle brackets", name);
807 if (strchr (generic_constraint_letters, name[0]))
810 error_at (loc, "constraint letter '%s' cannot be "
811 "redefined by the machine description", name);
813 error_at (loc, "constraint name '%s' cannot be defined by the machine"
814 " description, as it begins with '%c'", name, name[0]);
819 namelen = strlen (name);
820 slot = &constraints_by_letter_table[(unsigned int)name[0]];
821 for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
823 /* This causes slot to end up pointing to the
824 next_this_letter field of the last constraint with a name
825 of equal or greater length than the new constraint; hence
826 the new constraint will be inserted after all previous
827 constraints with names of the same length. */
828 if ((*iter)->namelen >= namelen)
831 if (!strcmp ((*iter)->name, name))
833 error_at (loc, "redefinition of constraint '%s'", name);
834 message_at ((*iter)->loc, "previous definition is here");
837 else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
839 error_at (loc, "defining constraint '%s' here", name);
840 message_at ((*iter)->loc, "renders constraint '%s' "
841 "(defined here) a prefix", (*iter)->name);
844 else if (!strncmp ((*iter)->name, name, namelen))
846 error_at (loc, "constraint '%s' is a prefix", name);
847 message_at ((*iter)->loc, "of constraint '%s' (defined here)",
853 is_const_int = strchr (const_int_constraints, name[0]) != 0;
854 is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
856 if (is_const_int || is_const_dbl)
858 enum rtx_code appropriate_code
859 = is_const_int ? CONST_INT : CONST_DOUBLE;
861 /* Consider relaxing this requirement in the future. */
863 || GET_CODE (exp) != AND
864 || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
865 || strcmp (XSTR (XEXP (exp, 0), 0),
866 GET_RTX_NAME (appropriate_code)))
869 error_at (loc, "constraint letter '%c' is reserved "
870 "for %s constraints", name[0],
871 GET_RTX_NAME (appropriate_code));
873 error_at (loc, "constraint names beginning with '%c' "
874 "(%s) are reserved for %s constraints",
875 name[0], name, GET_RTX_NAME (appropriate_code));
879 if (is_memory || is_special_memory || is_relaxed_memory)
882 error_at (loc, "constraint letter '%c' cannot be a "
883 "memory constraint", name[0]);
885 error_at (loc, "constraint name '%s' begins with '%c', "
886 "and therefore cannot be a memory constraint",
893 error_at (loc, "constraint letter '%c' cannot be an "
894 "address constraint", name[0]);
896 error_at (loc, "constraint name '%s' begins with '%c', "
897 "and therefore cannot be an address constraint",
904 c = XOBNEW (rtl_obstack, class constraint_data);
906 c->c_name = need_mangled_name ? mangle (name) : name;
908 c->namelen = namelen;
909 c->regclass = regclass;
911 c->is_register = regclass != 0;
912 c->is_const_int = is_const_int;
913 c->is_const_dbl = is_const_dbl;
914 c->is_extra = !(regclass || is_const_int || is_const_dbl);
915 c->is_memory = is_memory;
916 c->is_special_memory = is_special_memory;
917 c->is_relaxed_memory = is_relaxed_memory;
918 c->is_address = is_address;
919 c->maybe_allows_reg = true;
920 c->maybe_allows_mem = true;
923 char codes[NUM_RTX_CODE];
924 compute_test_codes (exp, loc, codes);
925 if (!codes[REG] && !codes[SUBREG])
926 c->maybe_allows_reg = false;
928 c->maybe_allows_mem = false;
930 c->next_this_letter = *slot;
933 /* Insert this constraint in the list of all constraints in textual
936 *last_constraint_ptr = c;
937 last_constraint_ptr = &c->next_textual;
939 constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
940 have_register_constraints |= c->is_register;
941 have_const_int_constraints |= c->is_const_int;
942 have_extra_constraints |= c->is_extra;
943 have_memory_constraints |= c->is_memory;
944 have_special_memory_constraints |= c->is_special_memory;
945 have_relaxed_memory_constraints |= c->is_relaxed_memory;
946 have_address_constraints |= c->is_address;
947 num_constraints += 1;
950 /* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT,
951 DEFINE_SPECIAL_MEMORY_CONSTRAINT, DEFINE_RELAXED_MEMORY_CONSTRAINT, or
952 DEFINE_ADDRESS_CONSTRAINT expression, C. */
954 process_define_constraint (md_rtx_info *info)
956 add_constraint (XSTR (info->def, 0), 0, XEXP (info->def, 2),
957 GET_CODE (info->def) == DEFINE_MEMORY_CONSTRAINT,
958 GET_CODE (info->def) == DEFINE_SPECIAL_MEMORY_CONSTRAINT,
959 GET_CODE (info->def) == DEFINE_RELAXED_MEMORY_CONSTRAINT,
960 GET_CODE (info->def) == DEFINE_ADDRESS_CONSTRAINT,
964 /* Process a DEFINE_REGISTER_CONSTRAINT expression, C. */
966 process_define_register_constraint (md_rtx_info *info)
968 add_constraint (XSTR (info->def, 0), XSTR (info->def, 1),
969 0, false, false, false, false, info->loc);
972 /* Put the constraints into enum order. We want to keep constraints
973 of the same type together so that query functions can be simple
976 choose_enum_order (void)
978 class constraint_data *c;
980 enum_order = XNEWVEC (const constraint_data *, num_constraints);
981 unsigned int next = 0;
983 register_start = next;
984 FOR_ALL_CONSTRAINTS (c)
986 enum_order[next++] = c;
989 satisfied_start = next;
991 const_int_start = next;
992 FOR_ALL_CONSTRAINTS (c)
994 enum_order[next++] = c;
995 const_int_end = next;
998 FOR_ALL_CONSTRAINTS (c)
1000 enum_order[next++] = c;
1003 special_memory_start = next;
1004 FOR_ALL_CONSTRAINTS (c)
1005 if (c->is_special_memory)
1006 enum_order[next++] = c;
1007 special_memory_end = next;
1009 relaxed_memory_start = next;
1010 FOR_ALL_CONSTRAINTS (c)
1011 if (c->is_relaxed_memory)
1012 enum_order[next++] = c;
1013 relaxed_memory_end = next;
1015 address_start = next;
1016 FOR_ALL_CONSTRAINTS (c)
1018 enum_order[next++] = c;
1021 maybe_allows_none_start = next;
1022 FOR_ALL_CONSTRAINTS (c)
1023 if (!c->is_register && !c->is_const_int && !c->is_memory
1024 && !c->is_special_memory && !c->is_relaxed_memory && !c->is_address
1025 && !c->maybe_allows_reg && !c->maybe_allows_mem)
1026 enum_order[next++] = c;
1027 maybe_allows_none_end = next;
1029 maybe_allows_reg_start = next;
1030 FOR_ALL_CONSTRAINTS (c)
1031 if (!c->is_register && !c->is_const_int && !c->is_memory
1032 && !c->is_special_memory && !c->is_relaxed_memory && !c->is_address
1033 && c->maybe_allows_reg && !c->maybe_allows_mem)
1034 enum_order[next++] = c;
1035 maybe_allows_reg_end = next;
1037 maybe_allows_mem_start = next;
1038 FOR_ALL_CONSTRAINTS (c)
1039 if (!c->is_register && !c->is_const_int && !c->is_memory
1040 && !c->is_special_memory && !c->is_relaxed_memory && !c->is_address
1041 && !c->maybe_allows_reg && c->maybe_allows_mem)
1042 enum_order[next++] = c;
1043 maybe_allows_mem_end = next;
1045 FOR_ALL_CONSTRAINTS (c)
1046 if (!c->is_register && !c->is_const_int && !c->is_memory
1047 && !c->is_special_memory && !c->is_relaxed_memory && !c->is_address
1048 && c->maybe_allows_reg && c->maybe_allows_mem)
1049 enum_order[next++] = c;
1050 gcc_assert (next == num_constraints);
1053 /* Write out an enumeration with one entry per machine-specific
1056 write_enum_constraint_num (void)
1058 fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout);
1059 fputs ("enum constraint_num\n"
1061 " CONSTRAINT__UNKNOWN = 0", stdout);
1062 for (unsigned int i = 0; i < num_constraints; ++i)
1063 printf (",\n CONSTRAINT_%s", enum_order[i]->c_name);
1064 puts (",\n CONSTRAINT__LIMIT\n};\n");
1067 /* Write out a function which looks at a string and determines what
1068 constraint name, if any, it begins with. */
1070 write_lookup_constraint_1 (void)
1073 puts ("enum constraint_num\n"
1074 "lookup_constraint_1 (const char *str)\n"
1076 " switch (str[0])\n"
1079 for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
1081 class constraint_data *c = constraints_by_letter_table[i];
1085 printf (" case '%c':\n", i);
1086 if (c->namelen == 1)
1087 printf (" return CONSTRAINT_%s;\n", c->c_name);
1093 printf (" if (!strncmp (str + 1, \"%s\", %lu))\n"
1094 " return CONSTRAINT_%s;\n",
1095 c->name + 1, (unsigned long int) c->namelen - 1,
1098 printf (" if (str[1] == '%c')\n"
1099 " return CONSTRAINT_%s;\n",
1100 c->name[1], c->c_name);
1101 c = c->next_this_letter;
1108 puts (" default: break;\n"
1110 " return CONSTRAINT__UNKNOWN;\n"
1114 /* Write out an array that maps single-letter characters to their
1115 constraints (if that fits in a character) or 255 if lookup_constraint_1
1118 write_lookup_constraint_array (void)
1121 printf ("const unsigned char lookup_constraint_array[] = {\n ");
1122 for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
1126 class constraint_data *c = constraints_by_letter_table[i];
1128 printf ("CONSTRAINT__UNKNOWN");
1129 else if (c->namelen == 1)
1130 printf ("MIN ((int) CONSTRAINT_%s, (int) UCHAR_MAX)", c->c_name);
1132 printf ("UCHAR_MAX");
1134 printf ("\n};\n\n");
1137 /* Write out a function which looks at a string and determines what
1138 the constraint name length is. */
1140 write_insn_constraint_len (void)
1144 puts ("static inline size_t\n"
1145 "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n"
1150 for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
1152 class constraint_data *c = constraints_by_letter_table[i];
1158 /* Constraints with multiple characters should have the same
1161 class constraint_data *c2 = c->next_this_letter;
1162 size_t len = c->namelen;
1165 if (c2->namelen != len)
1166 error ("Multi-letter constraints with first letter '%c' "
1167 "should have same length", i);
1168 c2 = c2->next_this_letter;
1172 printf (" case '%c': return %lu;\n",
1173 i, (unsigned long int) c->namelen);
1176 puts (" default: break;\n"
1182 /* Write out the function which computes the register class corresponding
1183 to a register constraint. */
1185 write_reg_class_for_constraint_1 (void)
1187 class constraint_data *c;
1189 puts ("enum reg_class\n"
1190 "reg_class_for_constraint_1 (enum constraint_num c)\n"
1195 FOR_ALL_CONSTRAINTS (c)
1197 printf (" case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
1199 puts (" default: break;\n"
1201 " return NO_REGS;\n"
1205 /* Write out the functions which compute whether a given value matches
1206 a given non-register constraint. */
1208 write_tm_constrs_h (void)
1210 class constraint_data *c;
1213 /* Generated automatically by the program '%s'\n\
1214 from the machine description file '%s'. */\n\n", progname,
1215 md_reader_ptr->get_top_level_filename ());
1218 #ifndef GCC_TM_CONSTRS_H\n\
1219 #define GCC_TM_CONSTRS_H\n");
1221 FOR_ALL_CONSTRAINTS (c)
1222 if (!c->is_register)
1224 bool needs_ival = needs_variable (c->exp, "ival");
1225 bool needs_hval = needs_variable (c->exp, "hval");
1226 bool needs_lval = needs_variable (c->exp, "lval");
1227 bool needs_rval = needs_variable (c->exp, "rval");
1228 bool needs_mode = (needs_variable (c->exp, "mode")
1229 || needs_hval || needs_lval || needs_rval);
1230 bool needs_op = (needs_variable (c->exp, "op")
1231 || needs_ival || needs_mode);
1233 printf ("static inline bool\n"
1234 "satisfies_constraint_%s (rtx %s)\n"
1236 needs_op ? "op" : "ARG_UNUSED (op)");
1238 puts (" machine_mode mode = GET_MODE (op);");
1240 puts (" HOST_WIDE_INT ival = 0;");
1242 puts (" HOST_WIDE_INT hval = 0;");
1244 puts (" unsigned HOST_WIDE_INT lval = 0;");
1246 puts (" const REAL_VALUE_TYPE *rval = 0;");
1249 puts (" if (CONST_INT_P (op))\n"
1250 " ival = INTVAL (op);");
1251 #if TARGET_SUPPORTS_WIDE_INT
1252 if (needs_lval || needs_hval)
1253 error ("you can't use lval or hval");
1256 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1257 " hval = CONST_DOUBLE_HIGH (op);");
1259 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1260 " lval = CONST_DOUBLE_LOW (op);");
1263 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
1264 " rval = CONST_DOUBLE_REAL_VALUE (op);");
1266 write_predicate_stmts (c->exp);
1267 fputs ("}\n", stdout);
1269 puts ("#endif /* tm-constrs.h */");
1272 /* Write out the wrapper function, constraint_satisfied_p, that maps
1273 a CONSTRAINT_xxx constant to one of the predicate functions generated
1276 write_constraint_satisfied_p_array (void)
1278 if (satisfied_start == num_constraints)
1281 printf ("bool (*constraint_satisfied_p_array[]) (rtx) = {\n ");
1282 for (unsigned int i = satisfied_start; i < num_constraints; ++i)
1284 if (i != satisfied_start)
1286 printf ("satisfies_constraint_%s", enum_order[i]->c_name);
1288 printf ("\n};\n\n");
1291 /* Write out the function which computes whether a given value matches
1292 a given CONST_INT constraint. This doesn't just forward to
1293 constraint_satisfied_p because caller passes the INTVAL, not the RTX. */
1295 write_insn_const_int_ok_for_constraint (void)
1297 class constraint_data *c;
1300 "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1301 "enum constraint_num c)\n"
1306 FOR_ALL_CONSTRAINTS (c)
1307 if (c->is_const_int)
1309 printf (" case CONSTRAINT_%s:\n return ", c->c_name);
1310 /* c->exp is guaranteed to be (and (match_code "const_int") (...));
1311 we know at this point that we have a const_int, so we need not
1312 bother with that part of the test. */
1313 write_predicate_expr (XEXP (c->exp, 1));
1314 fputs (";\n\n", stdout);
1317 puts (" default: break;\n"
1323 /* Write a definition for a function NAME that returns true if a given
1324 constraint_num is in the range [START, END). */
1326 write_range_function (const char *name, unsigned int start, unsigned int end)
1328 printf ("static inline bool\n");
1330 printf ("%s (enum constraint_num c)\n"
1332 " return c >= CONSTRAINT_%s && c <= CONSTRAINT_%s;\n"
1334 name, enum_order[start]->c_name, enum_order[end - 1]->c_name);
1336 printf ("%s (enum constraint_num)\n"
1342 /* Write a definition for insn_extra_constraint_allows_reg_mem function. */
1344 write_allows_reg_mem_function (void)
1346 printf ("static inline void\n"
1347 "insn_extra_constraint_allows_reg_mem (enum constraint_num c,\n"
1348 "\t\t\t\t bool *allows_reg, bool *allows_mem)\n"
1350 if (maybe_allows_none_start != maybe_allows_none_end)
1351 printf (" if (c >= CONSTRAINT_%s && c <= CONSTRAINT_%s)\n"
1353 enum_order[maybe_allows_none_start]->c_name,
1354 enum_order[maybe_allows_none_end - 1]->c_name);
1355 if (maybe_allows_reg_start != maybe_allows_reg_end)
1356 printf (" if (c >= CONSTRAINT_%s && c <= CONSTRAINT_%s)\n"
1358 " *allows_reg = true;\n"
1361 enum_order[maybe_allows_reg_start]->c_name,
1362 enum_order[maybe_allows_reg_end - 1]->c_name);
1363 if (maybe_allows_mem_start != maybe_allows_mem_end)
1364 printf (" if (c >= CONSTRAINT_%s && c <= CONSTRAINT_%s)\n"
1366 " *allows_mem = true;\n"
1369 enum_order[maybe_allows_mem_start]->c_name,
1370 enum_order[maybe_allows_mem_end - 1]->c_name);
1371 printf (" (void) c;\n"
1372 " *allows_reg = true;\n"
1373 " *allows_mem = true;\n"
1377 /* VEC is a list of key/value pairs, with the keys being lower bounds
1378 of a range. Output a decision tree that handles the keys covered by
1379 [VEC[START], VEC[END]), returning FALLBACK for keys lower then VEC[START]'s.
1380 INDENT is the number of spaces to indent the code. */
1382 print_type_tree (const vec <std::pair <unsigned int, const char *> > &vec,
1383 unsigned int start, unsigned int end, const char *fallback,
1384 unsigned int indent)
1388 unsigned int mid = (start + end) / 2;
1389 printf ("%*sif (c >= CONSTRAINT_%s)\n",
1390 indent, "", enum_order[vec[mid].first]->c_name);
1392 print_type_tree (vec, mid + 1, end, vec[mid].second, indent + 2);
1395 printf ("%*s{\n", indent + 2, "");
1396 print_type_tree (vec, mid + 1, end, vec[mid].second, indent + 4);
1397 printf ("%*s}\n", indent + 2, "");
1401 printf ("%*sreturn %s;\n", indent, "", fallback);
1404 /* Write tm-preds.h. Unfortunately, it is impossible to forward-declare
1405 an enumeration in portable C, so we have to condition all these
1406 prototypes on HAVE_MACHINE_MODES. */
1408 write_tm_preds_h (void)
1410 struct pred_data *p;
1413 /* Generated automatically by the program '%s'\n\
1414 from the machine description file '%s'. */\n\n", progname,
1415 md_reader_ptr->get_top_level_filename ());
1418 #ifndef GCC_TM_PREDS_H\n\
1419 #define GCC_TM_PREDS_H\n\
1421 #ifdef HAVE_MACHINE_MODES");
1423 FOR_ALL_PREDICATES (p)
1424 printf ("extern bool %s (rtx, machine_mode);\n", p->name);
1426 puts ("#endif /* HAVE_MACHINE_MODES */\n");
1428 if (constraint_max_namelen > 0)
1430 write_enum_constraint_num ();
1431 puts ("extern enum constraint_num lookup_constraint_1 (const char *);\n"
1432 "extern const unsigned char lookup_constraint_array[];\n"
1434 "/* Return the constraint at the beginning of P, or"
1435 " CONSTRAINT__UNKNOWN if it\n"
1436 " isn't recognized. */\n"
1438 "static inline enum constraint_num\n"
1439 "lookup_constraint (const char *p)\n"
1441 " unsigned int index = lookup_constraint_array"
1442 "[(unsigned char) *p];\n"
1443 " return (index == UCHAR_MAX\n"
1444 " ? lookup_constraint_1 (p)\n"
1445 " : (enum constraint_num) index);\n"
1447 if (satisfied_start == num_constraints)
1448 puts ("/* Return true if X satisfies constraint C. */\n"
1450 "static inline bool\n"
1451 "constraint_satisfied_p (rtx, enum constraint_num)\n"
1456 printf ("extern bool (*constraint_satisfied_p_array[]) (rtx);\n"
1458 "/* Return true if X satisfies constraint C. */\n"
1460 "static inline bool\n"
1461 "constraint_satisfied_p (rtx x, enum constraint_num c)\n"
1463 " int i = (int) c - (int) CONSTRAINT_%s;\n"
1464 " return i >= 0 && constraint_satisfied_p_array[i] (x);\n"
1467 enum_order[satisfied_start]->name);
1469 write_range_function ("insn_extra_register_constraint",
1470 register_start, register_end);
1471 write_range_function ("insn_extra_memory_constraint",
1472 memory_start, memory_end);
1473 write_range_function ("insn_extra_special_memory_constraint",
1474 special_memory_start, special_memory_end);
1475 write_range_function ("insn_extra_relaxed_memory_constraint",
1476 relaxed_memory_start, relaxed_memory_end);
1477 write_range_function ("insn_extra_address_constraint",
1478 address_start, address_end);
1479 write_allows_reg_mem_function ();
1481 if (constraint_max_namelen > 1)
1483 write_insn_constraint_len ();
1484 puts ("#define CONSTRAINT_LEN(c_,s_) "
1485 "insn_constraint_len (c_,s_)\n");
1488 puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1489 if (have_register_constraints)
1490 puts ("extern enum reg_class reg_class_for_constraint_1 "
1491 "(enum constraint_num);\n"
1493 "static inline enum reg_class\n"
1494 "reg_class_for_constraint (enum constraint_num c)\n"
1496 " if (insn_extra_register_constraint (c))\n"
1497 " return reg_class_for_constraint_1 (c);\n"
1498 " return NO_REGS;\n"
1501 puts ("static inline enum reg_class\n"
1502 "reg_class_for_constraint (enum constraint_num)\n"
1504 " return NO_REGS;\n"
1506 if (have_const_int_constraints)
1507 puts ("extern bool insn_const_int_ok_for_constraint "
1508 "(HOST_WIDE_INT, enum constraint_num);\n"
1509 "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1510 " insn_const_int_ok_for_constraint (v_, "
1511 "lookup_constraint (s_))\n");
1513 puts ("static inline bool\n"
1514 "insn_const_int_ok_for_constraint (HOST_WIDE_INT,"
1515 " enum constraint_num)\n"
1520 puts ("enum constraint_type\n"
1525 " CT_SPECIAL_MEMORY,\n"
1526 " CT_RELAXED_MEMORY,\n"
1531 "static inline enum constraint_type\n"
1532 "get_constraint_type (enum constraint_num c)\n"
1534 auto_vec <std::pair <unsigned int, const char *>, 4> values;
1535 if (const_int_start != const_int_end)
1536 values.safe_push (std::make_pair (const_int_start, "CT_CONST_INT"));
1537 if (memory_start != memory_end)
1538 values.safe_push (std::make_pair (memory_start, "CT_MEMORY"));
1539 if (special_memory_start != special_memory_end)
1540 values.safe_push (std::make_pair (special_memory_start,
1541 "CT_SPECIAL_MEMORY"));
1542 if (relaxed_memory_start != relaxed_memory_end)
1543 values.safe_push (std::make_pair (relaxed_memory_start,
1544 "CT_RELAXED_MEMORY"));
1545 if (address_start != address_end)
1546 values.safe_push (std::make_pair (address_start, "CT_ADDRESS"));
1547 if (address_end != num_constraints)
1548 values.safe_push (std::make_pair (address_end, "CT_FIXED_FORM"));
1549 print_type_tree (values, 0, values.length (), "CT_REGISTER", 2);
1553 puts ("#endif /* tm-preds.h */");
1556 /* Write insn-preds.cc.
1557 N.B. the list of headers to include was copied from genrecog; it
1560 FUTURE: Write #line markers referring back to the machine
1561 description. (Can't practically do this now since we don't know
1562 the line number of the C block - just the line number of the enclosing
1565 write_insn_preds_c (void)
1567 struct pred_data *p;
1570 /* Generated automatically by the program '%s'\n\
1571 from the machine description file '%s'. */\n\n", progname,
1572 md_reader_ptr->get_top_level_filename ());
1575 #define IN_TARGET_CODE 1\n\
1576 #include \"config.h\"\n\
1577 #include \"system.h\"\n\
1578 #include \"coretypes.h\"\n\
1579 #include \"backend.h\"\n\
1580 #include \"predict.h\"\n\
1581 #include \"tree.h\"\n\
1582 #include \"rtl.h\"\n\
1583 #include \"alias.h\"\n\
1584 #include \"varasm.h\"\n\
1585 #include \"stor-layout.h\"\n\
1586 #include \"calls.h\"\n\
1587 #include \"memmodel.h\"\n\
1588 #include \"tm_p.h\"\n\
1589 #include \"insn-config.h\"\n\
1590 #include \"recog.h\"\n\
1591 #include \"output.h\"\n\
1592 #include \"flags.h\"\n\
1593 #include \"df.h\"\n\
1594 #include \"resource.h\"\n\
1595 #include \"diagnostic-core.h\"\n\
1596 #include \"reload.h\"\n\
1597 #include \"regs.h\"\n\
1598 #include \"emit-rtl.h\"\n\
1599 #include \"tm-constrs.h\"\n\
1600 #include \"target.h\"\n");
1602 FOR_ALL_PREDICATES (p)
1603 write_one_predicate_function (p);
1605 if (constraint_max_namelen > 0)
1607 write_lookup_constraint_1 ();
1608 write_lookup_constraint_array ();
1609 if (have_register_constraints)
1610 write_reg_class_for_constraint_1 ();
1611 write_constraint_satisfied_p_array ();
1613 if (have_const_int_constraints)
1614 write_insn_const_int_ok_for_constraint ();
1618 /* Argument parsing. */
1619 static bool gen_header;
1620 static bool gen_constrs;
1623 parse_option (const char *opt)
1625 if (!strcmp (opt, "-h"))
1630 else if (!strcmp (opt, "-c"))
1639 /* Master control. */
1641 main (int argc, const char **argv)
1645 fatal ("no input file name");
1646 if (!init_rtx_reader_args_cb (argc, argv, parse_option))
1647 return FATAL_EXIT_CODE;
1650 while (read_md_rtx (&info))
1651 switch (GET_CODE (info.def))
1653 case DEFINE_PREDICATE:
1654 case DEFINE_SPECIAL_PREDICATE:
1655 process_define_predicate (&info);
1658 case DEFINE_CONSTRAINT:
1659 case DEFINE_MEMORY_CONSTRAINT:
1660 case DEFINE_SPECIAL_MEMORY_CONSTRAINT:
1661 case DEFINE_RELAXED_MEMORY_CONSTRAINT:
1662 case DEFINE_ADDRESS_CONSTRAINT:
1663 process_define_constraint (&info);
1666 case DEFINE_REGISTER_CONSTRAINT:
1667 process_define_register_constraint (&info);
1674 choose_enum_order ();
1677 write_tm_preds_h ();
1678 else if (gen_constrs)
1679 write_tm_constrs_h ();
1681 write_insn_preds_c ();
1683 if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
1684 return FATAL_EXIT_CODE;
1686 return SUCCESS_EXIT_CODE;