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, 2002, 2003, 2004, 2005 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 2, 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 COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
26 #include "coretypes.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. */
38 validate_exp (rtx exp, const char *name, int lineno)
42 message_with_line (lineno, "%s: must give a predicate expression", name);
46 switch (GET_CODE (exp))
48 /* Ternary, binary, unary expressions: recurse into subexpressions. */
50 if (validate_exp (XEXP (exp, 2), name, lineno))
52 /* else fall through */
55 if (validate_exp (XEXP (exp, 1), name, lineno))
57 /* else fall through */
59 return validate_exp (XEXP (exp, 0), name, lineno);
61 /* MATCH_CODE might have a syntax error in its path expression. */
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));
78 /* These need no special checking. */
84 message_with_line (lineno,
85 "%s: cannot use '%s' in a predicate expression",
86 name, GET_RTX_NAME (GET_CODE (exp)));
92 /* Predicates are defined with (define_predicate) or
93 (define_special_predicate) expressions in the machine description. */
95 process_define_predicate (rtx defn, int lineno)
97 struct pred_data *pred;
100 if (!ISALPHA (XSTR (defn, 0)[0]) && XSTR (defn, 0)[0] != '_')
102 for (p = XSTR (defn, 0) + 1; *p; p++)
103 if (!ISALNUM (*p) && *p != '_')
106 if (validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno))
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);
121 message_with_line (lineno,
122 "%s: predicate name must be a valid C function name",
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);
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. */
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')
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
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;
183 printf ("static inline int\n"
184 "%s_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n",
186 print_rtx_ptr_loc (p->c_block);
187 if (p->c_block[0] == '{')
188 fputs (p->c_block, stdout);
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. */
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. */
204 if (needs_variable (XEXP (exp, 2), var))
206 /* else fall through */
209 if (needs_variable (XEXP (exp, 1), var))
211 /* else fall through */
213 return needs_variable (XEXP (exp, 0), var);
215 /* MATCH_CODE uses "op", but nothing else. */
217 return !strcmp (var, "op");
219 /* MATCH_OPERAND uses "op" and may use "mode". */
221 if (!strcmp (var, "op"))
223 if (!strcmp (var, "mode") && GET_MODE (exp) == VOIDmode)
227 /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
230 const char *p = XSTR (exp, 0);
231 const char *q = strstr (p, var);
234 if (q != p && (ISALNUM (q[-1]) || q[-1] == '_'))
237 if (ISALNUM (q[0] || q[0] == '_'))
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)
260 mark_mode_tests (rtx exp)
262 switch (GET_CODE (exp))
266 struct pred_data *p = lookup_predicate (XSTR (exp, 1));
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;
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;
283 NO_MODE_TEST (exp) = 1;
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)));
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)));
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)));
319 /* Given a predicate, work out where in its RTL expression to add
320 tests for proper modes. Special predicates do not get any such
321 tests. We try to avoid adding tests when we don't have to; in
322 particular, other normal predicates can be counted on to do it for
326 add_mode_tests (struct pred_data *p)
328 rtx match_test_exp, and_exp;
331 /* Don't touch special predicates. */
335 mark_mode_tests (p->exp);
337 /* If the whole expression already tests the mode, we're done. */
338 if (!NO_MODE_TEST (p->exp))
341 match_test_exp = rtx_alloc (MATCH_TEST);
342 XSTR (match_test_exp, 0) = "mode == VOIDmode || GET_MODE (op) == mode";
343 and_exp = rtx_alloc (AND);
344 XEXP (and_exp, 1) = match_test_exp;
346 /* It is always correct to rewrite p->exp as
348 (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode"))
350 but there are a couple forms where we can do better. If the
351 top-level pattern is an IOR, and one of the two branches does test
352 the mode, we can wrap just the branch that doesn't. Likewise, if
353 we have an IF_THEN_ELSE, and one side of it tests the mode, we can
354 wrap just the side that doesn't. And, of course, we can repeat this
355 descent as many times as it works. */
362 switch (GET_CODE (subexp))
366 int test0 = NO_MODE_TEST (XEXP (subexp, 0));
367 int test1 = NO_MODE_TEST (XEXP (subexp, 1));
369 gcc_assert (test0 || test1);
373 pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1);
379 int test0 = NO_MODE_TEST (XEXP (subexp, 0));
380 int test1 = NO_MODE_TEST (XEXP (subexp, 1));
381 int test2 = NO_MODE_TEST (XEXP (subexp, 2));
383 gcc_assert ((test0 && test1) || test2);
385 if (test0 && test1 && test2)
388 /* Must put it on the dependent clause, not the
389 controlling expression, or we change the meaning of
391 pos = &XEXP (subexp, 1);
393 pos = &XEXP (subexp, 2);
402 XEXP (and_exp, 0) = *pos;
406 /* PATH is a string describing a path from the root of an RTL
407 expression to an inner subexpression to be tested. Output
408 code which computes the subexpression from the variable
409 holding the root of the expression. */
411 write_extract_subexp (const char *path)
413 int len = strlen (path);
416 /* We first write out the operations (XEXP or XVECEXP) in reverse
417 order, then write "op", then the indices in forward order. */
418 for (i = len - 1; i >= 0; i--)
420 if (ISLOWER (path[i]))
421 fputs ("XVECEXP (", stdout);
422 else if (ISDIGIT (path[i]))
423 fputs ("XEXP (", stdout);
428 fputs ("op", stdout);
430 for (i = 0; i < len; i++)
432 if (ISLOWER (path[i]))
433 printf (", 0, %d)", path[i] - 'a');
434 else if (ISDIGIT (path[i]))
435 printf (", %d)", path[i] - '0');
441 /* CODES is a list of RTX codes. Write out an expression which
442 determines whether the operand has one of those codes. */
444 write_match_code (const char *path, const char *codes)
448 while ((code = scan_comma_elt (&codes)) != 0)
450 fputs ("GET_CODE (", stdout);
451 write_extract_subexp (path);
452 fputs (") == ", stdout);
455 putchar (TOUPPER (*code));
460 fputs (" || ", stdout);
464 /* EXP is an RTL (sub)expression for a predicate. Recursively
465 descend the expression and write out an equivalent C expression. */
467 write_predicate_expr (rtx exp)
469 switch (GET_CODE (exp))
473 write_predicate_expr (XEXP (exp, 0));
474 fputs (") && (", stdout);
475 write_predicate_expr (XEXP (exp, 1));
481 write_predicate_expr (XEXP (exp, 0));
482 fputs (") || (", stdout);
483 write_predicate_expr (XEXP (exp, 1));
488 fputs ("!(", stdout);
489 write_predicate_expr (XEXP (exp, 0));
495 write_predicate_expr (XEXP (exp, 0));
496 fputs (") ? (", stdout);
497 write_predicate_expr (XEXP (exp, 1));
498 fputs (") : (", stdout);
499 write_predicate_expr (XEXP (exp, 2));
504 if (GET_MODE (exp) == VOIDmode)
505 printf ("%s (op, mode)", XSTR (exp, 1));
507 printf ("%s (op, %smode)", XSTR (exp, 1), mode_name[GET_MODE (exp)]);
511 write_match_code (XSTR (exp, 1), XSTR (exp, 0));
515 print_c_condition (XSTR (exp, 0));
523 /* Given a predicate, write out a complete C function to compute it. */
525 write_one_predicate_function (struct pred_data *p)
530 write_predicate_subfunction (p);
533 /* A normal predicate can legitimately not look at enum machine_mode
534 if it accepts only CONST_INTs and/or CONST_DOUBLEs. */
535 printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n"
538 write_predicate_expr (p->exp);
539 fputs (";\n}\n\n", stdout);
542 /* Constraints fall into two categories: register constraints
543 (define_register_constraint), and others (define_constraint,
544 define_memory_constraint, define_address_constraint). We
545 work out automatically which of the various old-style macros
546 they correspond to, and produce appropriate code. They all
547 go in the same hash table so we can verify that there are no
550 /* All data from one constraint definition. */
551 struct constraint_data
553 struct constraint_data *next_this_letter;
554 struct constraint_data *next_textual;
556 const char *c_name; /* same as .name unless mangling is necessary */
558 const char *regclass; /* for register constraints */
559 rtx exp; /* for other constraints */
560 unsigned int lineno; /* line of definition */
561 unsigned int is_register : 1;
562 unsigned int is_const_int : 1;
563 unsigned int is_const_dbl : 1;
564 unsigned int is_extra : 1;
565 unsigned int is_memory : 1;
566 unsigned int is_address : 1;
569 /* Overview of all constraints beginning with a given letter. */
571 static struct constraint_data *
572 constraints_by_letter_table[1<<CHAR_BIT];
574 /* For looking up all the constraints in the order that they appeared
575 in the machine description. */
576 static struct constraint_data *first_constraint;
577 static struct constraint_data **last_constraint_ptr = &first_constraint;
579 #define FOR_ALL_CONSTRAINTS(iter_) \
580 for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
582 /* These letters, and all names beginning with them, are reserved for
583 generic constraints. */
584 static const char generic_constraint_letters[] = "EFVXgimnoprs";
586 /* Machine-independent code expects that constraints with these
587 (initial) letters will allow only (a subset of all) CONST_INTs. */
589 static const char const_int_constraints[] = "IJKLMNOP";
591 /* Machine-independent code expects that constraints with these
592 (initial) letters will allow only (a subset of all) CONST_DOUBLEs. */
594 static const char const_dbl_constraints[] = "GH";
596 /* Summary data used to decide whether to output various functions and
597 macro definitions. */
598 static unsigned int constraint_max_namelen;
599 static bool have_register_constraints;
600 static bool have_memory_constraints;
601 static bool have_address_constraints;
602 static bool have_extra_constraints;
603 static bool have_const_int_constraints;
604 static bool have_const_dbl_constraints;
606 /* Convert NAME, which contains angle brackets and/or underscores, to
607 a string that can be used as part of a C identifier. The string
608 comes from the rtl_obstack. */
610 mangle (const char *name)
612 for (; *name; name++)
615 case '_': obstack_grow (rtl_obstack, "__", 2); break;
616 case '<': obstack_grow (rtl_obstack, "_l", 2); break;
617 case '>': obstack_grow (rtl_obstack, "_g", 2); break;
618 default: obstack_1grow (rtl_obstack, *name); break;
621 obstack_1grow (rtl_obstack, '\0');
622 return obstack_finish (rtl_obstack);
625 /* Add one constraint, of any sort, to the tables. NAME is its name;
626 REGCLASS is the register class, if any; EXP is the expression to
627 test, if any; IS_MEMORY and IS_ADDRESS indicate memory and address
628 constraints, respectively; LINENO is the line number from the MD reader.
629 Not all combinations of arguments are valid; most importantly, REGCLASS
630 is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only
631 meaningful for constraints with EXP.
633 This function enforces all syntactic and semantic rules about what
634 constraints can be defined. */
637 add_constraint (const char *name, const char *regclass,
638 rtx exp, bool is_memory, bool is_address,
641 struct constraint_data *c, **iter, **slot;
643 bool need_mangled_name = false;
648 if (exp && validate_exp (exp, name, lineno))
651 if (!ISALPHA (name[0]) && name[0] != '_')
654 message_with_line (lineno, "constraint name '%s' is not "
655 "a letter or underscore", name);
657 message_with_line (lineno, "constraint name '%s' does not begin "
658 "with a letter or underscore", name);
662 for (p = name; *p; p++)
665 if (*p == '<' || *p == '>' || *p == '_')
666 need_mangled_name = true;
669 message_with_line (lineno,
670 "constraint name '%s' must be composed of "
671 "letters, digits, underscores, and "
672 "angle brackets", name);
678 if (strchr (generic_constraint_letters, name[0]))
681 message_with_line (lineno, "constraint letter '%s' cannot be "
682 "redefined by the machine description", name);
684 message_with_line (lineno, "constraint name '%s' cannot be defined by "
685 "the machine description, as it begins with '%c'",
692 namelen = strlen (name);
693 slot = &constraints_by_letter_table[(unsigned int)name[0]];
694 for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
696 /* This causes slot to end up pointing to the
697 next_this_letter field of the last constraint with a name
698 of equal or greater length than the new constraint; hence
699 the new constraint will be inserted after all previous
700 constraints with names of the same length. */
701 if ((*iter)->namelen >= namelen)
704 if (!strcmp ((*iter)->name, name))
706 message_with_line (lineno, "redefinition of constraint '%s'", name);
707 message_with_line ((*iter)->lineno, "previous definition is here");
711 else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
713 message_with_line (lineno, "defining constraint '%s' here", name);
714 message_with_line ((*iter)->lineno, "renders constraint '%s' "
715 "(defined here) a prefix", (*iter)->name);
719 else if (!strncmp ((*iter)->name, name, namelen))
721 message_with_line (lineno, "constraint '%s' is a prefix", name);
722 message_with_line ((*iter)->lineno, "of constraint '%s' "
723 "(defined here)", (*iter)->name);
729 is_const_int = strchr (const_int_constraints, name[0]) != 0;
730 is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
732 if (is_const_int || is_const_dbl)
734 enum rtx_code appropriate_code
735 = is_const_int ? CONST_INT : CONST_DOUBLE;
737 /* Consider relaxing this requirement in the future. */
739 || GET_CODE (exp) != AND
740 || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
741 || strcmp (XSTR (XEXP (exp, 0), 0),
742 GET_RTX_NAME (appropriate_code)))
745 message_with_line (lineno, "constraint letter '%c' is reserved "
746 "for %s constraints",
747 name[0], GET_RTX_NAME (appropriate_code));
749 message_with_line (lineno, "constraint names beginning with '%c' "
750 "(%s) are reserved for %s constraints",
752 GET_RTX_NAME (appropriate_code));
761 message_with_line (lineno, "constraint letter '%c' cannot be a "
762 "memory constraint", name[0]);
764 message_with_line (lineno, "constraint name '%s' begins with '%c', "
765 "and therefore cannot be a memory constraint",
774 message_with_line (lineno, "constraint letter '%c' cannot be a "
775 "memory constraint", name[0]);
777 message_with_line (lineno, "constraint name '%s' begins with '%c', "
778 "and therefore cannot be a memory constraint",
785 /* Remove the redundant (and (match_code "const_(int|double)")
786 from the expression. */
791 c = obstack_alloc (rtl_obstack, sizeof (struct constraint_data));
793 c->c_name = need_mangled_name ? mangle (name) : name;
795 c->namelen = namelen;
796 c->regclass = regclass;
798 c->is_register = regclass != 0;
799 c->is_const_int = is_const_int;
800 c->is_const_dbl = is_const_dbl;
801 c->is_extra = !(regclass || is_const_int || is_const_dbl);
802 c->is_memory = is_memory;
803 c->is_address = is_address;
805 c->next_this_letter = *slot;
808 /* Insert this constraint in the list of all constraints in textual
811 *last_constraint_ptr = c;
812 last_constraint_ptr = &c->next_textual;
814 constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
815 have_register_constraints |= c->is_register;
816 have_const_int_constraints |= c->is_const_int;
817 have_const_dbl_constraints |= c->is_const_dbl;
818 have_extra_constraints |= c->is_extra;
819 have_memory_constraints |= c->is_memory;
820 have_address_constraints |= c->is_address;
823 /* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or
824 DEFINE_ADDRESS_CONSTRAINT expression, C. */
826 process_define_constraint (rtx c, int lineno)
828 add_constraint (XSTR (c, 0), 0, XEXP (c, 2),
829 GET_CODE (c) == DEFINE_MEMORY_CONSTRAINT,
830 GET_CODE (c) == DEFINE_ADDRESS_CONSTRAINT,
834 /* Process a DEFINE_REGISTER_CONSTRAINT expression, C. */
836 process_define_register_constraint (rtx c, int lineno)
838 add_constraint (XSTR (c, 0), XSTR (c, 1), 0, false, false, lineno);
841 /* Write out an enumeration with one entry per machine-specific
844 write_enum_constraint_num (void)
846 struct constraint_data *c;
848 fputs ("enum constraint_num\n"
850 " CONSTRAINT__UNKNOWN = 0", stdout);
851 FOR_ALL_CONSTRAINTS (c)
852 printf (",\n CONSTRAINT_%s", c->c_name);
856 /* Write out a function which looks at a string and determines what
857 constraint name, if any, it begins with. */
859 write_lookup_constraint (void)
862 puts ("enum constraint_num\n"
863 "lookup_constraint (const char *str)\n"
868 for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
870 struct constraint_data *c = constraints_by_letter_table[i];
874 printf (" case '%c':\n", i);
876 printf (" return CONSTRAINT_%s;\n", c->c_name);
881 printf (" if (!strncmp (str, \"%s\", %lu))\n"
882 " return CONSTRAINT_%s;\n",
883 c->name, (unsigned long int) c->namelen, c->c_name);
884 c = c->next_this_letter;
891 puts (" default: break;\n"
893 " return CONSTRAINT__UNKNOWN;\n"
897 /* Write out the function which computes constraint name lengths from
898 their enumerators. */
900 write_insn_constraint_len (void)
902 struct constraint_data *c;
904 if (constraint_max_namelen == 1)
907 puts ("unsigned int\n"
908 "insn_constraint_len (enum constraint_num c)\n"
913 FOR_ALL_CONSTRAINTS (c)
915 printf (" case CONSTRAINT_%s: return %lu;\n", c->c_name,
916 (unsigned long int) c->namelen);
918 puts (" default: break;\n"
924 /* Write out the function which computes the register class corresponding
925 to a register constraint. */
927 write_regclass_for_constraint (void)
929 struct constraint_data *c;
931 puts ("enum reg_class\n"
932 "regclass_for_constraint (enum constraint_num c)\n"
937 FOR_ALL_CONSTRAINTS (c)
939 printf (" case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
941 puts (" default: break;\n"
947 /* Write out the functions which compute whether a given value matches
948 a given non-register constraint. */
950 write_satisfies_constraint_fns (void)
952 struct constraint_data *c;
954 /* A fair number of places include tm_p.h without including rtl.h. */
955 puts ("#ifdef GCC_RTL_H\n");
957 FOR_ALL_CONSTRAINTS (c)
960 bool needs_ival = needs_variable (c->exp, "ival");
961 bool needs_hval = needs_variable (c->exp, "hval");
962 bool needs_lval = needs_variable (c->exp, "lval");
963 bool needs_rval = needs_variable (c->exp, "rval");
964 bool needs_mode = (needs_variable (c->exp, "mode")
965 || needs_hval || needs_lval || needs_rval);
967 printf ("static inline bool\n"
968 "satisfies_constraint_%s (rtx op)\n"
971 puts ("enum machine_mode mode = GET_MODE (op);");
973 puts (" HOST_WIDE_INT ival = 0;");
975 puts (" HOST_WIDE_INT hval = 0;");
977 puts (" unsigned HOST_WIDE_INT lval = 0;");
979 puts (" const REAL_VALUE_TYPE *rval = 0;");
982 puts (" if (GET_CODE (op) == CONST_INT)\n"
983 " ival = INTVAL (op);");
985 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
986 " hval = CONST_DOUBLE_HIGH (op);");
988 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
989 " lval = CONST_DOUBLE_LOW (op);");
991 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
992 " rval = CONST_DOUBLE_REAL_VALUE (op);");
994 fputs (" return ", stdout);
995 write_predicate_expr (c->exp);
996 fputs (";\n}\n", stdout);
999 puts ("\n#endif /* rtl.h visible */\n");
1002 /* Write out the wrapper function, constraint_satisfied_p, that maps
1003 a CONSTRAINT_xxx constant to one of the predicate functions generated
1006 write_constraint_satisfied_p (void)
1008 struct constraint_data *c;
1011 "constraint_satisfied_p (rtx op, enum constraint_num c)\n"
1016 FOR_ALL_CONSTRAINTS (c)
1017 if (!c->is_register)
1018 printf (" case CONSTRAINT_%s: "
1019 "return satisfies_constraint_%s (op);\n",
1020 c->c_name, c->c_name);
1022 puts (" default: break;\n"
1028 /* Write out the function which computes whether a given value matches
1029 a given CONST_INT constraint. This doesn't just forward to
1030 constraint_satisfied_p because caller passes the INTVAL, not the RTX. */
1032 write_insn_const_int_ok_for_constraint (void)
1034 struct constraint_data *c;
1037 "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1038 "enum constraint_num c)\n"
1043 FOR_ALL_CONSTRAINTS (c)
1044 if (c->is_const_int)
1046 printf (" case CONSTRAINT_%s:\n return ", c->c_name);
1047 write_predicate_expr (c->exp);
1048 fputs (";\n\n", stdout);
1051 puts (" default: break;\n"
1058 /* Write out the function which computes whether a given constraint is
1059 a memory constraint. */
1061 write_insn_extra_memory_constraint (void)
1063 struct constraint_data *c;
1066 "insn_extra_memory_constraint (enum constraint_num c)\n"
1071 FOR_ALL_CONSTRAINTS (c)
1073 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name);
1075 puts (" default: break;\n"
1081 /* Write out the function which computes whether a given constraint is
1082 an address constraint. */
1084 write_insn_extra_address_constraint (void)
1086 struct constraint_data *c;
1089 "insn_extra_address_constraint (enum constraint_num c)\n"
1091 " switch (str[0])\n"
1094 FOR_ALL_CONSTRAINTS (c)
1096 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name);
1098 puts (" default: break;\n"
1105 /* Write tm-preds.h. Unfortunately, it is impossible to forward-declare
1106 an enumeration in portable C, so we have to condition all these
1107 prototypes on HAVE_MACHINE_MODES. */
1109 write_tm_preds_h (void)
1111 struct pred_data *p;
1114 /* Generated automatically by the program '%s'\n\
1115 from the machine description file '%s'. */\n\n", progname, in_fname);
1118 #ifndef GCC_TM_PREDS_H\n\
1119 #define GCC_TM_PREDS_H\n\
1121 #ifdef HAVE_MACHINE_MODES");
1123 FOR_ALL_PREDICATES (p)
1124 printf ("extern int %s (rtx, enum machine_mode);\n", p->name);
1126 puts ("#endif /* HAVE_MACHINE_MODES */\n");
1128 if (constraint_max_namelen > 0)
1130 write_enum_constraint_num ();
1131 puts ("extern enum constraint_num lookup_constraint (const char *);\n"
1132 "extern bool constraint_satisfied_p (rtx, enum constraint_num);\n");
1134 if (constraint_max_namelen > 1)
1135 puts ("extern size_t insn_constraint_len (enum constraint_num);\n"
1136 "#define CONSTRAINT_LEN(c_,s_) "
1137 "insn_constraint_len (lookup_constraint (s_))\n");
1139 puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1140 if (have_register_constraints)
1141 puts ("extern enum reg_class regclass_for_constraint "
1142 "(enum constraint_num);\n"
1143 "#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n"
1144 " regclass_for_constraint (lookup_constraint (s_))\n");
1146 puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS");
1147 if (have_const_int_constraints)
1148 puts ("extern bool insn_const_int_ok_for_constraint "
1149 "(HOST_WIDE_INT, enum constraint_num);\n"
1150 "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1151 " insn_const_int_ok_for_constraint (v_, "
1152 "lookup_constraint (s_))\n");
1153 if (have_const_dbl_constraints)
1154 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1155 " constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1157 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) 0\n");
1158 if (have_extra_constraints)
1159 puts ("#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \\\n"
1160 " constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1161 if (have_memory_constraints)
1162 puts ("extern bool "
1163 "insn_extra_memory_constraint (enum constraint_num);\n"
1164 "#define EXTRA_MEMORY_CONSTRAINT(c_,s_) "
1165 "insn_extra_memory_constraint (lookup_constraint (s_))\n");
1167 puts ("#define EXTRA_MEMORY_CONSTRAINT(c_,s_) false\n");
1168 if (have_address_constraints)
1169 puts ("extern bool "
1170 "insn_extra_address_constraint (enum constraint_num)"
1171 "#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) "
1172 "insn_extra_address_constraint (lookup_constraint (s_))\n");
1174 puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n");
1176 if (have_const_int_constraints || have_const_dbl_constraints
1177 || have_extra_constraints)
1178 write_satisfies_constraint_fns ();
1181 puts ("#endif /* tm-preds.h */");
1184 /* Write insn-preds.c.
1185 N.B. the list of headers to include was copied from genrecog; it
1188 FUTURE: Write #line markers referring back to the machine
1189 description. (Can't practically do this now since we don't know
1190 the line number of the C block - just the line number of the enclosing
1193 write_insn_preds_c (void)
1195 struct pred_data *p;
1198 /* Generated automatically by the program '%s'\n\
1199 from the machine description file '%s'. */\n\n", progname, in_fname);
1202 #include \"config.h\"\n\
1203 #include \"system.h\"\n\
1204 #include \"coretypes.h\"\n\
1205 #include \"tm.h\"\n\
1206 #include \"rtl.h\"\n\
1207 #include \"tree.h\"\n\
1208 #include \"tm_p.h\"\n\
1209 #include \"function.h\"\n\
1210 #include \"insn-config.h\"\n\
1211 #include \"recog.h\"\n\
1212 #include \"real.h\"\n\
1213 #include \"output.h\"\n\
1214 #include \"flags.h\"\n\
1215 #include \"hard-reg-set.h\"\n\
1216 #include \"resource.h\"\n\
1217 #include \"toplev.h\"\n\
1218 #include \"reload.h\"\n\
1219 #include \"regs.h\"\n");
1221 FOR_ALL_PREDICATES (p)
1222 write_one_predicate_function (p);
1224 if (constraint_max_namelen > 0)
1226 write_lookup_constraint ();
1227 write_regclass_for_constraint ();
1228 write_constraint_satisfied_p ();
1230 if (constraint_max_namelen > 1)
1231 write_insn_constraint_len ();
1233 if (have_const_int_constraints)
1234 write_insn_const_int_ok_for_constraint ();
1236 if (have_memory_constraints)
1237 write_insn_extra_memory_constraint ();
1238 if (have_address_constraints)
1239 write_insn_extra_address_constraint ();
1243 /* Argument parsing. */
1244 static bool gen_header;
1246 parse_option (const char *opt)
1248 if (!strcmp (opt, "-h"))
1257 /* Master control. */
1259 main (int argc, char **argv)
1262 int pattern_lineno, next_insn_code = 0;
1266 fatal ("no input file name");
1267 if (init_md_reader_args_cb (argc, argv, parse_option) != SUCCESS_EXIT_CODE)
1268 return FATAL_EXIT_CODE;
1270 while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0)
1271 switch (GET_CODE (defn))
1273 case DEFINE_PREDICATE:
1274 case DEFINE_SPECIAL_PREDICATE:
1275 process_define_predicate (defn, pattern_lineno);
1278 case DEFINE_CONSTRAINT:
1279 case DEFINE_MEMORY_CONSTRAINT:
1280 case DEFINE_ADDRESS_CONSTRAINT:
1281 process_define_constraint (defn, pattern_lineno);
1284 case DEFINE_REGISTER_CONSTRAINT:
1285 process_define_register_constraint (defn, pattern_lineno);
1293 write_tm_preds_h ();
1295 write_insn_preds_c ();
1297 if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
1298 return FATAL_EXIT_CODE;
1300 return SUCCESS_EXIT_CODE;