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-2015 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 line LINENO,
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
, int lineno
)
44 message_with_line (lineno
, "%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
, lineno
))
54 /* else fall through */
57 if (validate_exp (XEXP (exp
, 1), name
, lineno
))
59 /* else fall through */
61 return validate_exp (XEXP (exp
, 0), name
, lineno
);
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_with_line (lineno
, "%s: invalid character in path "
72 "string '%s'", name
, XSTR (exp
, 1));
79 /* These need no special checking. */
85 error_with_line (lineno
,
86 "%s: cannot use '%s' in a predicate expression",
87 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 validate_exp (XEXP (defn
, 1), XSTR (defn
, 0), lineno
);
100 /* Given a predicate, if it has an embedded C block, write the block
101 out as a static inline subroutine, and augment the RTL test with a
102 match_test that calls that subroutine. For instance,
104 (define_predicate "basereg_operand"
105 (match_operand 0 "register_operand")
107 if (GET_CODE (op) == SUBREG)
108 op = SUBREG_REG (op);
109 return REG_POINTER (op);
114 static inline int basereg_operand_1(rtx op, machine_mode mode)
116 if (GET_CODE (op) == SUBREG)
117 op = SUBREG_REG (op);
118 return REG_POINTER (op);
121 (define_predicate "basereg_operand"
122 (and (match_operand 0 "register_operand")
123 (match_test "basereg_operand_1 (op, mode)")))
125 The only wart is that there's no way to insist on a { } string in
126 an RTL template, so we have to handle "" strings. */
130 write_predicate_subfunction (struct pred_data
*p
)
132 const char *match_test_str
;
133 rtx match_test_exp
, and_exp
;
135 if (p
->c_block
[0] == '\0')
138 /* Construct the function-call expression. */
139 obstack_grow (rtl_obstack
, p
->name
, strlen (p
->name
));
140 obstack_grow (rtl_obstack
, "_1 (op, mode)",
141 sizeof "_1 (op, mode)");
142 match_test_str
= XOBFINISH (rtl_obstack
, const char *);
144 /* Add the function-call expression to the complete expression to be
146 match_test_exp
= rtx_alloc (MATCH_TEST
);
147 XSTR (match_test_exp
, 0) = match_test_str
;
149 and_exp
= rtx_alloc (AND
);
150 XEXP (and_exp
, 0) = p
->exp
;
151 XEXP (and_exp
, 1) = match_test_exp
;
155 printf ("static inline int\n"
156 "%s_1 (rtx op, machine_mode mode ATTRIBUTE_UNUSED)\n",
158 print_md_ptr_loc (p
->c_block
);
159 if (p
->c_block
[0] == '{')
160 fputs (p
->c_block
, stdout
);
162 printf ("{\n %s\n}", p
->c_block
);
163 fputs ("\n\n", stdout
);
166 /* Given a predicate expression EXP, from form NAME, determine whether
167 it refers to the variable given as VAR. */
169 needs_variable (rtx exp
, const char *var
)
171 switch (GET_CODE (exp
))
173 /* Ternary, binary, unary expressions need a variable if
174 any of their subexpressions do. */
176 if (needs_variable (XEXP (exp
, 2), var
))
178 /* else fall through */
181 if (needs_variable (XEXP (exp
, 1), var
))
183 /* else fall through */
185 return needs_variable (XEXP (exp
, 0), var
);
187 /* MATCH_CODE uses "op", but nothing else. */
189 return !strcmp (var
, "op");
191 /* MATCH_OPERAND uses "op" and may use "mode". */
193 if (!strcmp (var
, "op"))
195 if (!strcmp (var
, "mode") && GET_MODE (exp
) == VOIDmode
)
199 /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
202 const char *p
= XSTR (exp
, 0);
203 const char *q
= strstr (p
, var
);
206 if (q
!= p
&& (ISALNUM (q
[-1]) || q
[-1] == '_'))
209 if (ISALNUM (q
[0]) || q
[0] == '_')
219 /* Given an RTL expression EXP, find all subexpressions which we may
220 assume to perform mode tests. Normal MATCH_OPERAND does;
221 MATCH_CODE does if it applies to the whole expression and accepts
222 CONST_INT or CONST_DOUBLE; and we have to assume that MATCH_TEST
223 does not. These combine in almost-boolean fashion - the only
224 exception is that (not X) must be assumed not to perform a mode
225 test, whether or not X does.
227 The mark is the RTL /v flag, which is true for subexpressions which
228 do *not* perform mode tests.
230 #define NO_MODE_TEST(EXP) RTX_FLAG (EXP, volatil)
232 mark_mode_tests (rtx exp
)
234 switch (GET_CODE (exp
))
238 struct pred_data
*p
= lookup_predicate (XSTR (exp
, 1));
240 error ("reference to undefined predicate '%s'", XSTR (exp
, 1));
241 else if (p
->special
|| GET_MODE (exp
) != VOIDmode
)
242 NO_MODE_TEST (exp
) = 1;
247 if (XSTR (exp
, 1)[0] != '\0'
248 || (!strstr (XSTR (exp
, 0), "const_int")
249 && !strstr (XSTR (exp
, 0), "const_double")))
250 NO_MODE_TEST (exp
) = 1;
255 NO_MODE_TEST (exp
) = 1;
259 mark_mode_tests (XEXP (exp
, 0));
260 mark_mode_tests (XEXP (exp
, 1));
262 NO_MODE_TEST (exp
) = (NO_MODE_TEST (XEXP (exp
, 0))
263 && NO_MODE_TEST (XEXP (exp
, 1)));
267 mark_mode_tests (XEXP (exp
, 0));
268 mark_mode_tests (XEXP (exp
, 1));
270 NO_MODE_TEST (exp
) = (NO_MODE_TEST (XEXP (exp
, 0))
271 || NO_MODE_TEST (XEXP (exp
, 1)));
275 /* A ? B : C does a mode test if (one of A and B) does a mode
276 test, and C does too. */
277 mark_mode_tests (XEXP (exp
, 0));
278 mark_mode_tests (XEXP (exp
, 1));
279 mark_mode_tests (XEXP (exp
, 2));
281 NO_MODE_TEST (exp
) = ((NO_MODE_TEST (XEXP (exp
, 0))
282 && NO_MODE_TEST (XEXP (exp
, 1)))
283 || NO_MODE_TEST (XEXP (exp
, 2)));
291 /* Determine whether the expression EXP is a MATCH_CODE that should
292 be written as a switch statement. */
294 generate_switch_p (rtx exp
)
296 return GET_CODE (exp
) == MATCH_CODE
297 && strchr (XSTR (exp
, 0), ',');
300 /* Given a predicate, work out where in its RTL expression to add
301 tests for proper modes. Special predicates do not get any such
302 tests. We try to avoid adding tests when we don't have to; in
303 particular, other normal predicates can be counted on to do it for
307 add_mode_tests (struct pred_data
*p
)
309 rtx match_test_exp
, and_exp
;
312 /* Don't touch special predicates. */
316 mark_mode_tests (p
->exp
);
318 /* If the whole expression already tests the mode, we're done. */
319 if (!NO_MODE_TEST (p
->exp
))
322 match_test_exp
= rtx_alloc (MATCH_TEST
);
323 XSTR (match_test_exp
, 0) = "mode == VOIDmode || GET_MODE (op) == mode";
324 and_exp
= rtx_alloc (AND
);
325 XEXP (and_exp
, 1) = match_test_exp
;
327 /* It is always correct to rewrite p->exp as
329 (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode"))
331 but there are a couple forms where we can do better. If the
332 top-level pattern is an IOR, and one of the two branches does test
333 the mode, we can wrap just the branch that doesn't. Likewise, if
334 we have an IF_THEN_ELSE, and one side of it tests the mode, we can
335 wrap just the side that doesn't. And, of course, we can repeat this
336 descent as many times as it works. */
343 switch (GET_CODE (subexp
))
346 /* The switch code generation in write_predicate_stmts prefers
347 rtx code tests to be at the top of the expression tree. So
348 push this AND down into the second operand of an existing
350 if (generate_switch_p (XEXP (subexp
, 0)))
351 pos
= &XEXP (subexp
, 1);
356 int test0
= NO_MODE_TEST (XEXP (subexp
, 0));
357 int test1
= NO_MODE_TEST (XEXP (subexp
, 1));
359 gcc_assert (test0
|| test1
);
363 pos
= test0
? &XEXP (subexp
, 0) : &XEXP (subexp
, 1);
369 int test0
= NO_MODE_TEST (XEXP (subexp
, 0));
370 int test1
= NO_MODE_TEST (XEXP (subexp
, 1));
371 int test2
= NO_MODE_TEST (XEXP (subexp
, 2));
373 gcc_assert ((test0
&& test1
) || test2
);
375 if (test0
&& test1
&& test2
)
378 /* Must put it on the dependent clause, not the
379 controlling expression, or we change the meaning of
381 pos
= &XEXP (subexp
, 1);
383 pos
= &XEXP (subexp
, 2);
392 XEXP (and_exp
, 0) = *pos
;
396 /* PATH is a string describing a path from the root of an RTL
397 expression to an inner subexpression to be tested. Output
398 code which computes the subexpression from the variable
399 holding the root of the expression. */
401 write_extract_subexp (const char *path
)
403 int len
= strlen (path
);
406 /* We first write out the operations (XEXP or XVECEXP) in reverse
407 order, then write "op", then the indices in forward order. */
408 for (i
= len
- 1; i
>= 0; i
--)
410 if (ISLOWER (path
[i
]))
411 fputs ("XVECEXP (", stdout
);
412 else if (ISDIGIT (path
[i
]))
413 fputs ("XEXP (", stdout
);
418 fputs ("op", stdout
);
420 for (i
= 0; i
< len
; i
++)
422 if (ISLOWER (path
[i
]))
423 printf (", 0, %d)", path
[i
] - 'a');
424 else if (ISDIGIT (path
[i
]))
425 printf (", %d)", path
[i
] - '0');
431 /* CODES is a list of RTX codes. Write out an expression which
432 determines whether the operand has one of those codes. */
434 write_match_code (const char *path
, const char *codes
)
438 while ((code
= scan_comma_elt (&codes
)) != 0)
440 fputs ("GET_CODE (", stdout
);
441 write_extract_subexp (path
);
442 fputs (") == ", stdout
);
445 putchar (TOUPPER (*code
));
450 fputs (" || ", stdout
);
454 /* EXP is an RTL (sub)expression for a predicate. Recursively
455 descend the expression and write out an equivalent C expression. */
457 write_predicate_expr (rtx exp
)
459 switch (GET_CODE (exp
))
463 write_predicate_expr (XEXP (exp
, 0));
464 fputs (") && (", stdout
);
465 write_predicate_expr (XEXP (exp
, 1));
471 write_predicate_expr (XEXP (exp
, 0));
472 fputs (") || (", stdout
);
473 write_predicate_expr (XEXP (exp
, 1));
478 fputs ("!(", stdout
);
479 write_predicate_expr (XEXP (exp
, 0));
485 write_predicate_expr (XEXP (exp
, 0));
486 fputs (") ? (", stdout
);
487 write_predicate_expr (XEXP (exp
, 1));
488 fputs (") : (", stdout
);
489 write_predicate_expr (XEXP (exp
, 2));
494 if (GET_MODE (exp
) == VOIDmode
)
495 printf ("%s (op, mode)", XSTR (exp
, 1));
497 printf ("%s (op, %smode)", XSTR (exp
, 1), mode_name
[GET_MODE (exp
)]);
501 write_match_code (XSTR (exp
, 1), XSTR (exp
, 0));
505 print_c_condition (XSTR (exp
, 0));
513 /* Write the MATCH_CODE expression EXP as a switch statement. */
516 write_match_code_switch (rtx exp
)
518 const char *codes
= XSTR (exp
, 0);
519 const char *path
= XSTR (exp
, 1);
522 fputs (" switch (GET_CODE (", stdout
);
523 write_extract_subexp (path
);
524 fputs ("))\n {\n", stdout
);
526 while ((code
= scan_comma_elt (&codes
)) != 0)
528 fputs (" case ", stdout
);
531 putchar (TOUPPER (*code
));
534 fputs (":\n", stdout
);
538 /* Given a predicate expression EXP, write out a sequence of stmts
539 to evaluate it. This is similar to write_predicate_expr but can
540 generate efficient switch statements. */
543 write_predicate_stmts (rtx exp
)
545 switch (GET_CODE (exp
))
548 if (generate_switch_p (exp
))
550 write_match_code_switch (exp
);
551 puts (" return true;\n"
561 if (generate_switch_p (XEXP (exp
, 0)))
563 write_match_code_switch (XEXP (exp
, 0));
573 if (generate_switch_p (XEXP (exp
, 0)))
575 write_match_code_switch (XEXP (exp
, 0));
576 puts (" return true;\n"
585 if (generate_switch_p (XEXP (exp
, 0)))
587 write_match_code_switch (XEXP (exp
, 0));
588 puts (" return false;\n"
601 fputs (" return ",stdout
);
602 write_predicate_expr (exp
);
603 fputs (";\n", stdout
);
606 /* Given a predicate, write out a complete C function to compute it. */
608 write_one_predicate_function (struct pred_data
*p
)
613 write_predicate_subfunction (p
);
616 /* A normal predicate can legitimately not look at machine_mode
617 if it accepts only CONST_INTs and/or CONST_WIDE_INT and/or CONST_DOUBLEs. */
618 printf ("int\n%s (rtx op, machine_mode mode ATTRIBUTE_UNUSED)\n{\n",
620 write_predicate_stmts (p
->exp
);
621 fputs ("}\n\n", stdout
);
624 /* Constraints fall into two categories: register constraints
625 (define_register_constraint), and others (define_constraint,
626 define_memory_constraint, define_address_constraint). We
627 work out automatically which of the various old-style macros
628 they correspond to, and produce appropriate code. They all
629 go in the same hash table so we can verify that there are no
632 /* All data from one constraint definition. */
633 struct constraint_data
635 struct constraint_data
*next_this_letter
;
636 struct constraint_data
*next_textual
;
638 const char *c_name
; /* same as .name unless mangling is necessary */
640 const char *regclass
; /* for register constraints */
641 rtx exp
; /* for other constraints */
642 unsigned int lineno
; /* line of definition */
643 unsigned int is_register
: 1;
644 unsigned int is_const_int
: 1;
645 unsigned int is_const_dbl
: 1;
646 unsigned int is_extra
: 1;
647 unsigned int is_memory
: 1;
648 unsigned int is_address
: 1;
649 unsigned int maybe_allows_reg
: 1;
650 unsigned int maybe_allows_mem
: 1;
653 /* Overview of all constraints beginning with a given letter. */
655 static struct constraint_data
*
656 constraints_by_letter_table
[1<<CHAR_BIT
];
658 /* For looking up all the constraints in the order that they appeared
659 in the machine description. */
660 static struct constraint_data
*first_constraint
;
661 static struct constraint_data
**last_constraint_ptr
= &first_constraint
;
663 #define FOR_ALL_CONSTRAINTS(iter_) \
664 for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
666 /* Contraint letters that have a special meaning and that cannot be used
667 in define*_constraints. */
668 static const char generic_constraint_letters
[] = "g";
670 /* Machine-independent code expects that constraints with these
671 (initial) letters will allow only (a subset of all) CONST_INTs. */
673 static const char const_int_constraints
[] = "IJKLMNOP";
675 /* Machine-independent code expects that constraints with these
676 (initial) letters will allow only (a subset of all) CONST_DOUBLEs. */
678 static const char const_dbl_constraints
[] = "GH";
680 /* Summary data used to decide whether to output various functions and
681 macro definitions. */
682 static unsigned int constraint_max_namelen
;
683 static bool have_register_constraints
;
684 static bool have_memory_constraints
;
685 static bool have_address_constraints
;
686 static bool have_extra_constraints
;
687 static bool have_const_int_constraints
;
688 static unsigned int num_constraints
;
690 static const constraint_data
**enum_order
;
691 static unsigned int register_start
, register_end
;
692 static unsigned int satisfied_start
;
693 static unsigned int const_int_start
, const_int_end
;
694 static unsigned int memory_start
, memory_end
;
695 static unsigned int address_start
, address_end
;
696 static unsigned int maybe_allows_none_start
, maybe_allows_none_end
;
697 static unsigned int maybe_allows_reg_start
, maybe_allows_reg_end
;
698 static unsigned int maybe_allows_mem_start
, maybe_allows_mem_end
;
700 /* Convert NAME, which contains angle brackets and/or underscores, to
701 a string that can be used as part of a C identifier. The string
702 comes from the rtl_obstack. */
704 mangle (const char *name
)
706 for (; *name
; name
++)
709 case '_': obstack_grow (rtl_obstack
, "__", 2); break;
710 case '<': obstack_grow (rtl_obstack
, "_l", 2); break;
711 case '>': obstack_grow (rtl_obstack
, "_g", 2); break;
712 default: obstack_1grow (rtl_obstack
, *name
); break;
715 obstack_1grow (rtl_obstack
, '\0');
716 return XOBFINISH (rtl_obstack
, const char *);
719 /* Add one constraint, of any sort, to the tables. NAME is its name;
720 REGCLASS is the register class, if any; EXP is the expression to
721 test, if any; IS_MEMORY and IS_ADDRESS indicate memory and address
722 constraints, respectively; LINENO is the line number from the MD reader.
723 Not all combinations of arguments are valid; most importantly, REGCLASS
724 is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only
725 meaningful for constraints with EXP.
727 This function enforces all syntactic and semantic rules about what
728 constraints can be defined. */
731 add_constraint (const char *name
, const char *regclass
,
732 rtx exp
, bool is_memory
, bool is_address
,
735 struct constraint_data
*c
, **iter
, **slot
;
737 bool need_mangled_name
= false;
742 if (strcmp (name
, "TARGET_MEM_CONSTRAINT") == 0)
745 if (exp
&& validate_exp (exp
, name
, lineno
))
748 for (p
= name
; *p
; p
++)
751 if (*p
== '<' || *p
== '>' || *p
== '_')
752 need_mangled_name
= true;
755 error_with_line (lineno
,
756 "constraint name '%s' must be composed of "
757 "letters, digits, underscores, and "
758 "angle brackets", name
);
763 if (strchr (generic_constraint_letters
, name
[0]))
766 error_with_line (lineno
, "constraint letter '%s' cannot be "
767 "redefined by the machine description", name
);
769 error_with_line (lineno
, "constraint name '%s' cannot be defined by "
770 "the machine description, as it begins with '%c'",
776 namelen
= strlen (name
);
777 slot
= &constraints_by_letter_table
[(unsigned int)name
[0]];
778 for (iter
= slot
; *iter
; iter
= &(*iter
)->next_this_letter
)
780 /* This causes slot to end up pointing to the
781 next_this_letter field of the last constraint with a name
782 of equal or greater length than the new constraint; hence
783 the new constraint will be inserted after all previous
784 constraints with names of the same length. */
785 if ((*iter
)->namelen
>= namelen
)
788 if (!strcmp ((*iter
)->name
, name
))
790 error_with_line (lineno
, "redefinition of constraint '%s'", name
);
791 message_with_line ((*iter
)->lineno
, "previous definition is here");
794 else if (!strncmp ((*iter
)->name
, name
, (*iter
)->namelen
))
796 error_with_line (lineno
, "defining constraint '%s' here", name
);
797 message_with_line ((*iter
)->lineno
, "renders constraint '%s' "
798 "(defined here) a prefix", (*iter
)->name
);
801 else if (!strncmp ((*iter
)->name
, name
, namelen
))
803 error_with_line (lineno
, "constraint '%s' is a prefix", name
);
804 message_with_line ((*iter
)->lineno
, "of constraint '%s' "
805 "(defined here)", (*iter
)->name
);
810 is_const_int
= strchr (const_int_constraints
, name
[0]) != 0;
811 is_const_dbl
= strchr (const_dbl_constraints
, name
[0]) != 0;
813 if (is_const_int
|| is_const_dbl
)
815 enum rtx_code appropriate_code
816 = is_const_int
? CONST_INT
: CONST_DOUBLE
;
818 /* Consider relaxing this requirement in the future. */
820 || GET_CODE (exp
) != AND
821 || GET_CODE (XEXP (exp
, 0)) != MATCH_CODE
822 || strcmp (XSTR (XEXP (exp
, 0), 0),
823 GET_RTX_NAME (appropriate_code
)))
826 error_with_line (lineno
, "constraint letter '%c' is reserved "
827 "for %s constraints",
828 name
[0], GET_RTX_NAME (appropriate_code
));
830 error_with_line (lineno
, "constraint names beginning with '%c' "
831 "(%s) are reserved for %s constraints",
832 name
[0], name
, GET_RTX_NAME (appropriate_code
));
839 error_with_line (lineno
, "constraint letter '%c' cannot be a "
840 "memory constraint", name
[0]);
842 error_with_line (lineno
, "constraint name '%s' begins with '%c', "
843 "and therefore cannot be a memory constraint",
850 error_with_line (lineno
, "constraint letter '%c' cannot be a "
851 "memory constraint", name
[0]);
853 error_with_line (lineno
, "constraint name '%s' begins with '%c', "
854 "and therefore cannot be a memory constraint",
861 c
= XOBNEW (rtl_obstack
, struct constraint_data
);
863 c
->c_name
= need_mangled_name
? mangle (name
) : name
;
865 c
->namelen
= namelen
;
866 c
->regclass
= regclass
;
868 c
->is_register
= regclass
!= 0;
869 c
->is_const_int
= is_const_int
;
870 c
->is_const_dbl
= is_const_dbl
;
871 c
->is_extra
= !(regclass
|| is_const_int
|| is_const_dbl
);
872 c
->is_memory
= is_memory
;
873 c
->is_address
= is_address
;
874 c
->maybe_allows_reg
= true;
875 c
->maybe_allows_mem
= true;
878 char codes
[NUM_RTX_CODE
];
879 compute_test_codes (exp
, lineno
, codes
);
880 if (!codes
[REG
] && !codes
[SUBREG
])
881 c
->maybe_allows_reg
= false;
883 c
->maybe_allows_mem
= false;
885 c
->next_this_letter
= *slot
;
888 /* Insert this constraint in the list of all constraints in textual
891 *last_constraint_ptr
= c
;
892 last_constraint_ptr
= &c
->next_textual
;
894 constraint_max_namelen
= MAX (constraint_max_namelen
, strlen (name
));
895 have_register_constraints
|= c
->is_register
;
896 have_const_int_constraints
|= c
->is_const_int
;
897 have_extra_constraints
|= c
->is_extra
;
898 have_memory_constraints
|= c
->is_memory
;
899 have_address_constraints
|= c
->is_address
;
900 num_constraints
+= 1;
903 /* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or
904 DEFINE_ADDRESS_CONSTRAINT expression, C. */
906 process_define_constraint (rtx c
, int lineno
)
908 add_constraint (XSTR (c
, 0), 0, XEXP (c
, 2),
909 GET_CODE (c
) == DEFINE_MEMORY_CONSTRAINT
,
910 GET_CODE (c
) == DEFINE_ADDRESS_CONSTRAINT
,
914 /* Process a DEFINE_REGISTER_CONSTRAINT expression, C. */
916 process_define_register_constraint (rtx c
, int lineno
)
918 add_constraint (XSTR (c
, 0), XSTR (c
, 1), 0, false, false, lineno
);
921 /* Put the constraints into enum order. We want to keep constraints
922 of the same type together so that query functions can be simple
925 choose_enum_order (void)
927 struct constraint_data
*c
;
929 enum_order
= XNEWVEC (const constraint_data
*, num_constraints
);
930 unsigned int next
= 0;
932 register_start
= next
;
933 FOR_ALL_CONSTRAINTS (c
)
935 enum_order
[next
++] = c
;
938 satisfied_start
= next
;
940 const_int_start
= next
;
941 FOR_ALL_CONSTRAINTS (c
)
943 enum_order
[next
++] = c
;
944 const_int_end
= next
;
947 FOR_ALL_CONSTRAINTS (c
)
949 enum_order
[next
++] = c
;
952 address_start
= next
;
953 FOR_ALL_CONSTRAINTS (c
)
955 enum_order
[next
++] = c
;
958 maybe_allows_none_start
= next
;
959 FOR_ALL_CONSTRAINTS (c
)
960 if (!c
->is_register
&& !c
->is_const_int
&& !c
->is_memory
&& !c
->is_address
961 && !c
->maybe_allows_reg
&& !c
->maybe_allows_mem
)
962 enum_order
[next
++] = c
;
963 maybe_allows_none_end
= next
;
965 maybe_allows_reg_start
= next
;
966 FOR_ALL_CONSTRAINTS (c
)
967 if (!c
->is_register
&& !c
->is_const_int
&& !c
->is_memory
&& !c
->is_address
968 && c
->maybe_allows_reg
&& !c
->maybe_allows_mem
)
969 enum_order
[next
++] = c
;
970 maybe_allows_reg_end
= next
;
972 maybe_allows_mem_start
= next
;
973 FOR_ALL_CONSTRAINTS (c
)
974 if (!c
->is_register
&& !c
->is_const_int
&& !c
->is_memory
&& !c
->is_address
975 && !c
->maybe_allows_reg
&& c
->maybe_allows_mem
)
976 enum_order
[next
++] = c
;
977 maybe_allows_mem_end
= next
;
979 FOR_ALL_CONSTRAINTS (c
)
980 if (!c
->is_register
&& !c
->is_const_int
&& !c
->is_memory
&& !c
->is_address
981 && c
->maybe_allows_reg
&& c
->maybe_allows_mem
)
982 enum_order
[next
++] = c
;
983 gcc_assert (next
== num_constraints
);
986 /* Write out an enumeration with one entry per machine-specific
989 write_enum_constraint_num (void)
991 fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout
);
992 fputs ("enum constraint_num\n"
994 " CONSTRAINT__UNKNOWN = 0", stdout
);
995 for (unsigned int i
= 0; i
< num_constraints
; ++i
)
996 printf (",\n CONSTRAINT_%s", enum_order
[i
]->c_name
);
997 puts (",\n CONSTRAINT__LIMIT\n};\n");
1000 /* Write out a function which looks at a string and determines what
1001 constraint name, if any, it begins with. */
1003 write_lookup_constraint_1 (void)
1006 puts ("enum constraint_num\n"
1007 "lookup_constraint_1 (const char *str)\n"
1009 " switch (str[0])\n"
1012 for (i
= 0; i
< ARRAY_SIZE (constraints_by_letter_table
); i
++)
1014 struct constraint_data
*c
= constraints_by_letter_table
[i
];
1018 printf (" case '%c':\n", i
);
1019 if (c
->namelen
== 1)
1020 printf (" return CONSTRAINT_%s;\n", c
->c_name
);
1025 printf (" if (!strncmp (str + 1, \"%s\", %lu))\n"
1026 " return CONSTRAINT_%s;\n",
1027 c
->name
+ 1, (unsigned long int) c
->namelen
- 1,
1029 c
= c
->next_this_letter
;
1036 puts (" default: break;\n"
1038 " return CONSTRAINT__UNKNOWN;\n"
1042 /* Write out an array that maps single-letter characters to their
1043 constraints (if that fits in a character) or 255 if lookup_constraint_1
1046 write_lookup_constraint_array (void)
1049 printf ("const unsigned char lookup_constraint_array[] = {\n ");
1050 for (i
= 0; i
< ARRAY_SIZE (constraints_by_letter_table
); i
++)
1054 struct constraint_data
*c
= constraints_by_letter_table
[i
];
1056 printf ("CONSTRAINT__UNKNOWN");
1057 else if (c
->namelen
== 1)
1058 printf ("MIN ((int) CONSTRAINT_%s, (int) UCHAR_MAX)", c
->c_name
);
1060 printf ("UCHAR_MAX");
1062 printf ("\n};\n\n");
1065 /* Write out a function which looks at a string and determines what
1066 the constraint name length is. */
1068 write_insn_constraint_len (void)
1072 puts ("static inline size_t\n"
1073 "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n"
1078 for (i
= 0; i
< ARRAY_SIZE (constraints_by_letter_table
); i
++)
1080 struct constraint_data
*c
= constraints_by_letter_table
[i
];
1086 /* Constraints with multiple characters should have the same
1089 struct constraint_data
*c2
= c
->next_this_letter
;
1090 size_t len
= c
->namelen
;
1093 if (c2
->namelen
!= len
)
1094 error ("Multi-letter constraints with first letter '%c' "
1095 "should have same length", i
);
1096 c2
= c2
->next_this_letter
;
1100 printf (" case '%c': return %lu;\n",
1101 i
, (unsigned long int) c
->namelen
);
1104 puts (" default: break;\n"
1110 /* Write out the function which computes the register class corresponding
1111 to a register constraint. */
1113 write_reg_class_for_constraint_1 (void)
1115 struct constraint_data
*c
;
1117 puts ("enum reg_class\n"
1118 "reg_class_for_constraint_1 (enum constraint_num c)\n"
1123 FOR_ALL_CONSTRAINTS (c
)
1125 printf (" case CONSTRAINT_%s: return %s;\n", c
->c_name
, c
->regclass
);
1127 puts (" default: break;\n"
1129 " return NO_REGS;\n"
1133 /* Write out the functions which compute whether a given value matches
1134 a given non-register constraint. */
1136 write_tm_constrs_h (void)
1138 struct constraint_data
*c
;
1141 /* Generated automatically by the program '%s'\n\
1142 from the machine description file '%s'. */\n\n", progname
, in_fname
);
1145 #ifndef GCC_TM_CONSTRS_H\n\
1146 #define GCC_TM_CONSTRS_H\n");
1148 FOR_ALL_CONSTRAINTS (c
)
1149 if (!c
->is_register
)
1151 bool needs_ival
= needs_variable (c
->exp
, "ival");
1152 bool needs_hval
= needs_variable (c
->exp
, "hval");
1153 bool needs_lval
= needs_variable (c
->exp
, "lval");
1154 bool needs_rval
= needs_variable (c
->exp
, "rval");
1155 bool needs_mode
= (needs_variable (c
->exp
, "mode")
1156 || needs_hval
|| needs_lval
|| needs_rval
);
1157 bool needs_op
= (needs_variable (c
->exp
, "op")
1158 || needs_ival
|| needs_mode
);
1160 printf ("static inline bool\n"
1161 "satisfies_constraint_%s (rtx %s)\n"
1163 needs_op
? "op" : "ARG_UNUSED (op)");
1165 puts (" machine_mode mode = GET_MODE (op);");
1167 puts (" HOST_WIDE_INT ival = 0;");
1169 puts (" HOST_WIDE_INT hval = 0;");
1171 puts (" unsigned HOST_WIDE_INT lval = 0;");
1173 puts (" const REAL_VALUE_TYPE *rval = 0;");
1176 puts (" if (CONST_INT_P (op))\n"
1177 " ival = INTVAL (op);");
1178 #if TARGET_SUPPORTS_WIDE_INT
1179 if (needs_lval
|| needs_hval
)
1180 error ("you can't use lval or hval");
1183 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1184 " hval = CONST_DOUBLE_HIGH (op);");
1186 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1187 " lval = CONST_DOUBLE_LOW (op);");
1190 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
1191 " rval = CONST_DOUBLE_REAL_VALUE (op);");
1193 write_predicate_stmts (c
->exp
);
1194 fputs ("}\n", stdout
);
1196 puts ("#endif /* tm-constrs.h */");
1199 /* Write out the wrapper function, constraint_satisfied_p, that maps
1200 a CONSTRAINT_xxx constant to one of the predicate functions generated
1203 write_constraint_satisfied_p_array (void)
1205 if (satisfied_start
== num_constraints
)
1208 printf ("bool (*constraint_satisfied_p_array[]) (rtx) = {\n ");
1209 for (unsigned int i
= satisfied_start
; i
< num_constraints
; ++i
)
1211 if (i
!= satisfied_start
)
1213 printf ("satisfies_constraint_%s", enum_order
[i
]->c_name
);
1215 printf ("\n};\n\n");
1218 /* Write out the function which computes whether a given value matches
1219 a given CONST_INT constraint. This doesn't just forward to
1220 constraint_satisfied_p because caller passes the INTVAL, not the RTX. */
1222 write_insn_const_int_ok_for_constraint (void)
1224 struct constraint_data
*c
;
1227 "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1228 "enum constraint_num c)\n"
1233 FOR_ALL_CONSTRAINTS (c
)
1234 if (c
->is_const_int
)
1236 printf (" case CONSTRAINT_%s:\n return ", c
->c_name
);
1237 /* c->exp is guaranteed to be (and (match_code "const_int") (...));
1238 we know at this point that we have a const_int, so we need not
1239 bother with that part of the test. */
1240 write_predicate_expr (XEXP (c
->exp
, 1));
1241 fputs (";\n\n", stdout
);
1244 puts (" default: break;\n"
1250 /* Write a definition for a function NAME that returns true if a given
1251 constraint_num is in the range [START, END). */
1253 write_range_function (const char *name
, unsigned int start
, unsigned int end
)
1255 printf ("static inline bool\n");
1257 printf ("%s (enum constraint_num c)\n"
1259 " return c >= CONSTRAINT_%s && c <= CONSTRAINT_%s;\n"
1261 name
, enum_order
[start
]->c_name
, enum_order
[end
- 1]->c_name
);
1263 printf ("%s (enum constraint_num)\n"
1269 /* Write a definition for insn_extra_constraint_allows_reg_mem function. */
1271 write_allows_reg_mem_function (void)
1273 printf ("static inline void\n"
1274 "insn_extra_constraint_allows_reg_mem (enum constraint_num c,\n"
1275 "\t\t\t\t bool *allows_reg, bool *allows_mem)\n"
1277 if (maybe_allows_none_start
!= maybe_allows_none_end
)
1278 printf (" if (c >= CONSTRAINT_%s && c <= CONSTRAINT_%s)\n"
1280 enum_order
[maybe_allows_none_start
]->c_name
,
1281 enum_order
[maybe_allows_none_end
- 1]->c_name
);
1282 if (maybe_allows_reg_start
!= maybe_allows_reg_end
)
1283 printf (" if (c >= CONSTRAINT_%s && c <= CONSTRAINT_%s)\n"
1285 " *allows_reg = true;\n"
1288 enum_order
[maybe_allows_reg_start
]->c_name
,
1289 enum_order
[maybe_allows_reg_end
- 1]->c_name
);
1290 if (maybe_allows_mem_start
!= maybe_allows_mem_end
)
1291 printf (" if (c >= CONSTRAINT_%s && c <= CONSTRAINT_%s)\n"
1293 " *allows_mem = true;\n"
1296 enum_order
[maybe_allows_mem_start
]->c_name
,
1297 enum_order
[maybe_allows_mem_end
- 1]->c_name
);
1298 printf (" (void) c;\n"
1299 " *allows_reg = true;\n"
1300 " *allows_mem = true;\n"
1304 /* VEC is a list of key/value pairs, with the keys being lower bounds
1305 of a range. Output a decision tree that handles the keys covered by
1306 [VEC[START], VEC[END]), returning FALLBACK for keys lower then VEC[START]'s.
1307 INDENT is the number of spaces to indent the code. */
1309 print_type_tree (const vec
<std::pair
<unsigned int, const char *> > &vec
,
1310 unsigned int start
, unsigned int end
, const char *fallback
,
1311 unsigned int indent
)
1315 unsigned int mid
= (start
+ end
) / 2;
1316 printf ("%*sif (c >= CONSTRAINT_%s)\n",
1317 indent
, "", enum_order
[vec
[mid
].first
]->c_name
);
1319 print_type_tree (vec
, mid
+ 1, end
, vec
[mid
].second
, indent
+ 2);
1322 printf ("%*s{\n", indent
+ 2, "");
1323 print_type_tree (vec
, mid
+ 1, end
, vec
[mid
].second
, indent
+ 4);
1324 printf ("%*s}\n", indent
+ 2, "");
1328 printf ("%*sreturn %s;\n", indent
, "", fallback
);
1331 /* Write tm-preds.h. Unfortunately, it is impossible to forward-declare
1332 an enumeration in portable C, so we have to condition all these
1333 prototypes on HAVE_MACHINE_MODES. */
1335 write_tm_preds_h (void)
1337 struct pred_data
*p
;
1340 /* Generated automatically by the program '%s'\n\
1341 from the machine description file '%s'. */\n\n", progname
, in_fname
);
1344 #ifndef GCC_TM_PREDS_H\n\
1345 #define GCC_TM_PREDS_H\n\
1347 #ifdef HAVE_MACHINE_MODES");
1349 FOR_ALL_PREDICATES (p
)
1350 printf ("extern int %s (rtx, machine_mode);\n", p
->name
);
1352 puts ("#endif /* HAVE_MACHINE_MODES */\n");
1354 if (constraint_max_namelen
> 0)
1356 write_enum_constraint_num ();
1357 puts ("extern enum constraint_num lookup_constraint_1 (const char *);\n"
1358 "extern const unsigned char lookup_constraint_array[];\n"
1360 "/* Return the constraint at the beginning of P, or"
1361 " CONSTRAINT__UNKNOWN if it\n"
1362 " isn't recognized. */\n"
1364 "static inline enum constraint_num\n"
1365 "lookup_constraint (const char *p)\n"
1367 " unsigned int index = lookup_constraint_array"
1368 "[(unsigned char) *p];\n"
1369 " return (index == UCHAR_MAX\n"
1370 " ? lookup_constraint_1 (p)\n"
1371 " : (enum constraint_num) index);\n"
1373 if (satisfied_start
== num_constraints
)
1374 puts ("/* Return true if X satisfies constraint C. */\n"
1376 "static inline bool\n"
1377 "constraint_satisfied_p (rtx, enum constraint_num)\n"
1382 printf ("extern bool (*constraint_satisfied_p_array[]) (rtx);\n"
1384 "/* Return true if X satisfies constraint C. */\n"
1386 "static inline bool\n"
1387 "constraint_satisfied_p (rtx x, enum constraint_num c)\n"
1389 " int i = (int) c - (int) CONSTRAINT_%s;\n"
1390 " return i >= 0 && constraint_satisfied_p_array[i] (x);\n"
1393 enum_order
[satisfied_start
]->name
);
1395 write_range_function ("insn_extra_register_constraint",
1396 register_start
, register_end
);
1397 write_range_function ("insn_extra_memory_constraint",
1398 memory_start
, memory_end
);
1399 write_range_function ("insn_extra_address_constraint",
1400 address_start
, address_end
);
1401 write_allows_reg_mem_function ();
1403 if (constraint_max_namelen
> 1)
1405 write_insn_constraint_len ();
1406 puts ("#define CONSTRAINT_LEN(c_,s_) "
1407 "insn_constraint_len (c_,s_)\n");
1410 puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1411 if (have_register_constraints
)
1412 puts ("extern enum reg_class reg_class_for_constraint_1 "
1413 "(enum constraint_num);\n"
1415 "static inline enum reg_class\n"
1416 "reg_class_for_constraint (enum constraint_num c)\n"
1418 " if (insn_extra_register_constraint (c))\n"
1419 " return reg_class_for_constraint_1 (c);\n"
1420 " return NO_REGS;\n"
1423 puts ("static inline enum reg_class\n"
1424 "reg_class_for_constraint (enum constraint_num)\n"
1426 " return NO_REGS;\n"
1428 if (have_const_int_constraints
)
1429 puts ("extern bool insn_const_int_ok_for_constraint "
1430 "(HOST_WIDE_INT, enum constraint_num);\n"
1431 "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1432 " insn_const_int_ok_for_constraint (v_, "
1433 "lookup_constraint (s_))\n");
1435 puts ("static inline bool\n"
1436 "insn_const_int_ok_for_constraint (HOST_WIDE_INT,"
1437 " enum constraint_num)\n"
1442 puts ("enum constraint_type\n"
1451 "static inline enum constraint_type\n"
1452 "get_constraint_type (enum constraint_num c)\n"
1454 auto_vec
<std::pair
<unsigned int, const char *>, 4> values
;
1455 if (const_int_start
!= const_int_end
)
1456 values
.safe_push (std::make_pair (const_int_start
, "CT_CONST_INT"));
1457 if (memory_start
!= memory_end
)
1458 values
.safe_push (std::make_pair (memory_start
, "CT_MEMORY"));
1459 if (address_start
!= address_end
)
1460 values
.safe_push (std::make_pair (address_start
, "CT_ADDRESS"));
1461 if (address_end
!= num_constraints
)
1462 values
.safe_push (std::make_pair (address_end
, "CT_FIXED_FORM"));
1463 print_type_tree (values
, 0, values
.length (), "CT_REGISTER", 2);
1467 puts ("#endif /* tm-preds.h */");
1470 /* Write insn-preds.c.
1471 N.B. the list of headers to include was copied from genrecog; it
1474 FUTURE: Write #line markers referring back to the machine
1475 description. (Can't practically do this now since we don't know
1476 the line number of the C block - just the line number of the enclosing
1479 write_insn_preds_c (void)
1481 struct pred_data
*p
;
1484 /* Generated automatically by the program '%s'\n\
1485 from the machine description file '%s'. */\n\n", progname
, in_fname
);
1488 #include \"config.h\"\n\
1489 #include \"system.h\"\n\
1490 #include \"coretypes.h\"\n\
1491 #include \"tm.h\"\n\
1492 #include \"rtl.h\"\n\
1493 #include \"hash-set.h\"\n\
1494 #include \"machmode.h\"\n\
1495 #include \"hash-map.h\"\n\
1496 #include \"vec.h\"\n\
1497 #include \"double-int.h\"\n\
1498 #include \"input.h\"\n\
1499 #include \"alias.h\"\n\
1500 #include \"symtab.h\"\n\
1501 #include \"wide-int.h\"\n\
1502 #include \"inchash.h\"\n\
1503 #include \"tree.h\"\n\
1504 #include \"varasm.h\"\n\
1505 #include \"stor-layout.h\"\n\
1506 #include \"calls.h\"\n\
1507 #include \"tm_p.h\"\n\
1508 #include \"hashtab.h\"\n\
1509 #include \"hash-set.h\"\n\
1510 #include \"vec.h\"\n\
1511 #include \"machmode.h\"\n\
1512 #include \"hard-reg-set.h\"\n\
1513 #include \"input.h\"\n\
1514 #include \"function.h\"\n\
1515 #include \"insn-config.h\"\n\
1516 #include \"recog.h\"\n\
1517 #include \"output.h\"\n\
1518 #include \"flags.h\"\n\
1519 #include \"hard-reg-set.h\"\n\
1520 #include \"predict.h\"\n\
1521 #include \"basic-block.h\"\n\
1522 #include \"resource.h\"\n\
1523 #include \"diagnostic-core.h\"\n\
1524 #include \"reload.h\"\n\
1525 #include \"regs.h\"\n\
1526 #include \"tm-constrs.h\"\n");
1528 FOR_ALL_PREDICATES (p
)
1529 write_one_predicate_function (p
);
1531 if (constraint_max_namelen
> 0)
1533 write_lookup_constraint_1 ();
1534 write_lookup_constraint_array ();
1535 if (have_register_constraints
)
1536 write_reg_class_for_constraint_1 ();
1537 write_constraint_satisfied_p_array ();
1539 if (have_const_int_constraints
)
1540 write_insn_const_int_ok_for_constraint ();
1544 /* Argument parsing. */
1545 static bool gen_header
;
1546 static bool gen_constrs
;
1549 parse_option (const char *opt
)
1551 if (!strcmp (opt
, "-h"))
1556 else if (!strcmp (opt
, "-c"))
1565 /* Master control. */
1567 main (int argc
, char **argv
)
1570 int pattern_lineno
, next_insn_code
= 0;
1574 fatal ("no input file name");
1575 if (!init_rtx_reader_args_cb (argc
, argv
, parse_option
))
1576 return FATAL_EXIT_CODE
;
1578 while ((defn
= read_md_rtx (&pattern_lineno
, &next_insn_code
)) != 0)
1579 switch (GET_CODE (defn
))
1581 case DEFINE_PREDICATE
:
1582 case DEFINE_SPECIAL_PREDICATE
:
1583 process_define_predicate (defn
, pattern_lineno
);
1586 case DEFINE_CONSTRAINT
:
1587 case DEFINE_MEMORY_CONSTRAINT
:
1588 case DEFINE_ADDRESS_CONSTRAINT
:
1589 process_define_constraint (defn
, pattern_lineno
);
1592 case DEFINE_REGISTER_CONSTRAINT
:
1593 process_define_register_constraint (defn
, pattern_lineno
);
1600 choose_enum_order ();
1603 write_tm_preds_h ();
1604 else if (gen_constrs
)
1605 write_tm_constrs_h ();
1607 write_insn_preds_c ();
1609 if (have_error
|| ferror (stdout
) || fflush (stdout
) || fclose (stdout
))
1610 return FATAL_EXIT_CODE
;
1612 return SUCCESS_EXIT_CODE
;