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, 2007, 2008, 2009
6 Free Software Foundation, Inc.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
32 #include "gensupport.h"
34 /* Given a predicate expression EXP, from form NAME at line LINENO,
35 verify that it does not contain any RTL constructs which are not
36 valid in predicate definitions. Returns true if EXP is
37 INvalid; issues error messages, caller need not. */
39 validate_exp (rtx exp, const char *name, int lineno)
43 message_with_line (lineno, "%s: must give a predicate expression", name);
47 switch (GET_CODE (exp))
49 /* Ternary, binary, unary expressions: recurse into subexpressions. */
51 if (validate_exp (XEXP (exp, 2), name, lineno))
53 /* else fall through */
56 if (validate_exp (XEXP (exp, 1), name, lineno))
58 /* else fall through */
60 return validate_exp (XEXP (exp, 0), name, lineno);
62 /* MATCH_CODE might have a syntax error in its path expression. */
66 for (p = XSTR (exp, 1); *p; p++)
68 if (!ISDIGIT (*p) && !ISLOWER (*p))
70 message_with_line (lineno, "%s: invalid character in path "
71 "string '%s'", name, XSTR (exp, 1));
79 /* These need no special checking. */
85 message_with_line (lineno,
86 "%s: cannot use '%s' in a predicate expression",
87 name, GET_RTX_NAME (GET_CODE (exp)));
93 /* Predicates are defined with (define_predicate) or
94 (define_special_predicate) expressions in the machine description. */
96 process_define_predicate (rtx defn, int lineno)
98 struct pred_data *pred;
101 if (!ISALPHA (XSTR (defn, 0)[0]) && XSTR (defn, 0)[0] != '_')
103 for (p = XSTR (defn, 0) + 1; *p; p++)
104 if (!ISALNUM (*p) && *p != '_')
107 if (validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno))
110 pred = XCNEW (struct pred_data);
111 pred->name = XSTR (defn, 0);
112 pred->exp = XEXP (defn, 1);
113 pred->c_block = XSTR (defn, 2);
115 if (GET_CODE (defn) == DEFINE_SPECIAL_PREDICATE)
116 pred->special = true;
118 add_predicate (pred);
122 message_with_line (lineno,
123 "%s: predicate name must be a valid C function name",
129 /* Given a predicate, if it has an embedded C block, write the block
130 out as a static inline subroutine, and augment the RTL test with a
131 match_test that calls that subroutine. For instance,
133 (define_predicate "basereg_operand"
134 (match_operand 0 "register_operand")
136 if (GET_CODE (op) == SUBREG)
137 op = SUBREG_REG (op);
138 return REG_POINTER (op);
143 static inline int basereg_operand_1(rtx op, enum machine_mode mode)
145 if (GET_CODE (op) == SUBREG)
146 op = SUBREG_REG (op);
147 return REG_POINTER (op);
150 (define_predicate "basereg_operand"
151 (and (match_operand 0 "register_operand")
152 (match_test "basereg_operand_1 (op, mode)")))
154 The only wart is that there's no way to insist on a { } string in
155 an RTL template, so we have to handle "" strings. */
159 write_predicate_subfunction (struct pred_data *p)
161 const char *match_test_str;
162 rtx match_test_exp, and_exp;
164 if (p->c_block[0] == '\0')
167 /* Construct the function-call expression. */
168 obstack_grow (rtl_obstack, p->name, strlen (p->name));
169 obstack_grow (rtl_obstack, "_1 (op, mode)",
170 sizeof "_1 (op, mode)");
171 match_test_str = XOBFINISH (rtl_obstack, const char *);
173 /* Add the function-call expression to the complete expression to be
175 match_test_exp = rtx_alloc (MATCH_TEST);
176 XSTR (match_test_exp, 0) = match_test_str;
178 and_exp = rtx_alloc (AND);
179 XEXP (and_exp, 0) = p->exp;
180 XEXP (and_exp, 1) = match_test_exp;
184 printf ("static inline int\n"
185 "%s_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n",
187 print_rtx_ptr_loc (p->c_block);
188 if (p->c_block[0] == '{')
189 fputs (p->c_block, stdout);
191 printf ("{\n %s\n}", p->c_block);
192 fputs ("\n\n", stdout);
195 /* Given a predicate expression EXP, from form NAME, determine whether
196 it refers to the variable given as VAR. */
198 needs_variable (rtx exp, const char *var)
200 switch (GET_CODE (exp))
202 /* Ternary, binary, unary expressions need a variable if
203 any of their subexpressions do. */
205 if (needs_variable (XEXP (exp, 2), var))
207 /* else fall through */
210 if (needs_variable (XEXP (exp, 1), var))
212 /* else fall through */
214 return needs_variable (XEXP (exp, 0), var);
216 /* MATCH_CODE uses "op", but nothing else. */
218 return !strcmp (var, "op");
220 /* MATCH_OPERAND uses "op" and may use "mode". */
222 if (!strcmp (var, "op"))
224 if (!strcmp (var, "mode") && GET_MODE (exp) == VOIDmode)
228 /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
231 const char *p = XSTR (exp, 0);
232 const char *q = strstr (p, var);
235 if (q != p && (ISALNUM (q[-1]) || q[-1] == '_'))
238 if (ISALNUM (q[0]) || q[0] == '_')
248 /* Given an RTL expression EXP, find all subexpressions which we may
249 assume to perform mode tests. Normal MATCH_OPERAND does;
250 MATCH_CODE does if it applies to the whole expression and accepts
251 CONST_INT or CONST_DOUBLE; and we have to assume that MATCH_TEST
252 does not. These combine in almost-boolean fashion - the only
253 exception is that (not X) must be assumed not to perform a mode
254 test, whether or not X does.
256 The mark is the RTL /v flag, which is true for subexpressions which
257 do *not* perform mode tests.
259 #define NO_MODE_TEST(EXP) RTX_FLAG (EXP, volatil)
261 mark_mode_tests (rtx exp)
263 switch (GET_CODE (exp))
267 struct pred_data *p = lookup_predicate (XSTR (exp, 1));
269 error ("reference to undefined predicate '%s'", XSTR (exp, 1));
270 else if (p->special || GET_MODE (exp) != VOIDmode)
271 NO_MODE_TEST (exp) = 1;
276 if (XSTR (exp, 1)[0] != '\0'
277 || (!strstr (XSTR (exp, 0), "const_int")
278 && !strstr (XSTR (exp, 0), "const_double")))
279 NO_MODE_TEST (exp) = 1;
284 NO_MODE_TEST (exp) = 1;
288 mark_mode_tests (XEXP (exp, 0));
289 mark_mode_tests (XEXP (exp, 1));
291 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
292 && NO_MODE_TEST (XEXP (exp, 1)));
296 mark_mode_tests (XEXP (exp, 0));
297 mark_mode_tests (XEXP (exp, 1));
299 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
300 || NO_MODE_TEST (XEXP (exp, 1)));
304 /* A ? B : C does a mode test if (one of A and B) does a mode
305 test, and C does too. */
306 mark_mode_tests (XEXP (exp, 0));
307 mark_mode_tests (XEXP (exp, 1));
308 mark_mode_tests (XEXP (exp, 2));
310 NO_MODE_TEST (exp) = ((NO_MODE_TEST (XEXP (exp, 0))
311 && NO_MODE_TEST (XEXP (exp, 1)))
312 || NO_MODE_TEST (XEXP (exp, 2)));
320 /* Determine whether the expression EXP is a MATCH_CODE that should
321 be written as a switch statement. */
323 generate_switch_p (rtx exp)
325 return GET_CODE (exp) == MATCH_CODE
326 && strchr (XSTR (exp, 0), ',');
329 /* Given a predicate, work out where in its RTL expression to add
330 tests for proper modes. Special predicates do not get any such
331 tests. We try to avoid adding tests when we don't have to; in
332 particular, other normal predicates can be counted on to do it for
336 add_mode_tests (struct pred_data *p)
338 rtx match_test_exp, and_exp;
341 /* Don't touch special predicates. */
345 mark_mode_tests (p->exp);
347 /* If the whole expression already tests the mode, we're done. */
348 if (!NO_MODE_TEST (p->exp))
351 match_test_exp = rtx_alloc (MATCH_TEST);
352 XSTR (match_test_exp, 0) = "mode == VOIDmode || GET_MODE (op) == mode";
353 and_exp = rtx_alloc (AND);
354 XEXP (and_exp, 1) = match_test_exp;
356 /* It is always correct to rewrite p->exp as
358 (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode"))
360 but there are a couple forms where we can do better. If the
361 top-level pattern is an IOR, and one of the two branches does test
362 the mode, we can wrap just the branch that doesn't. Likewise, if
363 we have an IF_THEN_ELSE, and one side of it tests the mode, we can
364 wrap just the side that doesn't. And, of course, we can repeat this
365 descent as many times as it works. */
372 switch (GET_CODE (subexp))
375 /* The switch code generation in write_predicate_stmts prefers
376 rtx code tests to be at the top of the expression tree. So
377 push this AND down into the second operand of an existing
379 if (generate_switch_p (XEXP (subexp, 0)))
380 pos = &XEXP (subexp, 1);
385 int test0 = NO_MODE_TEST (XEXP (subexp, 0));
386 int test1 = NO_MODE_TEST (XEXP (subexp, 1));
388 gcc_assert (test0 || test1);
392 pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1);
398 int test0 = NO_MODE_TEST (XEXP (subexp, 0));
399 int test1 = NO_MODE_TEST (XEXP (subexp, 1));
400 int test2 = NO_MODE_TEST (XEXP (subexp, 2));
402 gcc_assert ((test0 && test1) || test2);
404 if (test0 && test1 && test2)
407 /* Must put it on the dependent clause, not the
408 controlling expression, or we change the meaning of
410 pos = &XEXP (subexp, 1);
412 pos = &XEXP (subexp, 2);
421 XEXP (and_exp, 0) = *pos;
425 /* PATH is a string describing a path from the root of an RTL
426 expression to an inner subexpression to be tested. Output
427 code which computes the subexpression from the variable
428 holding the root of the expression. */
430 write_extract_subexp (const char *path)
432 int len = strlen (path);
435 /* We first write out the operations (XEXP or XVECEXP) in reverse
436 order, then write "op", then the indices in forward order. */
437 for (i = len - 1; i >= 0; i--)
439 if (ISLOWER (path[i]))
440 fputs ("XVECEXP (", stdout);
441 else if (ISDIGIT (path[i]))
442 fputs ("XEXP (", stdout);
447 fputs ("op", stdout);
449 for (i = 0; i < len; i++)
451 if (ISLOWER (path[i]))
452 printf (", 0, %d)", path[i] - 'a');
453 else if (ISDIGIT (path[i]))
454 printf (", %d)", path[i] - '0');
460 /* CODES is a list of RTX codes. Write out an expression which
461 determines whether the operand has one of those codes. */
463 write_match_code (const char *path, const char *codes)
467 while ((code = scan_comma_elt (&codes)) != 0)
469 fputs ("GET_CODE (", stdout);
470 write_extract_subexp (path);
471 fputs (") == ", stdout);
474 putchar (TOUPPER (*code));
479 fputs (" || ", stdout);
483 /* EXP is an RTL (sub)expression for a predicate. Recursively
484 descend the expression and write out an equivalent C expression. */
486 write_predicate_expr (rtx exp)
488 switch (GET_CODE (exp))
492 write_predicate_expr (XEXP (exp, 0));
493 fputs (") && (", stdout);
494 write_predicate_expr (XEXP (exp, 1));
500 write_predicate_expr (XEXP (exp, 0));
501 fputs (") || (", stdout);
502 write_predicate_expr (XEXP (exp, 1));
507 fputs ("!(", stdout);
508 write_predicate_expr (XEXP (exp, 0));
514 write_predicate_expr (XEXP (exp, 0));
515 fputs (") ? (", stdout);
516 write_predicate_expr (XEXP (exp, 1));
517 fputs (") : (", stdout);
518 write_predicate_expr (XEXP (exp, 2));
523 if (GET_MODE (exp) == VOIDmode)
524 printf ("%s (op, mode)", XSTR (exp, 1));
526 printf ("%s (op, %smode)", XSTR (exp, 1), mode_name[GET_MODE (exp)]);
530 write_match_code (XSTR (exp, 1), XSTR (exp, 0));
534 print_c_condition (XSTR (exp, 0));
542 /* Write the MATCH_CODE expression EXP as a switch statement. */
545 write_match_code_switch (rtx exp)
547 const char *codes = XSTR (exp, 0);
548 const char *path = XSTR (exp, 1);
551 fputs (" switch (GET_CODE (", stdout);
552 write_extract_subexp (path);
553 fputs ("))\n {\n", stdout);
555 while ((code = scan_comma_elt (&codes)) != 0)
557 fputs (" case ", stdout);
560 putchar (TOUPPER (*code));
563 fputs(":\n", stdout);
567 /* Given a predicate expression EXP, write out a sequence of stmts
568 to evaluate it. This is similar to write_predicate_expr but can
569 generate efficient switch statements. */
572 write_predicate_stmts (rtx exp)
574 switch (GET_CODE (exp))
577 if (generate_switch_p (exp))
579 write_match_code_switch (exp);
580 puts (" return true;\n"
590 if (generate_switch_p (XEXP (exp, 0)))
592 write_match_code_switch (XEXP (exp, 0));
602 if (generate_switch_p (XEXP (exp, 0)))
604 write_match_code_switch (XEXP (exp, 0));
605 puts (" return true;\n"
614 if (generate_switch_p (XEXP (exp, 0)))
616 write_match_code_switch (XEXP (exp, 0));
617 puts (" return false;\n"
630 fputs(" return ",stdout);
631 write_predicate_expr (exp);
632 fputs(";\n", stdout);
635 /* Given a predicate, write out a complete C function to compute it. */
637 write_one_predicate_function (struct pred_data *p)
642 write_predicate_subfunction (p);
645 /* A normal predicate can legitimately not look at enum machine_mode
646 if it accepts only CONST_INTs and/or CONST_DOUBLEs. */
647 printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n{\n",
649 write_predicate_stmts (p->exp);
650 fputs ("}\n\n", stdout);
653 /* Constraints fall into two categories: register constraints
654 (define_register_constraint), and others (define_constraint,
655 define_memory_constraint, define_address_constraint). We
656 work out automatically which of the various old-style macros
657 they correspond to, and produce appropriate code. They all
658 go in the same hash table so we can verify that there are no
661 /* All data from one constraint definition. */
662 struct constraint_data
664 struct constraint_data *next_this_letter;
665 struct constraint_data *next_textual;
667 const char *c_name; /* same as .name unless mangling is necessary */
669 const char *regclass; /* for register constraints */
670 rtx exp; /* for other constraints */
671 unsigned int lineno; /* line of definition */
672 unsigned int is_register : 1;
673 unsigned int is_const_int : 1;
674 unsigned int is_const_dbl : 1;
675 unsigned int is_extra : 1;
676 unsigned int is_memory : 1;
677 unsigned int is_address : 1;
680 /* Overview of all constraints beginning with a given letter. */
682 static struct constraint_data *
683 constraints_by_letter_table[1<<CHAR_BIT];
685 /* For looking up all the constraints in the order that they appeared
686 in the machine description. */
687 static struct constraint_data *first_constraint;
688 static struct constraint_data **last_constraint_ptr = &first_constraint;
690 #define FOR_ALL_CONSTRAINTS(iter_) \
691 for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
693 /* These letters, and all names beginning with them, are reserved for
695 The 'm' constraint is not mentioned here since that constraint
696 letter can be overridden by the back end by defining the
697 TARGET_MEM_CONSTRAINT macro. */
698 static const char generic_constraint_letters[] = "EFVXginoprs";
700 /* Machine-independent code expects that constraints with these
701 (initial) letters will allow only (a subset of all) CONST_INTs. */
703 static const char const_int_constraints[] = "IJKLMNOP";
705 /* Machine-independent code expects that constraints with these
706 (initial) letters will allow only (a subset of all) CONST_DOUBLEs. */
708 static const char const_dbl_constraints[] = "GH";
710 /* Summary data used to decide whether to output various functions and
711 macro definitions. */
712 static unsigned int constraint_max_namelen;
713 static bool have_register_constraints;
714 static bool have_memory_constraints;
715 static bool have_address_constraints;
716 static bool have_extra_constraints;
717 static bool have_const_int_constraints;
718 static bool have_const_dbl_constraints;
720 /* Convert NAME, which contains angle brackets and/or underscores, to
721 a string that can be used as part of a C identifier. The string
722 comes from the rtl_obstack. */
724 mangle (const char *name)
726 for (; *name; name++)
729 case '_': obstack_grow (rtl_obstack, "__", 2); break;
730 case '<': obstack_grow (rtl_obstack, "_l", 2); break;
731 case '>': obstack_grow (rtl_obstack, "_g", 2); break;
732 default: obstack_1grow (rtl_obstack, *name); break;
735 obstack_1grow (rtl_obstack, '\0');
736 return XOBFINISH (rtl_obstack, const char *);
739 /* Add one constraint, of any sort, to the tables. NAME is its name;
740 REGCLASS is the register class, if any; EXP is the expression to
741 test, if any; IS_MEMORY and IS_ADDRESS indicate memory and address
742 constraints, respectively; LINENO is the line number from the MD reader.
743 Not all combinations of arguments are valid; most importantly, REGCLASS
744 is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only
745 meaningful for constraints with EXP.
747 This function enforces all syntactic and semantic rules about what
748 constraints can be defined. */
751 add_constraint (const char *name, const char *regclass,
752 rtx exp, bool is_memory, bool is_address,
755 struct constraint_data *c, **iter, **slot;
757 bool need_mangled_name = false;
762 if (exp && validate_exp (exp, name, lineno))
765 if (!ISALPHA (name[0]) && name[0] != '_')
768 message_with_line (lineno, "constraint name '%s' is not "
769 "a letter or underscore", name);
771 message_with_line (lineno, "constraint name '%s' does not begin "
772 "with a letter or underscore", name);
776 for (p = name; *p; p++)
779 if (*p == '<' || *p == '>' || *p == '_')
780 need_mangled_name = true;
783 message_with_line (lineno,
784 "constraint name '%s' must be composed of "
785 "letters, digits, underscores, and "
786 "angle brackets", name);
792 if (strchr (generic_constraint_letters, name[0]))
795 message_with_line (lineno, "constraint letter '%s' cannot be "
796 "redefined by the machine description", name);
798 message_with_line (lineno, "constraint name '%s' cannot be defined by "
799 "the machine description, as it begins with '%c'",
806 namelen = strlen (name);
807 slot = &constraints_by_letter_table[(unsigned int)name[0]];
808 for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
810 /* This causes slot to end up pointing to the
811 next_this_letter field of the last constraint with a name
812 of equal or greater length than the new constraint; hence
813 the new constraint will be inserted after all previous
814 constraints with names of the same length. */
815 if ((*iter)->namelen >= namelen)
818 if (!strcmp ((*iter)->name, name))
820 message_with_line (lineno, "redefinition of constraint '%s'", name);
821 message_with_line ((*iter)->lineno, "previous definition is here");
825 else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
827 message_with_line (lineno, "defining constraint '%s' here", name);
828 message_with_line ((*iter)->lineno, "renders constraint '%s' "
829 "(defined here) a prefix", (*iter)->name);
833 else if (!strncmp ((*iter)->name, name, namelen))
835 message_with_line (lineno, "constraint '%s' is a prefix", name);
836 message_with_line ((*iter)->lineno, "of constraint '%s' "
837 "(defined here)", (*iter)->name);
843 is_const_int = strchr (const_int_constraints, name[0]) != 0;
844 is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
846 if (is_const_int || is_const_dbl)
848 enum rtx_code appropriate_code
849 = is_const_int ? CONST_INT : CONST_DOUBLE;
851 /* Consider relaxing this requirement in the future. */
853 || GET_CODE (exp) != AND
854 || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
855 || strcmp (XSTR (XEXP (exp, 0), 0),
856 GET_RTX_NAME (appropriate_code)))
859 message_with_line (lineno, "constraint letter '%c' is reserved "
860 "for %s constraints",
861 name[0], GET_RTX_NAME (appropriate_code));
863 message_with_line (lineno, "constraint names beginning with '%c' "
864 "(%s) are reserved for %s constraints",
866 GET_RTX_NAME (appropriate_code));
875 message_with_line (lineno, "constraint letter '%c' cannot be a "
876 "memory constraint", name[0]);
878 message_with_line (lineno, "constraint name '%s' begins with '%c', "
879 "and therefore cannot be a memory constraint",
888 message_with_line (lineno, "constraint letter '%c' cannot be a "
889 "memory constraint", name[0]);
891 message_with_line (lineno, "constraint name '%s' begins with '%c', "
892 "and therefore cannot be a memory constraint",
901 c = XOBNEW (rtl_obstack, struct constraint_data);
903 c->c_name = need_mangled_name ? mangle (name) : name;
905 c->namelen = namelen;
906 c->regclass = regclass;
908 c->is_register = regclass != 0;
909 c->is_const_int = is_const_int;
910 c->is_const_dbl = is_const_dbl;
911 c->is_extra = !(regclass || is_const_int || is_const_dbl);
912 c->is_memory = is_memory;
913 c->is_address = is_address;
915 c->next_this_letter = *slot;
918 /* Insert this constraint in the list of all constraints in textual
921 *last_constraint_ptr = c;
922 last_constraint_ptr = &c->next_textual;
924 constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
925 have_register_constraints |= c->is_register;
926 have_const_int_constraints |= c->is_const_int;
927 have_const_dbl_constraints |= c->is_const_dbl;
928 have_extra_constraints |= c->is_extra;
929 have_memory_constraints |= c->is_memory;
930 have_address_constraints |= c->is_address;
933 /* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or
934 DEFINE_ADDRESS_CONSTRAINT expression, C. */
936 process_define_constraint (rtx c, int lineno)
938 add_constraint (XSTR (c, 0), 0, XEXP (c, 2),
939 GET_CODE (c) == DEFINE_MEMORY_CONSTRAINT,
940 GET_CODE (c) == DEFINE_ADDRESS_CONSTRAINT,
944 /* Process a DEFINE_REGISTER_CONSTRAINT expression, C. */
946 process_define_register_constraint (rtx c, int lineno)
948 add_constraint (XSTR (c, 0), XSTR (c, 1), 0, false, false, lineno);
951 /* Write out an enumeration with one entry per machine-specific
954 write_enum_constraint_num (void)
956 struct constraint_data *c;
958 fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout);
959 fputs ("enum constraint_num\n"
961 " CONSTRAINT__UNKNOWN = 0", stdout);
962 FOR_ALL_CONSTRAINTS (c)
963 printf (",\n CONSTRAINT_%s", c->c_name);
964 puts (",\n CONSTRAINT__LIMIT\n};\n");
967 /* Write out a function which looks at a string and determines what
968 constraint name, if any, it begins with. */
970 write_lookup_constraint (void)
973 puts ("enum constraint_num\n"
974 "lookup_constraint (const char *str)\n"
979 for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
981 struct constraint_data *c = constraints_by_letter_table[i];
985 printf (" case '%c':\n", i);
987 printf (" return CONSTRAINT_%s;\n", c->c_name);
992 printf (" if (!strncmp (str, \"%s\", %lu))\n"
993 " return CONSTRAINT_%s;\n",
994 c->name, (unsigned long int) c->namelen, c->c_name);
995 c = c->next_this_letter;
1002 puts (" default: break;\n"
1004 " return CONSTRAINT__UNKNOWN;\n"
1008 /* Write out a function which looks at a string and determines what
1009 the constraint name length is. */
1011 write_insn_constraint_len (void)
1015 puts ("static inline size_t\n"
1016 "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n"
1021 for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
1023 struct constraint_data *c = constraints_by_letter_table[i];
1029 /* Constraints with multiple characters should have the same
1032 struct constraint_data *c2 = c->next_this_letter;
1033 size_t len = c->namelen;
1036 if (c2->namelen != len)
1037 error ("Multi-letter constraints with first letter '%c' "
1038 "should have same length", i);
1039 c2 = c2->next_this_letter;
1043 printf (" case '%c': return %lu;\n",
1044 i, (unsigned long int) c->namelen);
1047 puts (" default: break;\n"
1053 /* Write out the function which computes the register class corresponding
1054 to a register constraint. */
1056 write_regclass_for_constraint (void)
1058 struct constraint_data *c;
1060 puts ("enum reg_class\n"
1061 "regclass_for_constraint (enum constraint_num c)\n"
1066 FOR_ALL_CONSTRAINTS (c)
1068 printf (" case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
1070 puts (" default: break;\n"
1072 " return NO_REGS;\n"
1076 /* Write out the functions which compute whether a given value matches
1077 a given non-register constraint. */
1079 write_tm_constrs_h (void)
1081 struct constraint_data *c;
1084 /* Generated automatically by the program '%s'\n\
1085 from the machine description file '%s'. */\n\n", progname, in_fname);
1088 #ifndef GCC_TM_CONSTRS_H\n\
1089 #define GCC_TM_CONSTRS_H\n");
1091 FOR_ALL_CONSTRAINTS (c)
1092 if (!c->is_register)
1094 bool needs_ival = needs_variable (c->exp, "ival");
1095 bool needs_hval = needs_variable (c->exp, "hval");
1096 bool needs_lval = needs_variable (c->exp, "lval");
1097 bool needs_rval = needs_variable (c->exp, "rval");
1098 bool needs_mode = (needs_variable (c->exp, "mode")
1099 || needs_hval || needs_lval || needs_rval);
1100 bool needs_op = (needs_variable (c->exp, "op")
1101 || needs_ival || needs_mode);
1103 printf ("static inline bool\n"
1104 "satisfies_constraint_%s (rtx %s)\n"
1106 needs_op ? "op" : "ARG_UNUSED (op)");
1108 puts (" enum machine_mode mode = GET_MODE (op);");
1110 puts (" HOST_WIDE_INT ival = 0;");
1112 puts (" HOST_WIDE_INT hval = 0;");
1114 puts (" unsigned HOST_WIDE_INT lval = 0;");
1116 puts (" const REAL_VALUE_TYPE *rval = 0;");
1119 puts (" if (CONST_INT_P (op))\n"
1120 " ival = INTVAL (op);");
1122 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1123 " hval = CONST_DOUBLE_HIGH (op);");
1125 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1126 " lval = CONST_DOUBLE_LOW (op);");
1128 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
1129 " rval = CONST_DOUBLE_REAL_VALUE (op);");
1131 write_predicate_stmts (c->exp);
1132 fputs ("}\n", stdout);
1134 puts ("#endif /* tm-constrs.h */");
1137 /* Write out the wrapper function, constraint_satisfied_p, that maps
1138 a CONSTRAINT_xxx constant to one of the predicate functions generated
1141 write_constraint_satisfied_p (void)
1143 struct constraint_data *c;
1146 "constraint_satisfied_p (rtx op, enum constraint_num c)\n"
1151 FOR_ALL_CONSTRAINTS (c)
1152 if (!c->is_register)
1153 printf (" case CONSTRAINT_%s: "
1154 "return satisfies_constraint_%s (op);\n",
1155 c->c_name, c->c_name);
1157 puts (" default: break;\n"
1163 /* Write out the function which computes whether a given value matches
1164 a given CONST_INT constraint. This doesn't just forward to
1165 constraint_satisfied_p because caller passes the INTVAL, not the RTX. */
1167 write_insn_const_int_ok_for_constraint (void)
1169 struct constraint_data *c;
1172 "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1173 "enum constraint_num c)\n"
1178 FOR_ALL_CONSTRAINTS (c)
1179 if (c->is_const_int)
1181 printf (" case CONSTRAINT_%s:\n return ", c->c_name);
1182 /* c->exp is guaranteed to be (and (match_code "const_int") (...));
1183 we know at this point that we have a const_int, so we need not
1184 bother with that part of the test. */
1185 write_predicate_expr (XEXP (c->exp, 1));
1186 fputs (";\n\n", stdout);
1189 puts (" default: break;\n"
1196 /* Write out the function which computes whether a given constraint is
1197 a memory constraint. */
1199 write_insn_extra_memory_constraint (void)
1201 struct constraint_data *c;
1204 "insn_extra_memory_constraint (enum constraint_num c)\n"
1209 FOR_ALL_CONSTRAINTS (c)
1211 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name);
1213 puts (" default: break;\n"
1219 /* Write out the function which computes whether a given constraint is
1220 an address constraint. */
1222 write_insn_extra_address_constraint (void)
1224 struct constraint_data *c;
1227 "insn_extra_address_constraint (enum constraint_num c)\n"
1232 FOR_ALL_CONSTRAINTS (c)
1234 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name);
1236 puts (" default: break;\n"
1243 /* Write tm-preds.h. Unfortunately, it is impossible to forward-declare
1244 an enumeration in portable C, so we have to condition all these
1245 prototypes on HAVE_MACHINE_MODES. */
1247 write_tm_preds_h (void)
1249 struct pred_data *p;
1252 /* Generated automatically by the program '%s'\n\
1253 from the machine description file '%s'. */\n\n", progname, in_fname);
1256 #ifndef GCC_TM_PREDS_H\n\
1257 #define GCC_TM_PREDS_H\n\
1259 #ifdef HAVE_MACHINE_MODES");
1261 FOR_ALL_PREDICATES (p)
1262 printf ("extern int %s (rtx, enum machine_mode);\n", p->name);
1264 puts ("#endif /* HAVE_MACHINE_MODES */\n");
1266 if (constraint_max_namelen > 0)
1268 write_enum_constraint_num ();
1269 puts ("extern enum constraint_num lookup_constraint (const char *);\n"
1270 "extern bool constraint_satisfied_p (rtx, enum constraint_num);\n");
1272 if (constraint_max_namelen > 1)
1274 write_insn_constraint_len ();
1275 puts ("#define CONSTRAINT_LEN(c_,s_) "
1276 "insn_constraint_len (c_,s_)\n");
1279 puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1280 if (have_register_constraints)
1281 puts ("extern enum reg_class regclass_for_constraint "
1282 "(enum constraint_num);\n"
1283 "#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n"
1284 " regclass_for_constraint (lookup_constraint (s_))\n"
1285 "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
1286 " regclass_for_constraint (x_)\n");
1288 puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS\n"
1289 "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
1291 if (have_const_int_constraints)
1292 puts ("extern bool insn_const_int_ok_for_constraint "
1293 "(HOST_WIDE_INT, enum constraint_num);\n"
1294 "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1295 " insn_const_int_ok_for_constraint (v_, "
1296 "lookup_constraint (s_))\n");
1297 if (have_const_dbl_constraints)
1298 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1299 " constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1301 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) 0\n");
1302 if (have_extra_constraints)
1303 puts ("#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \\\n"
1304 " constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1305 if (have_memory_constraints)
1306 puts ("extern bool "
1307 "insn_extra_memory_constraint (enum constraint_num);\n"
1308 "#define EXTRA_MEMORY_CONSTRAINT(c_,s_) "
1309 "insn_extra_memory_constraint (lookup_constraint (s_))\n");
1311 puts ("#define EXTRA_MEMORY_CONSTRAINT(c_,s_) false\n");
1312 if (have_address_constraints)
1313 puts ("extern bool "
1314 "insn_extra_address_constraint (enum constraint_num);\n"
1315 "#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) "
1316 "insn_extra_address_constraint (lookup_constraint (s_))\n");
1318 puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n");
1321 puts ("#endif /* tm-preds.h */");
1324 /* Write insn-preds.c.
1325 N.B. the list of headers to include was copied from genrecog; it
1328 FUTURE: Write #line markers referring back to the machine
1329 description. (Can't practically do this now since we don't know
1330 the line number of the C block - just the line number of the enclosing
1333 write_insn_preds_c (void)
1335 struct pred_data *p;
1338 /* Generated automatically by the program '%s'\n\
1339 from the machine description file '%s'. */\n\n", progname, in_fname);
1342 #include \"config.h\"\n\
1343 #include \"system.h\"\n\
1344 #include \"coretypes.h\"\n\
1345 #include \"tm.h\"\n\
1346 #include \"rtl.h\"\n\
1347 #include \"tree.h\"\n\
1348 #include \"tm_p.h\"\n\
1349 #include \"function.h\"\n\
1350 #include \"insn-config.h\"\n\
1351 #include \"recog.h\"\n\
1352 #include \"output.h\"\n\
1353 #include \"flags.h\"\n\
1354 #include \"hard-reg-set.h\"\n\
1355 #include \"resource.h\"\n\
1356 #include \"toplev.h\"\n\
1357 #include \"reload.h\"\n\
1358 #include \"regs.h\"\n\
1359 #include \"tm-constrs.h\"\n");
1361 FOR_ALL_PREDICATES (p)
1362 write_one_predicate_function (p);
1364 if (constraint_max_namelen > 0)
1366 write_lookup_constraint ();
1367 if (have_register_constraints)
1368 write_regclass_for_constraint ();
1369 write_constraint_satisfied_p ();
1371 if (have_const_int_constraints)
1372 write_insn_const_int_ok_for_constraint ();
1374 if (have_memory_constraints)
1375 write_insn_extra_memory_constraint ();
1376 if (have_address_constraints)
1377 write_insn_extra_address_constraint ();
1381 /* Argument parsing. */
1382 static bool gen_header;
1383 static bool gen_constrs;
1386 parse_option (const char *opt)
1388 if (!strcmp (opt, "-h"))
1393 else if (!strcmp (opt, "-c"))
1402 /* Master control. */
1404 main (int argc, char **argv)
1407 int pattern_lineno, next_insn_code = 0;
1411 fatal ("no input file name");
1412 if (init_md_reader_args_cb (argc, argv, parse_option) != SUCCESS_EXIT_CODE)
1413 return FATAL_EXIT_CODE;
1415 while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0)
1416 switch (GET_CODE (defn))
1418 case DEFINE_PREDICATE:
1419 case DEFINE_SPECIAL_PREDICATE:
1420 process_define_predicate (defn, pattern_lineno);
1423 case DEFINE_CONSTRAINT:
1424 case DEFINE_MEMORY_CONSTRAINT:
1425 case DEFINE_ADDRESS_CONSTRAINT:
1426 process_define_constraint (defn, pattern_lineno);
1429 case DEFINE_REGISTER_CONSTRAINT:
1430 process_define_register_constraint (defn, pattern_lineno);
1438 write_tm_preds_h ();
1439 else if (gen_constrs)
1440 write_tm_constrs_h ();
1442 write_insn_preds_c ();
1444 if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
1445 return FATAL_EXIT_CODE;
1447 return SUCCESS_EXIT_CODE;