Mercurial > hg > CbC > CbC_gcc

annotate gcc/config/avr/predicates.md @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents 77e2b8dfacca
children 84e7813d76e9
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1 ;; Predicate definitions for ATMEL AVR micro controllers.
111
kono
parents: 55
diff changeset
2 ;; Copyright (C) 2006-2017 Free Software Foundation, Inc.
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
3 ;;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
4 ;; This file is part of GCC.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
5 ;;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
6 ;; GCC is free software; you can redistribute it and/or modify
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
7 ;; it under the terms of the GNU General Public License as published by
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
8 ;; the Free Software Foundation; either version 3, or (at your option)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
9 ;; any later version.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
10 ;;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
11 ;; GCC is distributed in the hope that it will be useful,
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
12 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
13 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
14 ;; GNU General Public License for more details.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
15 ;;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
16 ;; You should have received a copy of the GNU General Public License
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
17 ;; along with GCC; see the file COPYING3. If not see
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
18 ;; <http://www.gnu.org/licenses/>.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
19
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
20 ;; Registers from r0 to r15.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
21 (define_predicate "l_register_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
22 (and (match_code "reg")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
23 (match_test "REGNO (op) <= 15")))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
24
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
25 ;; Registers from r16 to r31.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
26 (define_predicate "d_register_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
27 (and (match_code "reg")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
28 (match_test "REGNO (op) >= 16 && REGNO (op) <= 31")))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
29
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
30 (define_predicate "even_register_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
31 (and (match_code "reg")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
32 (and (match_test "REGNO (op) <= 31")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
33 (match_test "(REGNO (op) & 1) == 0"))))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
34
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
35 (define_predicate "odd_register_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
36 (and (match_code "reg")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
37 (and (match_test "REGNO (op) <= 31")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
38 (match_test "(REGNO (op) & 1) != 0"))))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
39
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
40 ;; SP register.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
41 (define_predicate "stack_register_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
42 (and (match_code "reg")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
43 (match_test "REGNO (op) == REG_SP")))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
44
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
45 ;; Return true if OP is a valid address for lower half of I/O space.
111
kono
parents: 55
diff changeset
46 (define_special_predicate "low_io_address_operand"
kono
parents: 55
diff changeset
47 (ior (and (match_code "const_int")
kono
parents: 55
diff changeset
48 (match_test "IN_RANGE (INTVAL (op) - avr_arch->sfr_offset,
kono
parents: 55
diff changeset
49 0, 0x1F)"))
kono
parents: 55
diff changeset
50 (and (match_code "symbol_ref")
kono
parents: 55
diff changeset
51 (match_test "SYMBOL_REF_FLAGS (op) & SYMBOL_FLAG_IO_LOW"))))
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
52
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
53 ;; Return true if OP is a valid address for high half of I/O space.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
54 (define_predicate "high_io_address_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
55 (and (match_code "const_int")
111
kono
parents: 55
diff changeset
56 (match_test "IN_RANGE (INTVAL (op) - avr_arch->sfr_offset,
kono
parents: 55
diff changeset
57 0x20, 0x3F)")))
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
58
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
59 ;; Return true if OP is a valid address of I/O space.
111
kono
parents: 55
diff changeset
60 (define_special_predicate "io_address_operand"
kono
parents: 55
diff changeset
61 (ior (and (match_code "const_int")
kono
parents: 55
diff changeset
62 (match_test "IN_RANGE (INTVAL (op) - avr_arch->sfr_offset,
kono
parents: 55
diff changeset
63 0, 0x3F)"))
kono
parents: 55
diff changeset
64 (and (match_code "symbol_ref")
kono
parents: 55
diff changeset
65 (match_test "SYMBOL_REF_FLAGS (op) & SYMBOL_FLAG_IO"))))
kono
parents: 55
diff changeset
66
kono
parents: 55
diff changeset
67 ;; Return 1 if OP is a general operand not in flash memory
kono
parents: 55
diff changeset
68 (define_predicate "nop_general_operand"
kono
parents: 55
diff changeset
69 (and (match_operand 0 "general_operand")
kono
parents: 55
diff changeset
70 (match_test "!avr_mem_flash_p (op)")))
kono
parents: 55
diff changeset
71
kono
parents: 55
diff changeset
72 ;; Return 1 if OP is an "ordinary" general operand, i.e. a general
kono
parents: 55
diff changeset
73 ;; operand whose load is not handled by a libgcc call or ELPM.
kono
parents: 55
diff changeset
74 (define_predicate "nox_general_operand"
kono
parents: 55
diff changeset
75 (and (match_operand 0 "general_operand")
kono
parents: 55
diff changeset
76 (not (match_test "avr_load_libgcc_p (op)"))
kono
parents: 55
diff changeset
77 (not (match_test "avr_mem_memx_p (op)"))))
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
78
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
79 ;; Return 1 if OP is the zero constant for MODE.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
80 (define_predicate "const0_operand"
111
kono
parents: 55
diff changeset
81 (and (match_code "const_int,const_fixed,const_double")
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
82 (match_test "op == CONST0_RTX (mode)")))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
83
111
kono
parents: 55
diff changeset
84 ;; Return 1 if OP is the one constant integer for MODE.
kono
parents: 55
diff changeset
85 (define_predicate "const1_operand"
kono
parents: 55
diff changeset
86 (and (match_code "const_int")
kono
parents: 55
diff changeset
87 (match_test "op == CONST1_RTX (mode)")))
kono
parents: 55
diff changeset
88
kono
parents: 55
diff changeset
89
kono
parents: 55
diff changeset
90 ;; Return 1 if OP is constant integer 0..7 for MODE.
kono
parents: 55
diff changeset
91 (define_predicate "const_0_to_7_operand"
kono
parents: 55
diff changeset
92 (and (match_code "const_int")
kono
parents: 55
diff changeset
93 (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
kono
parents: 55
diff changeset
94
kono
parents: 55
diff changeset
95 ;; Return 1 if OP is constant integer 2..7 for MODE.
kono
parents: 55
diff changeset
96 (define_predicate "const_2_to_7_operand"
kono
parents: 55
diff changeset
97 (and (match_code "const_int")
kono
parents: 55
diff changeset
98 (match_test "IN_RANGE (INTVAL (op), 2, 7)")))
kono
parents: 55
diff changeset
99
kono
parents: 55
diff changeset
100 ;; Return 1 if OP is constant integer 1..6 for MODE.
kono
parents: 55
diff changeset
101 (define_predicate "const_1_to_6_operand"
kono
parents: 55
diff changeset
102 (and (match_code "const_int")
kono
parents: 55
diff changeset
103 (match_test "IN_RANGE (INTVAL (op), 1, 6)")))
kono
parents: 55
diff changeset
104
kono
parents: 55
diff changeset
105 ;; Return 1 if OP is constant integer 2..6 for MODE.
kono
parents: 55
diff changeset
106 (define_predicate "const_2_to_6_operand"
kono
parents: 55
diff changeset
107 (and (match_code "const_int")
kono
parents: 55
diff changeset
108 (match_test "IN_RANGE (INTVAL (op), 2, 6)")))
kono
parents: 55
diff changeset
109
kono
parents: 55
diff changeset
110 ;; Return 1 if OP is constant integer -255..-1.
kono
parents: 55
diff changeset
111 (define_predicate "const_m255_to_m1_operand"
kono
parents: 55
diff changeset
112 (and (match_code "const_int")
kono
parents: 55
diff changeset
113 (match_test "IN_RANGE (INTVAL (op), -255, -1)")))
kono
parents: 55
diff changeset
114
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
115 ;; Returns true if OP is either the constant zero or a register.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
116 (define_predicate "reg_or_0_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
117 (ior (match_operand 0 "register_operand")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
118 (match_operand 0 "const0_operand")))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
119
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
120 ;; Returns 1 if OP is a SYMBOL_REF.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
121 (define_predicate "symbol_ref_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
122 (match_code "symbol_ref"))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
123
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
124 ;; Return true if OP is a text segment reference.
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
125 ;; This is needed for program memory address expressions.
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
126 (define_predicate "text_segment_operand"
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
127 (match_code "code_label,label_ref,symbol_ref,plus,const")
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
128 {
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
129 switch (GET_CODE (op))
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
130 {
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
131 case CODE_LABEL:
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
132 return true;
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
133 case LABEL_REF :
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
134 return true;
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
135 case SYMBOL_REF :
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
136 return SYMBOL_REF_FUNCTION_P (op);
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
137 case PLUS :
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
138 /* Assume canonical format of symbol + constant.
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
139 Fall through. */
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
140 case CONST :
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
141 return text_segment_operand (XEXP (op, 0), VOIDmode);
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
142 default :
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
143 return false;
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
144 }
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
145 })
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
146
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
147 ;; Return true if OP is a constant that contains only one 1 in its
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
148 ;; binary representation.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
149 (define_predicate "single_one_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
150 (and (match_code "const_int")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
151 (match_test "exact_log2(INTVAL (op) & GET_MODE_MASK (mode)) >= 0")))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
152
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
153 ;; Return true if OP is a constant that contains only one 0 in its
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
154 ;; binary representation.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
155 (define_predicate "single_zero_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
156 (and (match_code "const_int")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
157 (match_test "exact_log2(~INTVAL (op) & GET_MODE_MASK (mode)) >= 0")))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
158
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
159 ;;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
160 (define_predicate "avr_sp_immediate_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
161 (and (match_code "const_int")
111
kono
parents: 55
diff changeset
162 (match_test "satisfies_constraint_Csp (op)")))
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
163
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
164 ;; True for EQ & NE
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
165 (define_predicate "eqne_operator"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
166 (match_code "eq,ne"))
111
kono
parents: 55
diff changeset
167
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
168 ;; True for GE & LT
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
169 (define_predicate "gelt_operator"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
170 (match_code "ge,lt"))
111
kono
parents: 55
diff changeset
171
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
172 ;; True for GT, GTU, LE & LEU
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
173 (define_predicate "difficult_comparison_operator"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
174 (match_code "gt,gtu,le,leu"))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
175
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
176 ;; False for GT, GTU, LE & LEU
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
177 (define_predicate "simple_comparison_operator"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
178 (and (match_operand 0 "comparison_operator")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
179 (not (match_code "gt,gtu,le,leu"))))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
180
111
kono
parents: 55
diff changeset
181 ;; True for SIGN_EXTEND, ZERO_EXTEND.
kono
parents: 55
diff changeset
182 (define_predicate "extend_operator"
kono
parents: 55
diff changeset
183 (match_code "sign_extend,zero_extend"))
kono
parents: 55
diff changeset
184
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
185 ;; Return true if OP is a valid call operand.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
186 (define_predicate "call_insn_operand"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
187 (and (match_code "mem")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
188 (ior (match_test "register_operand (XEXP (op, 0), mode)")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
189 (match_test "CONSTANT_ADDRESS_P (XEXP (op, 0))"))))
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
190
111
kono
parents: 55
diff changeset
191 ;; For some insns we must ensure that no hard register is inserted
kono
parents: 55
diff changeset
192 ;; into their operands because the insns are split and the split
kono
parents: 55
diff changeset
193 ;; involves hard registers. An example are divmod insn that are
kono
parents: 55
diff changeset
194 ;; split to insns that represent implicit library calls.
kono
parents: 55
diff changeset
195
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
196 ;; True for register that is pseudo register.
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
197 (define_predicate "pseudo_register_operand"
111
kono
parents: 55
diff changeset
198 (and (match_operand 0 "register_operand")
kono
parents: 55
diff changeset
199 (not (and (match_code "reg")
kono
parents: 55
diff changeset
200 (match_test "HARD_REGISTER_P (op)")))))
kono
parents: 55
diff changeset
201
kono
parents: 55
diff changeset
202 ;; True for operand that is pseudo register or CONST_INT.
kono
parents: 55
diff changeset
203 (define_predicate "pseudo_register_or_const_int_operand"
kono
parents: 55
diff changeset
204 (ior (match_operand 0 "const_int_operand")
kono
parents: 55
diff changeset
205 (match_operand 0 "pseudo_register_operand")))
kono
parents: 55
diff changeset
206
kono
parents: 55
diff changeset
207 ;; We keep combiner from inserting hard registers into the input of sign- and
kono
parents: 55
diff changeset
208 ;; zero-extends. A hard register in the input operand is not wanted because
kono
parents: 55
diff changeset
209 ;; 32-bit multiply patterns clobber some hard registers and extends with a
kono
parents: 55
diff changeset
210 ;; hard register that overlaps these clobbers won't combine to a widening
kono
parents: 55
diff changeset
211 ;; multiplication. There is no need for combine to propagate or insert
kono
parents: 55
diff changeset
212 ;; hard registers, register allocation can do it just as well.
kono
parents: 55
diff changeset
213
kono
parents: 55
diff changeset
214 ;; True for operand that is pseudo register at combine time.
kono
parents: 55
diff changeset
215 (define_predicate "combine_pseudo_register_operand"
kono
parents: 55
diff changeset
216 (ior (match_operand 0 "pseudo_register_operand")
kono
parents: 55
diff changeset
217 (and (match_operand 0 "register_operand")
kono
parents: 55
diff changeset
218 (match_test "reload_completed || reload_in_progress"))))
kono
parents: 55
diff changeset
219
kono
parents: 55
diff changeset
220 ;; Return true if OP is a constant integer that is either
kono
parents: 55
diff changeset
221 ;; 8 or 16 or 24.
kono
parents: 55
diff changeset
222 (define_predicate "const_8_16_24_operand"
kono
parents: 55
diff changeset
223 (and (match_code "const_int")
kono
parents: 55
diff changeset
224 (match_test "8 == INTVAL(op) || 16 == INTVAL(op) || 24 == INTVAL(op)")))
kono
parents: 55
diff changeset
225
kono
parents: 55
diff changeset
226 ;; Unsigned CONST_INT that fits in 8 bits, i.e. 0..255.
kono
parents: 55
diff changeset
227 (define_predicate "u8_operand"
kono
parents: 55
diff changeset
228 (and (match_code "const_int")
kono
parents: 55
diff changeset
229 (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
kono
parents: 55
diff changeset
230
kono
parents: 55
diff changeset
231 ;; Signed CONST_INT that fits in 8 bits, i.e. -128..127.
kono
parents: 55
diff changeset
232 (define_predicate "s8_operand"
kono
parents: 55
diff changeset
233 (and (match_code "const_int")
kono
parents: 55
diff changeset
234 (match_test "IN_RANGE (INTVAL (op), -128, 127)")))
kono
parents: 55
diff changeset
235
kono
parents: 55
diff changeset
236 ;; One-extended CONST_INT that fits in 8 bits, i.e. -256..-1.
kono
parents: 55
diff changeset
237 (define_predicate "o8_operand"
kono
parents: 55
diff changeset
238 (and (match_code "const_int")
kono
parents: 55
diff changeset
239 (match_test "IN_RANGE (INTVAL (op), -256, -1)")))
kono
parents: 55
diff changeset
240
kono
parents: 55
diff changeset
241 ;; Signed CONST_INT that fits in 9 bits, i.e. -256..255.
kono
parents: 55
diff changeset
242 (define_predicate "s9_operand"
kono
parents: 55
diff changeset
243 (and (match_code "const_int")
kono
parents: 55
diff changeset
244 (match_test "IN_RANGE (INTVAL (op), -256, 255)")))
kono
parents: 55
diff changeset
245
kono
parents: 55
diff changeset
246 (define_predicate "register_or_s9_operand"
kono
parents: 55
diff changeset
247 (ior (match_operand 0 "register_operand")
kono
parents: 55
diff changeset
248 (match_operand 0 "s9_operand")))
kono
parents: 55
diff changeset
249
kono
parents: 55
diff changeset
250 ;; Unsigned CONST_INT that fits in 16 bits, i.e. 0..65536.
kono
parents: 55
diff changeset
251 (define_predicate "u16_operand"
kono
parents: 55
diff changeset
252 (and (match_code "const_int")
kono
parents: 55
diff changeset
253 (match_test "IN_RANGE (INTVAL (op), 0, (1<<16)-1)")))
kono
parents: 55
diff changeset
254
kono
parents: 55
diff changeset
255 ;; Signed CONST_INT that fits in 16 bits, i.e. -32768..32767.
kono
parents: 55
diff changeset
256 (define_predicate "s16_operand"
kono
parents: 55
diff changeset
257 (and (match_code "const_int")
kono
parents: 55
diff changeset
258 (match_test "IN_RANGE (INTVAL (op), -(1<<15), (1<<15)-1)")))
kono
parents: 55
diff changeset
259
kono
parents: 55
diff changeset
260 ;; One-extended CONST_INT that fits in 16 bits, i.e. -65536..-1.
kono
parents: 55
diff changeset
261 (define_predicate "o16_operand"
kono
parents: 55
diff changeset
262 (and (match_code "const_int")
kono
parents: 55
diff changeset
263 (match_test "IN_RANGE (INTVAL (op), -(1<<16), -1)")))
kono
parents: 55
diff changeset
264
kono
parents: 55
diff changeset
265 ;; Const int, fixed, or double operand
kono
parents: 55
diff changeset
266 (define_predicate "const_operand"
kono
parents: 55
diff changeset
267 (ior (match_code "const_fixed")
kono
parents: 55
diff changeset
268 (match_code "const_double")
kono
parents: 55
diff changeset
269 (match_operand 0 "const_int_operand")))
kono
parents: 55
diff changeset
270
kono
parents: 55
diff changeset
271 ;; Const int, const fixed, or const double operand
kono
parents: 55
diff changeset
272 (define_predicate "nonmemory_or_const_operand"
kono
parents: 55
diff changeset
273 (ior (match_code "const_fixed")
kono
parents: 55
diff changeset
274 (match_code "const_double")
kono
parents: 55
diff changeset
275 (match_operand 0 "nonmemory_operand")))
kono
parents: 55
diff changeset
276
kono
parents: 55
diff changeset
277 ;; Immediate, const fixed, or const double operand
kono
parents: 55
diff changeset
278 (define_predicate "const_or_immediate_operand"
kono
parents: 55
diff changeset
279 (ior (match_code "const_fixed")
kono
parents: 55
diff changeset
280 (match_code "const_double")
kono
parents: 55
diff changeset
281 (match_operand 0 "immediate_operand")))