]>
Commit | Line | Data |
---|---|---|
41b6a5e2 | 1 | ;; Predicate definitions for Motorola 68000. |
99dee823 | 2 | ;; Copyright (C) 2005-2021 Free Software Foundation, Inc. |
41b6a5e2 KH |
3 | ;; |
4 | ;; This file is part of GCC. | |
5 | ;; | |
6 | ;; GCC is free software; you can redistribute it and/or modify | |
7 | ;; it under the terms of the GNU General Public License as published by | |
2f83c7d6 | 8 | ;; the Free Software Foundation; either version 3, or (at your option) |
41b6a5e2 KH |
9 | ;; any later version. |
10 | ;; | |
11 | ;; GCC is distributed in the hope that it will be useful, | |
12 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | ;; GNU General Public License for more details. | |
15 | ;; | |
16 | ;; You should have received a copy of the GNU General Public License | |
2f83c7d6 NC |
17 | ;; along with GCC; see the file COPYING3. If not see |
18 | ;; <http://www.gnu.org/licenses/>. | |
41b6a5e2 KH |
19 | |
20 | ;; Special case of a general operand that's used as a source | |
21 | ;; operand. Use this to permit reads from PC-relative memory when | |
22 | ;; -mpcrel is specified. | |
23 | ||
24 | (define_predicate "general_src_operand" | |
25 | (match_code "const_int,const_double,const,symbol_ref,label_ref,subreg,reg,mem") | |
26 | { | |
27 | if (TARGET_PCREL | |
28 | && GET_CODE (op) == MEM | |
29 | && (GET_CODE (XEXP (op, 0)) == SYMBOL_REF | |
30 | || GET_CODE (XEXP (op, 0)) == LABEL_REF | |
31 | || GET_CODE (XEXP (op, 0)) == CONST)) | |
32 | return 1; | |
33 | return general_operand (op, mode); | |
34 | }) | |
35 | ||
36 | ;; Special case of a nonimmediate operand that's used as a source. Use | |
37 | ;; this to permit reads from PC-relative memory when -mpcrel is | |
38 | ;; specified. | |
39 | ||
40 | (define_predicate "nonimmediate_src_operand" | |
41 | (match_code "subreg,reg,mem") | |
42 | { | |
43 | if (TARGET_PCREL && GET_CODE (op) == MEM | |
44 | && (GET_CODE (XEXP (op, 0)) == SYMBOL_REF | |
45 | || GET_CODE (XEXP (op, 0)) == LABEL_REF | |
46 | || GET_CODE (XEXP (op, 0)) == CONST)) | |
47 | return 1; | |
48 | return nonimmediate_operand (op, mode); | |
49 | }) | |
50 | ||
51 | ;; Special case of a memory operand that's used as a source. Use this | |
52 | ;; to permit reads from PC-relative memory when -mpcrel is specified. | |
53 | ||
54 | (define_predicate "memory_src_operand" | |
55 | (match_code "subreg,mem") | |
56 | { | |
57 | if (TARGET_PCREL && GET_CODE (op) == MEM | |
58 | && (GET_CODE (XEXP (op, 0)) == SYMBOL_REF | |
59 | || GET_CODE (XEXP (op, 0)) == LABEL_REF | |
60 | || GET_CODE (XEXP (op, 0)) == CONST)) | |
61 | return 1; | |
62 | return memory_operand (op, mode); | |
63 | }) | |
64 | ||
65 | ;; Similar to general_operand, but exclude stack_pointer_rtx. | |
66 | ||
67 | (define_predicate "not_sp_operand" | |
68 | (match_code "subreg,reg,mem") | |
69 | { | |
70 | return op != stack_pointer_rtx && nonimmediate_operand (op, mode); | |
71 | }) | |
72 | ||
73 | ;; Predicate that accepts only a pc-relative address. This is needed | |
74 | ;; because pc-relative addresses don't satisfy the predicate | |
75 | ;; "general_src_operand". | |
76 | ||
77 | (define_predicate "pcrel_address" | |
4fbe09f9 | 78 | (match_code "symbol_ref,label_ref,const")) |
41b6a5e2 KH |
79 | |
80 | ;; Accept integer operands in the range 0..0xffffffff. We have to | |
81 | ;; check the range carefully since this predicate is used in DImode | |
82 | ;; contexts. Also, we need some extra crud to make it work when | |
83 | ;; hosted on 64-bit machines. | |
84 | ||
85 | (define_predicate "const_uint32_operand" | |
86 | (match_code "const_int,const_double") | |
87 | { | |
88 | /* It doesn't make sense to ask this question with a mode that is | |
89 | not larger than 32 bits. */ | |
4fbe09f9 | 90 | gcc_assert (GET_MODE_BITSIZE (mode) > 32); |
41b6a5e2 KH |
91 | |
92 | #if HOST_BITS_PER_WIDE_INT > 32 | |
93 | /* All allowed constants will fit a CONST_INT. */ | |
94 | return (GET_CODE (op) == CONST_INT | |
95 | && (INTVAL (op) >= 0 && INTVAL (op) <= 0xffffffffL)); | |
96 | #else | |
97 | return (GET_CODE (op) == CONST_INT | |
98 | || (GET_CODE (op) == CONST_DOUBLE && CONST_DOUBLE_HIGH (op) == 0)); | |
99 | #endif | |
100 | }) | |
101 | ||
102 | ;; Accept integer operands in the range -0x80000000..0x7fffffff. We | |
103 | ;; have to check the range carefully since this predicate is used in | |
104 | ;; DImode contexts. | |
105 | ||
106 | (define_predicate "const_sint32_operand" | |
107 | (match_code "const_int") | |
108 | { | |
109 | /* It doesn't make sense to ask this question with a mode that is | |
110 | not larger than 32 bits. */ | |
4fbe09f9 | 111 | gcc_assert (GET_MODE_BITSIZE (mode) > 32); |
41b6a5e2 KH |
112 | |
113 | /* All allowed constants will fit a CONST_INT. */ | |
114 | return (GET_CODE (op) == CONST_INT | |
115 | && (INTVAL (op) >= (-0x7fffffff - 1) && INTVAL (op) <= 0x7fffffff)); | |
116 | }) | |
117 | ||
f90b7a5a PB |
118 | (define_predicate "m68k_cstore_comparison_operator" |
119 | (if_then_else (match_test "TARGET_68881") | |
120 | (match_operand 0 "comparison_operator") | |
121 | (match_operand 0 "ordered_comparison_operator"))) | |
122 | ||
41b6a5e2 KH |
123 | ;; Check for sign_extend or zero_extend. Used for bit-count operands. |
124 | ||
125 | (define_predicate "extend_operator" | |
4fbe09f9 | 126 | (match_code "sign_extend,zero_extend")) |
41b6a5e2 KH |
127 | |
128 | ;; Returns true if OP is either a symbol reference or a sum of a | |
75df395f MK |
129 | ;; symbol reference and a constant. This predicate is for "raw" |
130 | ;; symbol references not yet processed by legitimize*_address, | |
131 | ;; hence we do not handle UNSPEC_{XGOT, TLS, XTLS} here. | |
41b6a5e2 KH |
132 | |
133 | (define_predicate "symbolic_operand" | |
134 | (match_code "symbol_ref,label_ref,const") | |
135 | { | |
136 | switch (GET_CODE (op)) | |
137 | { | |
138 | case SYMBOL_REF: | |
139 | case LABEL_REF: | |
140 | return true; | |
141 | ||
142 | case CONST: | |
143 | op = XEXP (op, 0); | |
144 | return ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF | |
145 | || GET_CODE (XEXP (op, 0)) == LABEL_REF) | |
146 | && GET_CODE (XEXP (op, 1)) == CONST_INT); | |
147 | ||
148 | #if 0 /* Deleted, with corresponding change in m68k.h, | |
149 | so as to fit the specs. No CONST_DOUBLE is ever symbolic. */ | |
150 | case CONST_DOUBLE: | |
151 | return GET_MODE (op) == mode; | |
152 | #endif | |
153 | ||
154 | default: | |
155 | return false; | |
156 | } | |
157 | }) | |
158 | ||
4e2b26aa | 159 | ;; A constant that can be used the address in a call insn |
29ca003a RS |
160 | (define_predicate "const_call_operand" |
161 | (ior (match_operand 0 "const_int_operand") | |
162 | (and (match_test "m68k_symbolic_call != NULL") | |
163 | (match_operand 0 "symbolic_operand")))) | |
164 | ||
165 | ;; An operand that can be used as the address in a call insn. | |
166 | (define_predicate "call_operand" | |
167 | (ior (match_operand 0 "const_call_operand") | |
168 | (match_operand 0 "register_operand"))) | |
169 | ||
4e2b26aa NS |
170 | ;; A constant that can be used the address in a sibcall insn |
171 | (define_predicate "const_sibcall_operand" | |
172 | (ior (match_operand 0 "const_int_operand") | |
173 | (and (match_test "m68k_symbolic_jump != NULL") | |
174 | (match_operand 0 "symbolic_operand")))) | |
175 | ||
f7e70894 RS |
176 | ;; An operand that can be used as the address in a sibcall insn. |
177 | (define_predicate "sibcall_operand" | |
4e2b26aa | 178 | (ior (match_operand 0 "const_sibcall_operand") |
f7e70894 RS |
179 | (and (match_code "reg") |
180 | (match_test "REGNO (op) == STATIC_CHAIN_REGNUM")))) | |
181 | ||
41b6a5e2 KH |
182 | ;; TODO: Add a comment here. |
183 | ||
184 | (define_predicate "post_inc_operand" | |
4fbe09f9 KH |
185 | (and (match_code "mem") |
186 | (match_test "GET_CODE (XEXP (op, 0)) == POST_INC"))) | |
41b6a5e2 KH |
187 | |
188 | ;; TODO: Add a comment here. | |
189 | ||
190 | (define_predicate "pre_dec_operand" | |
4fbe09f9 KH |
191 | (and (match_code "mem") |
192 | (match_test "GET_CODE (XEXP (op, 0)) == PRE_DEC"))) | |
c47b0cb4 | 193 | |
f90b7a5a PB |
194 | ;; A zero constant. |
195 | (define_predicate "const0_operand" | |
196 | (and (match_code "const_int,const_double,const_vector") | |
197 | (match_test "op == CONST0_RTX (mode)"))) | |
198 | ||
199 | ;; A one constant (operand for conditional_trap). | |
200 | (define_predicate "const1_operand" | |
201 | (and (match_code "const_int") | |
202 | (match_test "op == const1_rtx"))) | |
203 | ||
6cebc6cb BS |
204 | ;; A valid operand for a conditional operation. |
205 | ;; ColdFire has tst patterns for HImode and QImode, but not cmp patterns. | |
206 | (define_predicate "m68k_comparison_operand" | |
207 | (if_then_else (match_test "TARGET_COLDFIRE && mode != SImode") | |
f90b7a5a PB |
208 | (and (match_code "const_int") |
209 | (match_test "op == const0_rtx")) | |
210 | (match_operand 0 "general_src_operand"))) | |
211 | ||
c47b0cb4 MK |
212 | ;; An operand for movsi_const0 pattern. |
213 | (define_predicate "movsi_const0_operand" | |
214 | (and (match_operand 0 "nonimmediate_operand") | |
215 | (match_test "(TARGET_68010 || TARGET_COLDFIRE) | |
216 | || !(MEM_P (op) && MEM_VOLATILE_P (op))"))) | |
217 | ||
218 | ;; A non-symbolic call operand. | |
219 | ;; We need to special case 'const_int' to ignore its mode while matching. | |
220 | (define_predicate "non_symbolic_call_operand" | |
221 | (and (match_operand 0 "call_operand") | |
222 | (ior (and (match_code "const_int") | |
223 | (match_test "!symbolic_operand (op, mode)")) | |
224 | (match_test "!symbolic_operand (op,mode)")))) | |
67595cbb RZ |
225 | |
226 | ;; Special case of general_src_operand, which rejects a few fp | |
227 | ;; constants (which we prefer in registers) before reload. | |
6cebc6cb | 228 | ;; Used only in comparisons, and we do want to allow zero. |
67595cbb RZ |
229 | |
230 | (define_predicate "fp_src_operand" | |
231 | (match_operand 0 "general_src_operand") | |
232 | { | |
6cebc6cb BS |
233 | return (!CONSTANT_P (op) |
234 | || op == CONST0_RTX (mode) | |
235 | || (TARGET_68881 | |
236 | && (!standard_68881_constant_p (op) | |
237 | || reload_in_progress | |
238 | || reload_completed))); | |
67595cbb | 239 | }) |
5e7821eb | 240 | |
57d7fe86 JL |
241 | ;; Used to detect constants that are valid for addq/subq instructions |
242 | (define_predicate "addq_subq_operand" | |
243 | (match_code "const_int") | |
244 | { | |
245 | return ((INTVAL (op) <= 8 && INTVAL (op) > 0) | |
246 | || (INTVAL (op) >= -8 && INTVAL (op) < 0)); | |
247 | }) | |
248 | ||
249 | ;; Used to detect equality and non-equality operators | |
250 | (define_predicate "equality_comparison_operator" | |
251 | (match_code "eq,ne")) | |
252 | ||
5e7821eb JL |
253 | ;; Used to detect when an operand is either a register |
254 | ;; or a constant that is all ones in its lower bits. | |
255 | ;; Used by insv pattern to help detect when we're initializing | |
256 | ;; a bitfield to all ones. | |
257 | ||
258 | (define_predicate "reg_or_pow2_m1_operand" | |
259 | (match_code "reg,const_int") | |
260 | { | |
bcff0913 | 261 | return (REG_P (op) || pow2_m1_operand (op, VOIDmode)); |
5e7821eb | 262 | }) |
bcff0913 JL |
263 | |
264 | ;; Used to detect a constant that is all ones in its lower bits. | |
265 | (define_predicate "pow2_m1_operand" | |
266 | (match_code "const_int") | |
267 | { | |
268 | return (GET_CODE (op) == CONST_INT && exact_log2 (INTVAL (op) + 1) >= 0); | |
269 | }) | |
270 | ||
271 | ;; Used to detect valid targets for conditional branches | |
272 | ;; Used to detect (pc) or (label_ref) in some jumping patterns to cut down | |
273 | (define_predicate "pc_or_label_operand" | |
274 | (match_code "pc,label_ref")) | |
83ad4fac JL |
275 | |
276 | (define_predicate "swap_peephole_relational_operator" | |
277 | (match_code "gtu,leu,gt,le")) | |
6cebc6cb BS |
278 | |
279 | (define_predicate "address_reg_operand" | |
280 | (match_test ("ADDRESS_REG_P (op)"))) |