Branch data Line data Source code
1 : : ;; Predicate definitions for IA-32 and x86-64.
2 : : ;; Copyright (C) 2004-2024 Free Software Foundation, Inc.
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
8 : : ;; the Free Software Foundation; either version 3, or (at your option)
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
17 : : ;; along with GCC; see the file COPYING3. If not see
18 : : ;; <http://www.gnu.org/licenses/>.
19 : :
20 : : ;; Return true if OP is either a i387 or SSE fp register.
21 : : (define_predicate "any_fp_register_operand"
22 : : (and (match_code "reg")
23 : 125042635 : (match_test "ANY_FP_REGNO_P (REGNO (op))")))
24 : 40436 :
25 : : ;; Return true if OP is an i387 fp register.
26 : : (define_predicate "fp_register_operand"
27 : : (and (match_code "reg")
28 : 1619518 : (match_test "STACK_REGNO_P (REGNO (op))")))
29 : 1528371 :
30 : 410200634 : ;; True if the operand is a GENERAL class register.
31 : : (define_predicate "general_reg_operand"
32 : : (and (match_code "reg")
33 : 255609203 : (match_test "GENERAL_REGNO_P (REGNO (op))")))
34 : 191094325 :
35 : 417183977 : ;; True if the operand is an INDEX class register.
36 : : (define_predicate "index_reg_operand"
37 : : (and (match_code "reg")
38 : 609432 : (match_test "INDEX_REGNO_P (REGNO (op))")))
39 : 609392 :
40 : 609797 : ;; True if the operand is a nonimmediate operand with GENERAL class register.
41 : : (define_predicate "nonimmediate_gr_operand"
42 : : (if_then_else (match_code "reg")
43 : 54522265 : (match_test "GENERAL_REGNO_P (REGNO (op))")
44 : 58319678 : (match_operand 0 "nonimmediate_operand")))
45 : 74460762 :
46 : : ;; True if the operand is a general operand with GENERAL class register.
47 : : (define_predicate "general_gr_operand"
48 : 85575397 : (if_then_else (match_code "reg")
49 : 38561815 : (match_test "GENERAL_REGNO_P (REGNO (op))")
50 : 109472172 : (match_operand 0 "general_operand")))
51 : :
52 : : ;; True if the operand is an MMX register.
53 : : (define_predicate "mmx_reg_operand"
54 : 35970516 : (and (match_code "reg")
55 : 190 : (match_test "MMX_REGNO_P (REGNO (op))")))
56 : 35970516 :
57 : : ;; Match register operands, but include memory operands for
58 : : ;; !TARGET_MMX_WITH_SSE.
59 : : (define_predicate "register_mmxmem_operand"
60 : 271297 : (ior (match_operand 0 "register_operand")
61 : 11 : (and (not (match_test "TARGET_MMX_WITH_SSE"))
62 : 271297 : (match_operand 0 "memory_operand"))))
63 : :
64 : : ;; True if the operand is an SSE register.
65 : 148897512 : (define_predicate "sse_reg_operand"
66 : : (and (match_code "reg")
67 : 148897512 : (match_test "SSE_REGNO_P (REGNO (op))")))
68 : 1785729 :
69 : : ;; Return true if op is a QImode register.
70 : : (define_predicate "any_QIreg_operand"
71 : : (and (match_code "reg")
72 : 2212885 : (match_test "ANY_QI_REGNO_P (REGNO (op))")))
73 : 750958 :
74 : 2238471 : ;; Return true if op is one of QImode registers: %[abcd][hl].
75 : : (define_predicate "QIreg_operand"
76 : : (and (match_code "reg")
77 : 758156 : (match_test "QI_REGNO_P (REGNO (op))")))
78 : 616390 :
79 : 1553004 : ;; Return true if op is a QImode register operand other than %[abcd][hl].
80 : : (define_predicate "ext_QIreg_operand"
81 : 2668100 : (and (match_test "TARGET_64BIT")
82 : 2668432 : (match_code "reg")
83 : 740292 : (not (match_test "QI_REGNO_P (REGNO (op))"))))
84 : 2855818 :
85 : : ;; Return true if op is the AX register.
86 : : (define_predicate "ax_reg_operand"
87 : : (and (match_code "reg")
88 : 20112013 : (match_test "REGNO (op) == AX_REG")))
89 : 0 :
90 : 102669179 : ;; Return true if op is the flags register.
91 : : (define_special_predicate "flags_reg_operand"
92 : : (and (match_code "reg")
93 : 105115033 : (match_test "REGNO (op) == FLAGS_REG")))
94 : :
95 : 37730983 : ;; True if the operand is a MASK register.
96 : : (define_predicate "mask_reg_operand"
97 : 8564936 : (and (match_code "reg")
98 : 2921 : (match_test "MASK_REGNO_P (REGNO (op))")))
99 : 8567857 :
100 : : ;; Match a DI, SI or HImode register operand.
101 : : (define_special_predicate "int248_register_operand"
102 : : (and (match_operand 0 "register_operand")
103 : 418563 : (ior (and (match_test "TARGET_64BIT")
104 : 125549 : (match_test "GET_MODE (op) == DImode"))
105 : 272098 : (match_test "GET_MODE (op) == SImode")
106 : 153607 : (match_test "GET_MODE (op) == HImode"))))
107 : :
108 : : ;; Match a DI, SI, HI or QImode nonimmediate_operand.
109 : : (define_special_predicate "int_nonimmediate_operand"
110 : 359307 : (and (match_operand 0 "nonimmediate_operand")
111 : 512989 : (ior (and (match_test "TARGET_64BIT")
112 : 359307 : (match_test "GET_MODE (op) == DImode"))
113 : 176949 : (match_test "GET_MODE (op) == SImode")
114 : : (match_test "GET_MODE (op) == HImode")
115 : 359307 : (match_test "GET_MODE (op) == QImode"))))
116 : :
117 : : ;; Match register operands, but include memory operands for TARGET_SSE_MATH.
118 : : (define_predicate "register_ssemem_operand"
119 : 1340267 : (if_then_else
120 : 1340267 : (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
121 : 1340267 : (match_operand 0 "nonimmediate_operand")
122 : : (match_operand 0 "register_operand")))
123 : :
124 : 672781 : ;; Match nonimmediate operands, but exclude memory operands
125 : : ;; for TARGET_SSE_MATH if TARGET_MIX_SSE_I387 is not enabled.
126 : 672781 : (define_predicate "nonimm_ssenomem_operand"
127 : : (if_then_else
128 : 672781 : (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
129 : 1345562 : (not (match_test "TARGET_MIX_SSE_I387")))
130 : : (match_operand 0 "register_operand")
131 : : (match_operand 0 "nonimmediate_operand")))
132 : :
133 : 280325 : ;; The above predicate, suitable for x87 arithmetic operators.
134 : : (define_predicate "x87nonimm_ssenomem_operand"
135 : 280325 : (if_then_else
136 : 280325 : (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
137 : 560650 : (not (match_test "TARGET_MIX_SSE_I387 && X87_ENABLE_ARITH (mode)")))
138 : : (match_operand 0 "register_operand")
139 : : (match_operand 0 "nonimmediate_operand")))
140 : :
141 : 45408 : ;; Match register operands, include memory operand for TARGET_SSE4_1.
142 : : (define_predicate "register_sse4nonimm_operand"
143 : 45408 : (if_then_else (match_test "TARGET_SSE4_1")
144 : : (match_operand 0 "nonimmediate_operand")
145 : : (match_operand 0 "register_operand")))
146 : :
147 : 14186 : ;; Return true if VALUE is symbol reference
148 : : (define_predicate "symbol_operand"
149 : 14186 : (match_code "symbol_ref"))
150 : 14186 :
151 : : ;; Return true if VALUE is an ENDBR opcode in immediate field.
152 : : (define_predicate "ix86_endbr_immediate_operand"
153 : : (match_code "const_int")
154 : 5027317482 : {
155 : 5027317482 : if (flag_cf_protection & CF_BRANCH)
156 : : {
157 : 849400902 : unsigned HOST_WIDE_INT imm = UINTVAL (op);
158 : 849400902 : unsigned HOST_WIDE_INT val = TARGET_64BIT ? 0xfa1e0ff3 : 0xfb1e0ff3;
159 : :
160 : 849400902 : if (imm == val)
161 : : return true;
162 : :
163 : : /* NB: Encoding is byte based. */
164 : 849400741 : if (TARGET_64BIT)
165 : 1445488242 : for (; imm >= val; imm >>= 8)
166 : 760175292 : if (imm == val)
167 : : return true;
168 : : }
169 : :
170 : : return false;
171 : : })
172 : :
173 : : ;; Return true if VALUE can be stored in a sign extended immediate field.
174 : 6649946857 : (define_predicate "x86_64_immediate_operand"
175 : : (match_code "const_int,symbol_ref,label_ref,const")
176 : 6649946857 : {
177 : 9482794819 : if (ix86_endbr_immediate_operand (op, VOIDmode))
178 : : return false;
179 : :
180 : 4455477130 : if (!TARGET_64BIT)
181 : 4634140996 : return immediate_operand (op, mode);
182 : :
183 : 4276813471 : switch (GET_CODE (op))
184 : : {
185 : 3535009973 : case CONST_INT:
186 : 3535009973 : {
187 : 3535009973 : HOST_WIDE_INT val = INTVAL (op);
188 : 3535009973 : return trunc_int_for_mode (val, SImode) == val;
189 : : }
190 : 603750203 : case SYMBOL_REF:
191 : : /* TLS symbols are not constant. */
192 : 603750203 : if (SYMBOL_REF_TLS_MODEL (op))
193 : : return false;
194 : :
195 : : /* Load the external function address via the GOT slot. */
196 : 603709162 : if (ix86_force_load_from_GOT_p (op))
197 : : return false;
198 : :
199 : : /* For certain code models, the symbolic references are known to fit.
200 : : in CM_SMALL_PIC model we know it fits if it is local to the shared
201 : : library. Don't count TLS SYMBOL_REFs here, since they should fit
202 : : only if inside of UNSPEC handled below. */
203 : 603709116 : return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
204 : 603709116 : || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
205 : :
206 : 19218903 : case LABEL_REF:
207 : : /* For certain code models, the code is near as well. */
208 : 19218903 : return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
209 : : || ix86_cmodel == CM_KERNEL);
210 : :
211 : 118834392 : case CONST:
212 : : /* We also may accept the offsetted memory references in certain
213 : : special cases. */
214 : 118834392 : if (GET_CODE (XEXP (op, 0)) == UNSPEC)
215 : 674179 : switch (XINT (XEXP (op, 0), 1))
216 : : {
217 : : case UNSPEC_GOTPCREL:
218 : : case UNSPEC_DTPOFF:
219 : : case UNSPEC_GOTNTPOFF:
220 : : case UNSPEC_NTPOFF:
221 : : return true;
222 : : default:
223 : : break;
224 : : }
225 : :
226 : 118161297 : if (GET_CODE (XEXP (op, 0)) == PLUS)
227 : : {
228 : 118160213 : rtx op1 = XEXP (XEXP (op, 0), 0);
229 : 118160213 : rtx op2 = XEXP (XEXP (op, 0), 1);
230 : :
231 : 118160213 : if (ix86_cmodel == CM_LARGE && GET_CODE (op1) != UNSPEC)
232 : : return false;
233 : 118160209 : if (!CONST_INT_P (op2))
234 : : return false;
235 : :
236 : 118160209 : HOST_WIDE_INT offset = INTVAL (op2);
237 : 118160209 : if (trunc_int_for_mode (offset, SImode) != offset)
238 : : return false;
239 : :
240 : 118153919 : switch (GET_CODE (op1))
241 : : {
242 : 117875400 : case SYMBOL_REF:
243 : : /* TLS symbols are not constant. */
244 : 117875400 : if (SYMBOL_REF_TLS_MODEL (op1))
245 : : return false;
246 : :
247 : : /* Load the external function address via the GOT slot. */
248 : 117862381 : if (ix86_force_load_from_GOT_p (op1))
249 : : return false;
250 : :
251 : : /* For CM_SMALL assume that latest object is 16MB before
252 : : end of 31bits boundary. We may also accept pretty
253 : : large negative constants knowing that all objects are
254 : : in the positive half of address space. */
255 : 117862375 : if ((ix86_cmodel == CM_SMALL
256 : 183975 : || (ix86_cmodel == CM_MEDIUM
257 : 0 : && !SYMBOL_REF_FAR_ADDR_P (op1)))
258 : 117862375 : && offset < 16*1024*1024)
259 : : return true;
260 : : /* For CM_KERNEL we know that all object resist in the
261 : : negative half of 32bits address space. We may not
262 : : accept negative offsets, since they may be just off
263 : : and we may accept pretty large positive ones. */
264 : 186039 : if (ix86_cmodel == CM_KERNEL
265 : 0 : && offset > 0)
266 : : return true;
267 : : break;
268 : :
269 : 3426 : case LABEL_REF:
270 : : /* These conditions are similar to SYMBOL_REF ones, just the
271 : : constraints for code models differ. */
272 : 3426 : if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
273 : 3426 : && offset < 16*1024*1024)
274 : : return true;
275 : 0 : if (ix86_cmodel == CM_KERNEL
276 : 0 : && offset > 0)
277 : : return true;
278 : : break;
279 : :
280 : 275093 : case UNSPEC:
281 : 275093 : switch (XINT (op1, 1))
282 : : {
283 : : case UNSPEC_DTPOFF:
284 : : case UNSPEC_NTPOFF:
285 : : return true;
286 : : }
287 : : break;
288 : :
289 : : default:
290 : : break;
291 : : }
292 : : }
293 : : break;
294 : :
295 : 0 : default:
296 : 0 : gcc_unreachable ();
297 : : }
298 : :
299 : : return false;
300 : : })
301 : :
302 : : ;; Return true if VALUE can be stored in the zero extended immediate field.
303 : 4886218956 : (define_predicate "x86_64_zext_immediate_operand"
304 : : (match_code "const_int,symbol_ref,label_ref,const")
305 : 4886218956 : {
306 : 116049116 : if (ix86_endbr_immediate_operand (op, VOIDmode))
307 : 4455477337 : return false;
308 : 4455477337 :
309 : 116049110 : switch (GET_CODE (op))
310 : 4455477337 : {
311 : 4515629096 : case CONST_INT:
312 : 60151759 : return !(INTVAL (op) & ~HOST_WIDE_INT_C (0xffffffff));
313 : :
314 : 52052051 : case SYMBOL_REF:
315 : 4455477337 : /* TLS symbols are not constant. */
316 : 4507529388 : if (SYMBOL_REF_TLS_MODEL (op))
317 : 120505897 : return false;
318 : :
319 : : /* Load the external function address via the GOT slot. */
320 : 52052051 : if (ix86_force_load_from_GOT_p (op))
321 : 116049116 : return false;
322 : :
323 : : /* For certain code models, the symbolic references are known to fit. */
324 : 52052051 : return (ix86_cmodel == CM_SMALL
325 : 52052051 : || (ix86_cmodel == CM_MEDIUM
326 : 198 : && !SYMBOL_REF_FAR_ADDR_P (op)));
327 : :
328 : 125251 : case LABEL_REF:
329 : : /* For certain code models, the code is near as well. */
330 : 125251 : return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
331 : :
332 : 3720049 : case CONST:
333 : : /* We also may accept the offsetted memory references in certain
334 : : special cases. */
335 : 3720049 : if (GET_CODE (XEXP (op, 0)) == PLUS)
336 : : {
337 : 3715785 : rtx op1 = XEXP (XEXP (op, 0), 0);
338 : 3715785 : rtx op2 = XEXP (XEXP (op, 0), 1);
339 : :
340 : 3715785 : if (ix86_cmodel == CM_LARGE)
341 : : return false;
342 : 3715785 : if (!CONST_INT_P (op2))
343 : : return false;
344 : :
345 : 3715785 : HOST_WIDE_INT offset = INTVAL (op2);
346 : 3715785 : if (trunc_int_for_mode (offset, SImode) != offset)
347 : : return false;
348 : :
349 : 3713157 : switch (GET_CODE (op1))
350 : : {
351 : 3712648 : case SYMBOL_REF:
352 : : /* TLS symbols are not constant. */
353 : 3712648 : if (SYMBOL_REF_TLS_MODEL (op1))
354 : : return false;
355 : :
356 : : /* Load the external function address via the GOT slot. */
357 : 3712648 : if (ix86_force_load_from_GOT_p (op1))
358 : : return false;
359 : :
360 : : /* For small code model we may accept pretty large positive
361 : : offsets, since one bit is available for free. Negative
362 : : offsets are limited by the size of NULL pointer area
363 : : specified by the ABI. */
364 : 3712648 : if ((ix86_cmodel == CM_SMALL
365 : 36256 : || (ix86_cmodel == CM_MEDIUM
366 : 0 : && !SYMBOL_REF_FAR_ADDR_P (op1)))
367 : 3712648 : && offset > -0x10000)
368 : : return true;
369 : : /* ??? For the kernel, we may accept adjustment of
370 : : -0x10000000, since we know that it will just convert
371 : : negative address space to positive, but perhaps this
372 : : is not worthwhile. */
373 : : break;
374 : :
375 : 0 : case LABEL_REF:
376 : : /* These conditions are similar to SYMBOL_REF ones, just the
377 : : constraints for code models differ. */
378 : 0 : if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
379 : 0 : && offset > -0x10000)
380 : : return true;
381 : : break;
382 : :
383 : : default:
384 : : return false;
385 : : }
386 : : }
387 : : break;
388 : :
389 : 0 : default:
390 : 0 : gcc_unreachable ();
391 : : }
392 : : return false;
393 : : })
394 : :
395 : : ;; Return true if VALUE is a constant integer whose low and high words satisfy
396 : 334490880 : ;; x86_64_immediate_operand.
397 : : (define_predicate "x86_64_hilo_int_operand"
398 : 334490880 : (match_code "const_int,const_wide_int")
399 : : {
400 : 137887758 : switch (GET_CODE (op))
401 : 116049116 : {
402 : 137843506 : case CONST_INT:
403 : 21794390 : return x86_64_immediate_operand (op, mode);
404 : 116049116 :
405 : 44252 : case CONST_WIDE_INT:
406 : 44252 : gcc_assert (CONST_WIDE_INT_NUNITS (op) == 2);
407 : 44252 : return (x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op, 0)),
408 : 116049116 : DImode)
409 : 116093368 : && x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op,
410 : 50315756 : 1)),
411 : : DImode));
412 : :
413 : 0 : default:
414 : 21838642 : gcc_unreachable ();
415 : : }
416 : : })
417 : :
418 : : ;; Return true if VALUE is a constant integer whose value is
419 : 22288458 : ;; x86_64_immediate_operand value zero extended from word mode to mode.
420 : : (define_predicate "x86_64_dwzext_immediate_operand"
421 : 22288458 : (match_code "const_int,const_wide_int")
422 : : {
423 : 7014 : if (ix86_endbr_immediate_operand (op, VOIDmode))
424 : 21838642 : return false;
425 : 21838642 :
426 : 7014 : switch (GET_CODE (op))
427 : : {
428 : 5328 : case CONST_INT:
429 : 5328 : if (!TARGET_64BIT)
430 : 21838642 : return UINTVAL (op) <= HOST_WIDE_INT_UC (0xffffffff);
431 : 5328 : return UINTVAL (op) <= HOST_WIDE_INT_UC (0x7fffffff);
432 : :
433 : 1686 : case CONST_WIDE_INT:
434 : 8700 : if (!TARGET_64BIT)
435 : : return false;
436 : 1686 : return (CONST_WIDE_INT_NUNITS (op) == 2
437 : 1686 : && CONST_WIDE_INT_ELT (op, 1) == 0
438 : 3372 : && (trunc_int_for_mode (CONST_WIDE_INT_ELT (op, 0), SImode)
439 : 1686 : == (HOST_WIDE_INT) CONST_WIDE_INT_ELT (op, 0)));
440 : :
441 : 0 : default:
442 : 0 : gcc_unreachable ();
443 : : }
444 : : })
445 : :
446 : : ;; Return true if size of VALUE can be stored in a sign
447 : 7014 : ;; extended immediate field.
448 : : (define_predicate "x86_64_immediate_size_operand"
449 : 7014 : (and (match_code "symbol_ref")
450 : 0 : (ior (not (match_test "TARGET_64BIT"))
451 : 0 : (match_test "ix86_cmodel == CM_SMALL")
452 : 0 : (match_test "ix86_cmodel == CM_KERNEL"))))
453 : 0 :
454 : : ;; Return true if OP is general operand representable on x86_64.
455 : : (define_predicate "x86_64_general_operand"
456 : 71557360 : (if_then_else (match_test "TARGET_64BIT")
457 : 71564374 : (ior (match_operand 0 "nonimmediate_operand")
458 : 7014 : (match_operand 0 "x86_64_immediate_operand"))
459 : 71557360 : (match_operand 0 "general_operand")))
460 : 29270782 :
461 : : ;; Return true if OP's both words are general operands representable
462 : 29270782 : ;; on x86_64.
463 : : (define_predicate "x86_64_hilo_general_operand"
464 : 29270782 : (if_then_else (match_test "TARGET_64BIT")
465 : : (ior (match_operand 0 "nonimmediate_operand")
466 : : (match_operand 0 "x86_64_hilo_int_operand"))
467 : : (match_operand 0 "general_operand")))
468 : 71291 :
469 : : ;; Return true if OP is non-VOIDmode general operand representable
470 : 71291 : ;; on x86_64. This predicate is used in sign-extending conversion
471 : : ;; operations that require non-VOIDmode immediate operands.
472 : : (define_predicate "x86_64_sext_operand"
473 : 71291 : (and (match_test "GET_MODE (op) != VOIDmode")
474 : : (match_operand 0 "x86_64_general_operand")))
475 : :
476 : : ;; Return true if OP is non-VOIDmode general operand. This predicate
477 : 2833 : ;; is used in sign-extending conversion operations that require
478 : : ;; non-VOIDmode immediate operands.
479 : 2833 : (define_predicate "sext_operand"
480 : 2833 : (and (match_test "GET_MODE (op) != VOIDmode")
481 : : (match_operand 0 "general_operand")))
482 : :
483 : : ;; Return true if OP is representable on x86_64 as zero-extended operand.
484 : 1090407 : ;; This predicate is used in zero-extending conversion operations that
485 : : ;; require non-VOIDmode immediate operands.
486 : 1090407 : (define_predicate "x86_64_zext_operand"
487 : 1090407 : (if_then_else (match_test "TARGET_64BIT")
488 : : (ior (match_operand 0 "nonimmediate_operand")
489 : : (and (match_operand 0 "x86_64_zext_immediate_operand")
490 : 38293 : (match_test "GET_MODE (op) != VOIDmode")))
491 : : (match_operand 0 "nonimmediate_operand")))
492 : :
493 : : ;; Return true if OP is general operand representable on x86_64
494 : 1409847 : ;; as either sign extended or zero extended constant.
495 : : (define_predicate "x86_64_szext_general_operand"
496 : 1409847 : (if_then_else (match_test "TARGET_64BIT")
497 : : (ior (match_operand 0 "nonimmediate_operand")
498 : : (match_operand 0 "x86_64_immediate_operand")
499 : : (match_operand 0 "x86_64_zext_immediate_operand"))
500 : 21552427 : (match_operand 0 "general_operand")))
501 : :
502 : 21552427 : ;; Return true if OP is nonmemory operand representable on x86_64.
503 : : (define_predicate "x86_64_nonmemory_operand"
504 : 21552427 : (if_then_else (match_test "TARGET_64BIT")
505 : : (ior (match_operand 0 "register_operand")
506 : : (match_operand 0 "x86_64_immediate_operand"))
507 : : (match_operand 0 "nonmemory_operand")))
508 : 237491 :
509 : : ;; Return true if OP is nonmemory operand representable on x86_64.
510 : 237491 : (define_predicate "x86_64_szext_nonmemory_operand"
511 : 237491 : (if_then_else (match_test "TARGET_64BIT")
512 : : (ior (match_operand 0 "register_operand")
513 : : (match_operand 0 "x86_64_immediate_operand")
514 : : (match_operand 0 "x86_64_zext_immediate_operand"))
515 : 140754599 : (match_operand 0 "nonmemory_operand")))
516 : :
517 : : ;; Return true when operand is PIC expression that can be computed by lea
518 : : ;; operation.
519 : : (define_predicate "pic_32bit_operand"
520 : : (match_code "const,symbol_ref,label_ref")
521 : : {
522 : 140754599 : if (!flag_pic)
523 : : return false;
524 : :
525 : : /* Rule out relocations that translate into 64bit constants. */
526 : 8032485 : if (TARGET_64BIT && GET_CODE (op) == CONST)
527 : : {
528 : 107554 : op = XEXP (op, 0);
529 : 107554 : if (GET_CODE (op) == PLUS && CONST_INT_P (XEXP (op, 1)))
530 : 106433 : op = XEXP (op, 0);
531 : 107554 : if (GET_CODE (op) == UNSPEC
532 : 1121 : && (XINT (op, 1) == UNSPEC_GOTOFF
533 : 1121 : || XINT (op, 1) == UNSPEC_GOT))
534 : : return false;
535 : : }
536 : :
537 : 8031807 : return symbolic_operand (op, mode);
538 : : })
539 : :
540 : : ;; Return true if OP is nonmemory operand acceptable by movabs patterns.
541 : 1148849182 : (define_predicate "x86_64_movabs_operand"
542 : : (and (match_operand 0 "nonmemory_operand")
543 : 1148849182 : (not (match_operand 0 "pic_32bit_operand"))))
544 : :
545 : 140754599 : ;; Return true if OP is either a symbol reference or a sum of a symbol
546 : 140754599 : ;; reference and a constant.
547 : 140754599 : (define_predicate "symbolic_operand"
548 : 140754599 : (match_code "symbol_ref,label_ref,const")
549 : : {
550 : 8387486 : switch (GET_CODE (op))
551 : : {
552 : 140754599 : case SYMBOL_REF:
553 : 140754599 : case LABEL_REF:
554 : 141790 : return true;
555 : :
556 : 32773 : case CONST:
557 : 32773 : op = XEXP (op, 0);
558 : 460587622 : if (GET_CODE (op) == SYMBOL_REF
559 : 32773 : || GET_CODE (op) == LABEL_REF
560 : 460587622 : || (GET_CODE (op) == UNSPEC
561 : 8029 : && (XINT (op, 1) == UNSPEC_GOT
562 : 8029 : || XINT (op, 1) == UNSPEC_GOTOFF
563 : 181 : || XINT (op, 1) == UNSPEC_PCREL
564 : 8387667 : || XINT (op, 1) == UNSPEC_GOTPCREL)))
565 : : return true;
566 : 24891 : if (GET_CODE (op) != PLUS
567 : 24744 : || !CONST_INT_P (XEXP (op, 1)))
568 : : return false;
569 : :
570 : 24744 : op = XEXP (op, 0);
571 : 24744 : if (GET_CODE (op) == SYMBOL_REF
572 : 24744 : || GET_CODE (op) == LABEL_REF)
573 : : return true;
574 : : /* Only @GOTOFF gets offsets. */
575 : 2079 : if (GET_CODE (op) != UNSPEC
576 : 2079 : || XINT (op, 1) != UNSPEC_GOTOFF)
577 : : return false;
578 : :
579 : 2079 : op = XVECEXP (op, 0, 0);
580 : 2079 : if (GET_CODE (op) == SYMBOL_REF
581 : 2079 : || GET_CODE (op) == LABEL_REF)
582 : 2079 : return true;
583 : : return false;
584 : :
585 : 0 : default:
586 : 0 : gcc_unreachable ();
587 : : }
588 : : })
589 : :
590 : : ;; Return true if OP is a symbolic operand that resolves locally.
591 : 15423280 : (define_predicate "local_symbolic_operand"
592 : : (match_code "const,label_ref,symbol_ref")
593 : 15423280 : {
594 : 2217403 : if (GET_CODE (op) == CONST
595 : 16088 : && GET_CODE (XEXP (op, 0)) == PLUS
596 : 8283 : && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
597 : 8283 : op = XEXP (XEXP (op, 0), 0);
598 : 8387486 :
599 : 2217403 : if (GET_CODE (op) == LABEL_REF)
600 : : return true;
601 : :
602 : 2183002 : if (GET_CODE (op) != SYMBOL_REF)
603 : 8387486 : return false;
604 : 497765 :
605 : 2173118 : if (SYMBOL_REF_TLS_MODEL (op))
606 : : return false;
607 : :
608 : 2217403 : /* Dll-imported symbols are always external. */
609 : 2173118 : if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
610 : : return false;
611 : 2173118 : if (SYMBOL_REF_LOCAL_P (op))
612 : : return true;
613 : :
614 : : /* There is, however, a not insubstantial body of code in the rest of
615 : : the compiler that assumes it can just stick the results of
616 : : ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done. */
617 : : /* ??? This is a hack. Should update the body of the compiler to
618 : : always create a DECL an invoke targetm.encode_section_info. */
619 : 92082 : if (strncmp (XSTR (op, 0), internal_label_prefix,
620 : : internal_label_prefix_len) == 0)
621 : 0 : return true;
622 : :
623 : : return false;
624 : : })
625 : :
626 : : (define_predicate "local_func_symbolic_operand"
627 : 2225968 : (match_operand 0 "local_symbolic_operand")
628 : : {
629 : 2225968 : if (GET_CODE (op) == CONST
630 : 0 : && GET_CODE (XEXP (op, 0)) == PLUS
631 : 0 : && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
632 : 0 : op = XEXP (XEXP (op, 0), 0);
633 : 2217403 :
634 : 2217411 : if (GET_CODE (op) == SYMBOL_REF
635 : 8 : && !SYMBOL_REF_FUNCTION_P (op))
636 : 0 : return false;
637 : :
638 : 2217403 : return true;
639 : 2217403 : })
640 : 2115431 :
641 : : ;; Test for a legitimate @GOTOFF operand.
642 : 44 : ;;
643 : : ;; VxWorks does not impose a fixed gap between segments; the run-time
644 : 52 : ;; gap can be different from the object-file gap. We therefore can't
645 : 8 : ;; use @GOTOFF unless we are absolutely sure that the symbol is in the
646 : : ;; same segment as the GOT. Unfortunately, the flexibility of linker
647 : : ;; scripts means that we can't be sure of that in general, so assume
648 : : ;; @GOTOFF is not valid on VxWorks, except with the large code model.
649 : 2225888 : (define_predicate "gotoff_operand"
650 : : (and (ior (not (match_test "TARGET_VXWORKS_RTP"))
651 : 2225888 : (match_test "ix86_cmodel == CM_LARGE")
652 : 2225888 : (match_test "ix86_cmodel == CM_LARGE_PIC"))
653 : : (match_operand 0 "local_symbolic_operand")))
654 : :
655 : : ;; Test for various thread-local symbols.
656 : 9418 : (define_special_predicate "tls_symbolic_operand"
657 : : (and (match_code "symbol_ref")
658 : 9418 : (match_test "SYMBOL_REF_TLS_MODEL (op)")))
659 : :
660 : : (define_special_predicate "tls_modbase_operand"
661 : : (and (match_code "symbol_ref")
662 : 4 : (match_test "op == ix86_tls_module_base ()")))
663 : :
664 : 8 : (define_predicate "tls_address_pattern"
665 : : (and (match_code "set,parallel,unspec,unspec_volatile")
666 : 218204714 : (match_test "ix86_tls_address_pattern_p (op)")))
667 : 0 :
668 : 218204714 : ;; Test for a pc-relative call operand
669 : : (define_predicate "constant_call_address_operand"
670 : 218204714 : (match_code "symbol_ref")
671 : 315763476 : {
672 : 97558762 : if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC
673 : 97558617 : || flag_force_indirect_call)
674 : 218204714 : return false;
675 : : if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
676 : : return false;
677 : : return true;
678 : 218204714 : })
679 : :
680 : : ;; True for any non-virtual and non-eliminable register. Used in places where
681 : 102001619 : ;; instantiation of such a register may cause the pattern to not be recognized.
682 : : (define_predicate "register_no_elim_operand"
683 : 102001619 : (match_operand 0 "register_operand")
684 : 199558782 : {
685 : 63556825 : if (SUBREG_P (op))
686 : 35676 : op = SUBREG_REG (op);
687 : :
688 : : /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
689 : 6899012 : because it is guaranteed to be reloaded into one. */
690 : 6899012 : if (MEM_P (op))
691 : : return true;
692 : :
693 : 6899012 : return !(op == arg_pointer_rtx
694 : 6875420 : || op == frame_pointer_rtx
695 : 6874988 : || VIRTUAL_REGISTER_P (op));
696 : : })
697 : :
698 : : ;; Similarly, but include the stack pointer. This is used
699 : 8791363 : ;; to prevent esp from being used as an index reg.
700 : : (define_predicate "register_no_SP_operand"
701 : 8791363 : (match_operand 0 "register_operand")
702 : 6899012 : {
703 : 103470 : if (SUBREG_P (op))
704 : 10803 : op = SUBREG_REG (op);
705 : :
706 : 103470 : /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
707 : : because it is guaranteed to be reloaded into one. */
708 : 103470 : if (MEM_P (op))
709 : : return true;
710 : :
711 : 103470 : return !(op == arg_pointer_rtx
712 : 103470 : || op == frame_pointer_rtx
713 : 103470 : || op == stack_pointer_rtx
714 : 103470 : || VIRTUAL_REGISTER_P (op));
715 : : })
716 : :
717 : : ;; P6 processors will jump to the address after the decrement when %esp
718 : 129452 : ;; is used as a call operand, so they will execute return address as a code.
719 : : ;; See Pentium Pro errata 70, Pentium 2 errata A33 and Pentium 3 errata E17.
720 : 129452 :
721 : 103470 : (define_predicate "call_register_operand"
722 : 781064 : (if_then_else (match_test "TARGET_64BIT")
723 : : (match_operand 0 "register_operand")
724 : : (match_operand 0 "register_no_SP_operand")))
725 : 781064 :
726 : 7994484 : ;; Return false if this is any eliminable register. Otherwise general_operand.
727 : 781064 : (define_predicate "general_no_elim_operand"
728 : 7994484 : (if_then_else (match_code "reg,subreg")
729 : : (match_operand 0 "register_no_elim_operand")
730 : : (match_operand 0 "general_operand")))
731 : :
732 : 3446855 : ;; Return false if this is any eliminable register. Otherwise
733 : : ;; register_operand or a constant.
734 : 3446855 : (define_predicate "nonmemory_no_elim_operand"
735 : : (ior (match_operand 0 "register_no_elim_operand")
736 : : (match_operand 0 "immediate_operand")))
737 : :
738 : 597648 : ;; Test for a valid operand for indirect branch.
739 : : (define_predicate "indirect_branch_operand"
740 : 597648 : (ior (match_operand 0 "register_operand")
741 : 578094 : (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
742 : 578071 : (not (match_test "TARGET_X32"))
743 : : (match_operand 0 "memory_operand"))))
744 : :
745 : : ;; Return true if OP is a memory operands that can be used in sibcalls.
746 : 17957 : ;; Since sibcall never returns, we can only use call-clobbered register
747 : : ;; as GOT base. Allow GOT slot here only with pseudo register as GOT
748 : : ;; base. Properly handle sibcall over GOT slot with *sibcall_GOT_32
749 : : ;; and *sibcall_value_GOT_32 patterns.
750 : : (define_predicate "sibcall_memory_operand"
751 : : (match_operand 0 "memory_operand")
752 : : {
753 : 17957 : op = XEXP (op, 0);
754 : 17957 : if (CONSTANT_P (op))
755 : : return true;
756 : 4582 : if (GET_CODE (op) == PLUS && REG_P (XEXP (op, 0)))
757 : : {
758 : 4082 : int regno = REGNO (XEXP (op, 0));
759 : 4082 : if (!HARD_REGISTER_NUM_P (regno) || call_used_or_fixed_reg_p (regno))
760 : : {
761 : 4082 : op = XEXP (op, 1);
762 : 4082 : if (GOT32_symbol_operand (op, VOIDmode))
763 : : return true;
764 : : }
765 : : }
766 : : return false;
767 : : })
768 : :
769 : : ;; Return true if OP is a GOT memory operand.
770 : 1248154 : (define_predicate "GOT_memory_operand"
771 : : (and (match_operand 0 "memory_operand")
772 : 1266111 : (match_code "const" "0")
773 : 17957 : (match_code "unspec" "00")
774 : 433 : (match_test "XINT (XEXP (XEXP (op, 0), 0), 1) == UNSPEC_GOTPCREL")))
775 : :
776 : : ;; Test for a valid operand for a call instruction.
777 : 393 : ;; Allow constant call address operands in Pmode only.
778 : 17333622 : (define_special_predicate "call_insn_operand"
779 : 393 : (ior (match_test "constant_call_address_operand
780 : 17333622 : (op, mode == VOIDmode ? mode : Pmode)")
781 : : (match_operand 0 "call_register_operand")
782 : 420713 : (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
783 : 420501 : (ior (and (not (match_test "TARGET_X32"))
784 : : (match_operand 0 "memory_operand"))
785 : 329650 : (and (match_test "TARGET_X32 && Pmode == DImode")
786 : : (match_operand 0 "GOT_memory_operand"))))))
787 : :
788 : : ;; Similarly, but for tail calls, in which we cannot allow memory references.
789 : 472679 : (define_special_predicate "sibcall_insn_operand"
790 : : (ior (match_test "constant_call_address_operand
791 : 472679 : (op, mode == VOIDmode ? mode : Pmode)")
792 : : (match_operand 0 "register_no_elim_operand")
793 : 117526 : (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
794 : 117338 : (ior (and (not (match_test "TARGET_X32"))
795 : : (match_operand 0 "sibcall_memory_operand"))
796 : 116058 : (and (match_test "TARGET_X32 && Pmode == DImode")
797 : : (match_operand 0 "GOT_memory_operand"))))))
798 : :
799 : : ;; Return true if OP is a 32-bit GOT symbol operand.
800 : 5350 : (define_predicate "GOT32_symbol_operand"
801 : : (and (match_code "const")
802 : 1940 : (match_code "unspec" "0")
803 : 7290 : (match_test "XINT (XEXP (op, 0), 1) == UNSPEC_GOT")))
804 : 0 :
805 : : ;; Match exactly zero.
806 : : (define_predicate "const0_operand"
807 : : (match_code "const_int,const_double,const_vector")
808 : 62691788 : {
809 : 62691788 : if (mode == VOIDmode)
810 : 18498164 : mode = GET_MODE (op);
811 : 62691788 : return op == CONST0_RTX (mode);
812 : : })
813 : :
814 : : ;; Match one or a vector with all elements equal to one.
815 : 701315907 : (define_predicate "const1_operand"
816 : : (match_code "const_int,const_double,const_vector")
817 : 701315907 : {
818 : 11168580 : if (mode == VOIDmode)
819 : 11166222 : mode = GET_MODE (op);
820 : 73860368 : return op == CONST1_RTX (mode);
821 : 62691788 : })
822 : 62691788 :
823 : : ;; Match exactly -1.
824 : 11978776 : (define_predicate "constm1_operand"
825 : : (and (match_code "const_int")
826 : 74670564 : (match_test "op == constm1_rtx")))
827 : 62691788 :
828 : 23392014 : ;; Match exactly eight.
829 : 11168580 : (define_predicate "const8_operand"
830 : 11168580 : (and (match_code "const_int")
831 : 11168580 : (match_test "INTVAL (op) == 8")))
832 : 0 :
833 : : ;; Match exactly 128.
834 : : (define_predicate "const128_operand"
835 : 11168580 : (and (match_code "const_int")
836 : 11168580 : (match_test "INTVAL (op) == 128")))
837 : 23460469 :
838 : : ;; Match exactly 0x0FFFFFFFF in anddi as a zero-extension operation
839 : : (define_predicate "const_32bit_mask"
840 : 2443695 : (and (match_code "const_int")
841 : 1675081 : (match_test "trunc_int_for_mode (INTVAL (op), DImode)
842 : 4118776 : == HOST_WIDE_INT_C (0xffffffff)")))
843 : 16077298 :
844 : : ;; Match 2, 4, or 8. Used for leal multiplicands.
845 : : (define_predicate "const248_operand"
846 : 220429 : (match_code "const_int")
847 : : {
848 : 220429 : HOST_WIDE_INT i = INTVAL (op);
849 : 220429 : return i == 2 || i == 4 || i == 8;
850 : : })
851 : :
852 : : ;; Match 1, 2, or 3. Used for lea shift amounts.
853 : 803929 : (define_predicate "const123_operand"
854 : : (match_code "const_int")
855 : 803929 : {
856 : 220429 : HOST_WIDE_INT i = INTVAL (op);
857 : 157741 : return i == 1 || i == 2 || i == 3;
858 : : })
859 : :
860 : 157741 : ;; Match 2, 3, 6, or 7
861 : 168121 : (define_predicate "const2367_operand"
862 : : (match_code "const_int")
863 : 168121 : {
864 : 157741 : HOST_WIDE_INT i = INTVAL (op);
865 : 20 : return i == 2 || i == 3 || i == 6 || i == 7;
866 : : })
867 : :
868 : 440 : ;; Match 1, 2, 4, or 8
869 : 440 : (define_predicate "const1248_operand"
870 : : (match_code "const_int")
871 : 440 : {
872 : 89137 : HOST_WIDE_INT i = INTVAL (op);
873 : 177394 : return i == 1 || i == 2 || i == 4 || i == 8;
874 : : })
875 : :
876 : 88697 : ;; Match 3, 5, or 9. Used for leal multiplicands.
877 : 412015 : (define_predicate "const359_operand"
878 : : (match_code "const_int")
879 : 412015 : {
880 : 88697 : HOST_WIDE_INT i = INTVAL (op);
881 : 84928 : return i == 3 || i == 5 || i == 9;
882 : : })
883 : :
884 : 42464 : ;; Match 4 or 8 to 11. Used for embeded rounding.
885 : 182889 : (define_predicate "const_4_or_8_to_11_operand"
886 : : (match_code "const_int")
887 : 182889 : {
888 : 42464 : HOST_WIDE_INT i = INTVAL (op);
889 : 63057 : return i == 4 || (i >= 8 && i <= 11);
890 : : })
891 : :
892 : 63057 : ;; Match 4 or 8. Used for SAE.
893 : 63059 : (define_predicate "const48_operand"
894 : : (match_code "const_int")
895 : 63059 : {
896 : 63057 : HOST_WIDE_INT i = INTVAL (op);
897 : 43500 : return i == 4 || i == 8;
898 : : })
899 : :
900 : 43500 : ;; Match 0 or 1.
901 : 43500 : (define_predicate "const_0_to_1_operand"
902 : : (and (match_code "const_int")
903 : 43500 : (ior (match_test "op == const0_rtx")
904 : 159341 : (match_test "op == const1_rtx"))))
905 : :
906 : : ;; Match 0 to 3.
907 : : (define_predicate "const_0_to_3_operand"
908 : 4057377 : (and (match_code "const_int")
909 : 7675184 : (match_test "IN_RANGE (INTVAL (op), 0, 3)")))
910 : 4057377 :
911 : : ;; Match 0 to 4.
912 : : (define_predicate "const_0_to_4_operand"
913 : 0 : (and (match_code "const_int")
914 : 0 : (match_test "IN_RANGE (INTVAL (op), 0, 4)")))
915 : 0 :
916 : : ;; Match 0 to 5.
917 : : (define_predicate "const_0_to_5_operand"
918 : 0 : (and (match_code "const_int")
919 : 0 : (match_test "IN_RANGE (INTVAL (op), 0, 5)")))
920 : 0 :
921 : : ;; Match 0 to 7.
922 : : (define_predicate "const_0_to_7_operand"
923 : 357169 : (and (match_code "const_int")
924 : 714324 : (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
925 : 357169 :
926 : : ;; Match 0 to 15.
927 : : (define_predicate "const_0_to_15_operand"
928 : 60282 : (and (match_code "const_int")
929 : 120548 : (match_test "IN_RANGE (INTVAL (op), 0, 15)")))
930 : 60282 :
931 : : ;; Match 0 to 31.
932 : : (define_predicate "const_0_to_31_operand"
933 : 46325 : (and (match_code "const_int")
934 : 92633 : (match_test "IN_RANGE (INTVAL (op), 0, 31)")))
935 : 46325 :
936 : : ;; Match 0 to 63.
937 : : (define_predicate "const_0_to_63_operand"
938 : 20306 : (and (match_code "const_int")
939 : 40370 : (match_test "IN_RANGE (INTVAL (op), 0, 63)")))
940 : 20306 :
941 : : ;; Match 0 to 127.
942 : : (define_predicate "const_0_to_127_operand"
943 : 8452 : (and (match_code "const_int")
944 : 16348 : (match_test "IN_RANGE (INTVAL (op), 0, 127)")))
945 : 8452 :
946 : : ;; Match 0 to 255.
947 : : (define_predicate "const_0_to_255_operand"
948 : 2691101 : (and (match_code "const_int")
949 : 5356000 : (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
950 : 2691101 :
951 : : ;; Match (0 to 255) * 8
952 : : (define_predicate "const_0_to_255_mul_8_operand"
953 : 128237 : (match_code "const_int")
954 : : {
955 : 128237 : unsigned HOST_WIDE_INT val = INTVAL (op);
956 : 128237 : return val <= 255*8 && val % 8 == 0;
957 : : })
958 : :
959 : : ;; Match 1 to 255 except multiples of 8
960 : 128239 : (define_predicate "const_0_to_255_not_mul_8_operand"
961 : : (match_code "const_int")
962 : 128239 : {
963 : 619418 : unsigned HOST_WIDE_INT val = INTVAL (op);
964 : 491168 : return val <= 255 && val % 8 != 0;
965 : : })
966 : :
967 : 491179 : ;; Return true if OP is CONST_INT >= 1 and <= 31 (a valid operand
968 : 491179 : ;; for shift & compare patterns, as shifting by 0 does not change flags).
969 : : (define_predicate "const_1_to_31_operand"
970 : 491179 : (and (match_code "const_int")
971 : 524573 : (match_test "IN_RANGE (INTVAL (op), 1, 31)")))
972 : :
973 : : ;; Return true if OP is CONST_INT >= 1 and <= 63 (a valid operand
974 : : ;; for 64bit shift & compare patterns, as shifting by 0 does not change flags).
975 : 66927 : (define_predicate "const_1_to_63_operand"
976 : : (and (match_code "const_int")
977 : 66927 : (match_test "IN_RANGE (INTVAL (op), 1, 63)")))
978 : :
979 : : ;; Match 2 or 3.
980 : : (define_predicate "const_2_to_3_operand"
981 : 43685 : (and (match_code "const_int")
982 : 87370 : (match_test "IN_RANGE (INTVAL (op), 2, 3)")))
983 : 43685 :
984 : : ;; Match 4 to 5.
985 : : (define_predicate "const_4_to_5_operand"
986 : 3935 : (and (match_code "const_int")
987 : 7870 : (match_test "IN_RANGE (INTVAL (op), 4, 5)")))
988 : 3935 :
989 : : ;; Match 4 to 7.
990 : : (define_predicate "const_4_to_7_operand"
991 : 293075 : (and (match_code "const_int")
992 : 586150 : (match_test "IN_RANGE (INTVAL (op), 4, 7)")))
993 : 293075 :
994 : : ;; Match 6 to 7.
995 : : (define_predicate "const_6_to_7_operand"
996 : 618 : (and (match_code "const_int")
997 : 1236 : (match_test "IN_RANGE (INTVAL (op), 6, 7)")))
998 : 618 :
999 : : ;; Match 8 to 9.
1000 : : (define_predicate "const_8_to_9_operand"
1001 : 400 : (and (match_code "const_int")
1002 : 800 : (match_test "IN_RANGE (INTVAL (op), 8, 9)")))
1003 : 400 :
1004 : : ;; Match 8 to 11.
1005 : : (define_predicate "const_8_to_11_operand"
1006 : 20501 : (and (match_code "const_int")
1007 : 41002 : (match_test "IN_RANGE (INTVAL (op), 8, 11)")))
1008 : 20501 :
1009 : : ;; Match 8 to 15.
1010 : : (define_predicate "const_8_to_15_operand"
1011 : 26519 : (and (match_code "const_int")
1012 : 53038 : (match_test "IN_RANGE (INTVAL (op), 8, 15)")))
1013 : 26519 :
1014 : : ;; Match 10 to 11.
1015 : : (define_predicate "const_10_to_11_operand"
1016 : 204 : (and (match_code "const_int")
1017 : 408 : (match_test "IN_RANGE (INTVAL (op), 10, 11)")))
1018 : 204 :
1019 : : ;; Match 12 to 13.
1020 : : (define_predicate "const_12_to_13_operand"
1021 : 196 : (and (match_code "const_int")
1022 : 392 : (match_test "IN_RANGE (INTVAL (op), 12, 13)")))
1023 : 196 :
1024 : : ;; Match 12 to 15.
1025 : : (define_predicate "const_12_to_15_operand"
1026 : 8926 : (and (match_code "const_int")
1027 : 17852 : (match_test "IN_RANGE (INTVAL (op), 12, 15)")))
1028 : 8926 :
1029 : : ;; Match 14 to 15.
1030 : : (define_predicate "const_14_to_15_operand"
1031 : 196 : (and (match_code "const_int")
1032 : 392 : (match_test "IN_RANGE (INTVAL (op), 14, 15)")))
1033 : 196 :
1034 : : ;; Match 16 to 19.
1035 : : (define_predicate "const_16_to_19_operand"
1036 : 648 : (and (match_code "const_int")
1037 : 1296 : (match_test "IN_RANGE (INTVAL (op), 16, 19)")))
1038 : 648 :
1039 : : ;; Match 16 to 31.
1040 : : (define_predicate "const_16_to_31_operand"
1041 : 6556 : (and (match_code "const_int")
1042 : 13112 : (match_test "IN_RANGE (INTVAL (op), 16, 31)")))
1043 : 6556 :
1044 : : ;; Match 20 to 23.
1045 : : (define_predicate "const_20_to_23_operand"
1046 : 392 : (and (match_code "const_int")
1047 : 784 : (match_test "IN_RANGE (INTVAL (op), 20, 23)")))
1048 : 392 :
1049 : : ;; Match 24 to 27.
1050 : : (define_predicate "const_24_to_27_operand"
1051 : 392 : (and (match_code "const_int")
1052 : 784 : (match_test "IN_RANGE (INTVAL (op), 24, 27)")))
1053 : 392 :
1054 : : ;; Match 28 to 31.
1055 : : (define_predicate "const_28_to_31_operand"
1056 : 392 : (and (match_code "const_int")
1057 : 784 : (match_test "IN_RANGE (INTVAL (op), 28, 31)")))
1058 : 392 :
1059 : : ;; True if this is a constant appropriate for an increment or decrement.
1060 : : (define_predicate "incdec_operand"
1061 : 88087922 : (match_code "const_int")
1062 : : {
1063 : : /* On Pentium4, the inc and dec operations causes extra dependency on flag
1064 : : registers, since carry flag is not set. */
1065 : 88087922 : if (!TARGET_USE_INCDEC && !optimize_insn_for_size_p ())
1066 : : return false;
1067 : 2070492 : return op == const1_rtx || op == constm1_rtx;
1068 : : })
1069 : :
1070 : : ;; True for registers, or const_int_operand, used to vec_setm expander.
1071 : 108998459 : (define_predicate "vec_setm_sse41_operand"
1072 : : (ior (and (match_operand 0 "register_operand")
1073 : 197087229 : (match_test "TARGET_SSE4_1"))
1074 : 88087922 : (match_code "const_int")))
1075 : :
1076 : : (define_predicate "vec_setm_avx2_operand"
1077 : : (ior (and (match_operand 0 "register_operand")
1078 : 1072 : (match_test "TARGET_AVX2"))
1079 : 0 : (match_code "const_int")))
1080 : 1317 :
1081 : : (define_predicate "vec_setm_mmx_operand"
1082 : : (ior (and (match_operand 0 "register_operand")
1083 : 181 : (match_test "TARGET_SSE4_1")
1084 : 159 : (match_test "TARGET_MMX_WITH_SSE"))
1085 : 181 : (match_code "const_int")))
1086 : :
1087 : : ;; True for registers, or 1 or -1. Used to optimize double-word shifts.
1088 : : (define_predicate "reg_or_pm1_operand"
1089 : 1320794 : (ior (match_operand 0 "register_operand")
1090 : : (and (match_code "const_int")
1091 : 1320794 : (ior (match_test "op == const1_rtx")
1092 : 195537 : (match_test "op == constm1_rtx")))))
1093 : 181010 :
1094 : : ;; True for registers, or (not: registers). Used to optimize 3-operand
1095 : : ;; bitwise operation.
1096 : : (define_predicate "regmem_or_bitnot_regmem_operand"
1097 : 293344 : (ior (match_operand 0 "nonimmediate_operand")
1098 : : (and (match_code "not")
1099 : 293344 : (match_test "nonimmediate_operand (XEXP (op, 0), mode)"))))
1100 : 12663 :
1101 : : ;; True if OP is acceptable as operand of DImode shift expander.
1102 : : (define_predicate "shiftdi_operand"
1103 : 1159573 : (if_then_else (match_test "TARGET_64BIT")
1104 : 1159573 : (match_operand 0 "nonimmediate_operand")
1105 : : (match_operand 0 "register_operand")))
1106 : 1159573 :
1107 : 573780 : (define_predicate "ashldi_input_operand"
1108 : 573780 : (if_then_else (match_test "TARGET_64BIT")
1109 : 573780 : (match_operand 0 "nonimmediate_operand")
1110 : : (match_operand 0 "reg_or_pm1_operand")))
1111 : :
1112 : 533659 : ;; Return true if OP is a vector load from the constant pool with just
1113 : : ;; the first element nonzero.
1114 : : (define_predicate "zero_extended_scalar_load_operand"
1115 : : (match_code "mem")
1116 : : {
1117 : 533659 : unsigned n_elts;
1118 : 533659 : op = avoid_constant_pool_reference (op);
1119 : :
1120 : 533659 : if (GET_CODE (op) != CONST_VECTOR)
1121 : : return false;
1122 : :
1123 : 72130 : n_elts = CONST_VECTOR_NUNITS (op);
1124 : :
1125 : 166152 : for (n_elts--; n_elts > 0; n_elts--)
1126 : : {
1127 : 115821 : rtx elt = CONST_VECTOR_ELT (op, n_elts);
1128 : 231642 : if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
1129 : : return false;
1130 : : }
1131 : : return true;
1132 : : })
1133 : :
1134 : : /* Return true if operand is a float vector constant that is all ones. */
1135 : 1708237 : (define_predicate "float_vector_all_ones_operand"
1136 : : (match_code "const_vector,mem")
1137 : 533659 : {
1138 : 1758568 : mode = GET_MODE (op);
1139 : 50331 : if (!FLOAT_MODE_P (mode)
1140 : 12560298 : || (MEM_P (op)
1141 : 10945511 : && (!SYMBOL_REF_P (XEXP (op, 0))
1142 : 780136 : || !CONSTANT_POOL_ADDRESS_P (XEXP (op, 0)))))
1143 : 14989364 : return false;
1144 : :
1145 : 2188703 : if (MEM_P (op))
1146 : : {
1147 : 573916 : op = get_pool_constant (XEXP (op, 0));
1148 : 573916 : if (GET_CODE (op) != CONST_VECTOR)
1149 : : return false;
1150 : :
1151 : 573916 : if (GET_MODE (op) != mode
1152 : 4780 : && INTEGRAL_MODE_P (GET_MODE (op))
1153 : 4780 : && op == CONSTM1_RTX (GET_MODE (op)))
1154 : : return true;
1155 : : }
1156 : :
1157 : 2188703 : rtx first = XVECEXP (op, 0, 0);
1158 : 6386002 : for (int i = 1; i != GET_MODE_NUNITS (GET_MODE (op)); i++)
1159 : : {
1160 : 2791269 : rtx tmp = XVECEXP (op, 0, i);
1161 : 2791269 : if (!rtx_equal_p (tmp, first))
1162 : : return false;
1163 : : }
1164 : 401732 : if (GET_MODE (first) == E_SFmode)
1165 : : {
1166 : 169138 : long l;
1167 : 169138 : REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (first), l);
1168 : 169138 : return (l & 0xffffffff) == 0xffffffff;
1169 : : }
1170 : 232594 : else if (GET_MODE (first) == E_DFmode)
1171 : : {
1172 : 228462 : long l[2];
1173 : 228462 : REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (first), l);
1174 : 228462 : return ((l[0] & 0xffffffff) == 0xffffffff
1175 : 228462 : && (l[1] & 0xffffffff) == 0xffffffff);
1176 : : }
1177 : : else
1178 : : return false;
1179 : : })
1180 : :
1181 : : /* Return true if operand is an integral vector constant that is all ones. */
1182 : 49645230 : (define_predicate "vector_all_ones_operand"
1183 : : (and (match_code "const_vector")
1184 : 60586654 : (match_test "INTEGRAL_MODE_P (GET_MODE (op))")
1185 : 9368173 : (match_test "op == CONSTM1_RTX (GET_MODE (op))")))
1186 : 166362 :
1187 : 14989364 : /* Return true if operand is a vector constant that is all ones. */
1188 : 14989364 : (define_predicate "int_float_vector_all_ones_operand"
1189 : : (ior (match_operand 0 "vector_all_ones_operand")
1190 : 7872060 : (match_operand 0 "float_vector_all_ones_operand")
1191 : 0 : (match_test "op == constm1_rtx")))
1192 : 7872060 :
1193 : 14989364 : /* Return true if operand is an 128/256bit all ones vector
1194 : 2175 : that zero-extends to 256/512bit. */
1195 : : (define_predicate "vector_all_ones_zero_extend_half_operand"
1196 : 10363969 : (match_code "const_vector")
1197 : : {
1198 : 129046654 : mode = GET_MODE (op);
1199 : 10363969 : if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
1200 : 138013899 : || (GET_MODE_SIZE (mode) != 32
1201 : 8684427 : && GET_MODE_SIZE (mode) != 64))
1202 : 9936870 : return false;
1203 : :
1204 : 427099 : int nelts = CONST_VECTOR_NUNITS (op);
1205 : 443572 : for (int i = 0; i != nelts; i++)
1206 : : {
1207 : 442903 : rtx elt = CONST_VECTOR_ELT (op, i);
1208 : 442903 : if (i < nelts / 2
1209 : 883006 : && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
1210 : : return false;
1211 : 17922 : if (i >= nelts / 2
1212 : 20722 : && elt != CONST0_RTX (GET_MODE_INNER (mode)))
1213 : : return false;
1214 : : }
1215 : : return true;
1216 : : })
1217 : :
1218 : : /* Return true if operand is an 128bit all ones vector
1219 : 132910644 : that zero extends to 512bit. */
1220 : : (define_predicate "vector_all_ones_zero_extend_quarter_operand"
1221 : 10363969 : (match_code "const_vector")
1222 : 132911313 : {
1223 : 669 : mode = GET_MODE (op);
1224 : 10363300 : if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
1225 : 8966576 : || GET_MODE_SIZE (mode) != 64)
1226 : 10219175 : return false;
1227 : 10363300 :
1228 : 144125 : int nelts = CONST_VECTOR_NUNITS (op);
1229 : 149475 : for (int i = 0; i != nelts; i++)
1230 : : {
1231 : 149432 : rtx elt = CONST_VECTOR_ELT (op, i);
1232 : 149432 : if (i < nelts / 4
1233 : 297345 : && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
1234 : : return false;
1235 : 6545 : if (i >= nelts / 4
1236 : 8064 : && elt != CONST0_RTX (GET_MODE_INNER (mode)))
1237 : : return false;
1238 : : }
1239 : : return true;
1240 : : })
1241 : :
1242 : : ; Return true when OP is operand acceptable for vector memory operand.
1243 : 132909975 : ; Only AVX can have misaligned memory operand.
1244 : : (define_predicate "vector_memory_operand"
1245 : 10363300 : (and (match_operand 0 "memory_operand")
1246 : 133604912 : (ior (match_test "TARGET_AVX")
1247 : 694937 : (match_test "MEM_ALIGN (op) >= GET_MODE_ALIGNMENT (mode)"))))
1248 : :
1249 : : ; Return true when OP is register_operand or vector_memory_operand.
1250 : : (define_predicate "vector_operand"
1251 : 10071791 : (ior (match_operand 0 "register_operand")
1252 : : (match_operand 0 "vector_memory_operand")))
1253 : 10071791 :
1254 : : ; Return true when OP is register_operand, vector_memory_operand
1255 : : ; or const_vector.
1256 : : (define_predicate "vector_or_const_vector_operand"
1257 : 6846 : (ior (match_operand 0 "register_operand")
1258 : : (match_operand 0 "vector_memory_operand")
1259 : 6846 : (match_code "const_vector")))
1260 : 4098 :
1261 : : (define_predicate "bcst_mem_operand"
1262 : : (and (match_code "vec_duplicate")
1263 : 9052 : (and (match_test "TARGET_AVX512F")
1264 : 60923547 : (ior (match_test "TARGET_AVX512VL")
1265 : 8172 : (and (match_test "GET_MODE_SIZE (GET_MODE (op)) == 64")
1266 : 57184 : (match_test "TARGET_EVEX512"))))
1267 : 27805 : (match_test "VALID_BCST_MODE_P (GET_MODE_INNER (GET_MODE (op)))")
1268 : 7950 : (match_test "GET_MODE (XEXP (op, 0))
1269 : 23831 : == GET_MODE_INNER (GET_MODE (op))")
1270 : 60931621 : (match_test "memory_operand (XEXP (op, 0), GET_MODE (XEXP (op, 0)))")))
1271 : 4229 :
1272 : : ; Return true when OP is bcst_mem_operand or vector_memory_operand.
1273 : : (define_predicate "bcst_vector_operand"
1274 : : (ior (match_operand 0 "vector_operand")
1275 : 2107925 : (match_operand 0 "bcst_mem_operand")))
1276 : :
1277 : 2107925 : ;; Return true when OP is either nonimmediate operand, or any
1278 : : ;; CONST_VECTOR.
1279 : : (define_predicate "nonimmediate_or_const_vector_operand"
1280 : : (ior (match_operand 0 "nonimmediate_operand")
1281 : 43674 : (match_code "const_vector")))
1282 : :
1283 : 43674 : (define_predicate "nonimmediate_or_const_vec_dup_operand"
1284 : 3782 : (ior (match_operand 0 "nonimmediate_operand")
1285 : 58 : (match_test "const_vec_duplicate_p (op)")))
1286 : 58 :
1287 : : ;; Return true when OP is either register operand, or any
1288 : 98 : ;; CONST_VECTOR.
1289 : : (define_predicate "reg_or_const_vector_operand"
1290 : 98 : (ior (match_operand 0 "register_operand")
1291 : : (match_code "const_vector")))
1292 : 373 :
1293 : 100 : ;; Return true when OP is CONST_VECTOR which can be converted to a
1294 : : ;; sign extended 32-bit integer.
1295 : : (define_predicate "x86_64_const_vector_operand"
1296 : : (match_code "const_vector")
1297 : 128647 : {
1298 : 128647 : if (mode == VOIDmode)
1299 : 0 : mode = GET_MODE (op);
1300 : 128647 : else if (GET_MODE (op) != mode)
1301 : : return false;
1302 : 313465 : if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
1303 : : return false;
1304 : 84741 : HOST_WIDE_INT val = ix86_convert_const_vector_to_integer (op, mode);
1305 : 84741 : return trunc_int_for_mode (val, SImode) == val;
1306 : : })
1307 : :
1308 : : (define_predicate "nonimmediate_or_x86_64_const_vector_operand"
1309 : 1255051 : (ior (match_operand 0 "nonimmediate_operand")
1310 : : (match_operand 0 "x86_64_const_vector_operand")))
1311 : 128647 :
1312 : 1327318 : ;; Return true when OP is nonimmediate or standard SSE constant.
1313 : 72267 : (define_predicate "nonimmediate_or_sse_const_operand"
1314 : : (ior (match_operand 0 "nonimmediate_operand")
1315 : 12493068 : (match_test "standard_sse_constant_p (op, mode)")))
1316 : 1026034 :
1317 : 2771 : ;; Return true if OP is a register or a zero.
1318 : : (define_predicate "reg_or_0_operand"
1319 : 2771 : (ior (match_operand 0 "register_operand")
1320 : 431213 : (match_operand 0 "const0_operand")))
1321 : :
1322 : 431213 : ; Return true when OP is a nonimmediate or zero.
1323 : 68783872 : (define_predicate "nonimm_or_0_operand"
1324 : : (ior (match_operand 0 "nonimmediate_operand")
1325 : 80250906 : (match_operand 0 "const0_operand")))
1326 : 70503909 :
1327 : : ;; Return true for RTX codes that force SImode address.
1328 : 70503909 : (define_predicate "SImode_address_operand"
1329 : : (match_code "subreg,zero_extend,and"))
1330 : :
1331 : : ;; Return true if op is a valid address for LEA, and does not contain
1332 : 212766445 : ;; a segment override. Defined as a special predicate to allow
1333 : : ;; mode-less const_int operands pass to address_operand.
1334 : 212766445 : (define_special_predicate "address_no_seg_operand"
1335 : 131611736 : (match_test "address_operand (op, VOIDmode)")
1336 : 48830481 : {
1337 : 49135480 : struct ix86_address parts;
1338 : 49135480 : int ok;
1339 : 304999 :
1340 : 48861121 : if (!CONST_INT_P (op)
1341 : 46195701 : && mode != VOIDmode
1342 : 46195701 : && GET_MODE (op) != mode)
1343 : 304999 : return false;
1344 : 304999 :
1345 : 48830405 : ok = ix86_decompose_address (op, &parts);
1346 : 48830405 : gcc_assert (ok);
1347 : 48830405 : return parts.seg == ADDR_SPACE_GENERIC;
1348 : 48830481 : })
1349 : :
1350 : : ;; Return true if op if a valid base register, displacement or
1351 : 82781255 : ;; sum of base register and displacement for VSIB addressing.
1352 : : (define_predicate "vsib_address_operand"
1353 : 82811895 : (match_test "address_operand (op, VOIDmode)")
1354 : 61755 : {
1355 : 29458 : struct ix86_address parts;
1356 : 30640 : int ok;
1357 : 30640 : rtx disp;
1358 : :
1359 : 30640 : ok = ix86_decompose_address (op, &parts);
1360 : 30640 : gcc_assert (ok);
1361 : 46158 : if (parts.index || parts.seg != ADDR_SPACE_GENERIC)
1362 : 15518 : return false;
1363 : :
1364 : : /* VSIB addressing doesn't support (%rip). */
1365 : 30640 : if (parts.disp)
1366 : 23892385 : {
1367 : 5124 : disp = parts.disp;
1368 : 5124 : if (GET_CODE (disp) == CONST)
1369 : : {
1370 : 90 : disp = XEXP (disp, 0);
1371 : 90 : if (GET_CODE (disp) == PLUS)
1372 : 90 : disp = XEXP (disp, 0);
1373 : 90 : if (GET_CODE (disp) == UNSPEC)
1374 : 0 : switch (XINT (disp, 1))
1375 : : {
1376 : : case UNSPEC_GOTPCREL:
1377 : : case UNSPEC_PCREL:
1378 : : case UNSPEC_GOTNTPOFF:
1379 : : return false;
1380 : : }
1381 : : }
1382 : 5124 : if (TARGET_64BIT
1383 : 5124 : && flag_pic
1384 : 0 : && (GET_CODE (disp) == SYMBOL_REF
1385 : 0 : || GET_CODE (disp) == LABEL_REF))
1386 : 0 : return false;
1387 : : }
1388 : :
1389 : : return true;
1390 : : })
1391 : :
1392 : : (define_predicate "vsib_mem_operator"
1393 : 31115 : (match_code "mem"))
1394 : :
1395 : 31115 : ;; Return true if the rtx is known to be at least 32 bits aligned.
1396 : : (define_predicate "aligned_operand"
1397 : : (match_operand 0 "general_operand")
1398 : : {
1399 : 23892385 : struct ix86_address parts;
1400 : 23892385 : int ok;
1401 : :
1402 : : /* Registers and immediate operands are always "aligned". */
1403 : 23892385 : if (!MEM_P (op))
1404 : : return true;
1405 : :
1406 : : /* All patterns using aligned_operand on memory operands ends up
1407 : : in promoting memory operand to 64bit and thus causing memory mismatch. */
1408 : 7311272 : if (TARGET_MEMORY_MISMATCH_STALL && !optimize_insn_for_size_p ())
1409 : : return false;
1410 : :
1411 : : /* Don't even try to do any aligned optimizations with volatiles. */
1412 : 122606 : if (MEM_VOLATILE_P (op))
1413 : : return false;
1414 : :
1415 : 109631 : if (MEM_ALIGN (op) >= 32)
1416 : : return true;
1417 : :
1418 : 46411 : op = XEXP (op, 0);
1419 : :
1420 : : /* Pushes and pops are only valid on the stack pointer. */
1421 : 46411 : if (GET_CODE (op) == PRE_DEC
1422 : 46411 : || GET_CODE (op) == POST_INC)
1423 : : return true;
1424 : :
1425 : : /* Decode the address. */
1426 : 46411 : ok = ix86_decompose_address (op, &parts);
1427 : 46411 : gcc_assert (ok);
1428 : :
1429 : 46411 : if (parts.base && SUBREG_P (parts.base))
1430 : 0 : parts.base = SUBREG_REG (parts.base);
1431 : 46411 : if (parts.index && SUBREG_P (parts.index))
1432 : 0 : parts.index = SUBREG_REG (parts.index);
1433 : :
1434 : : /* Look for some component that isn't known to be aligned. */
1435 : 46411 : if (parts.index)
1436 : : {
1437 : 3414 : if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
1438 : : return false;
1439 : : }
1440 : 42997 : if (parts.base)
1441 : : {
1442 : 36843 : if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
1443 : : return false;
1444 : : }
1445 : 15083 : if (parts.disp)
1446 : : {
1447 : 15083 : if (!CONST_INT_P (parts.disp)
1448 : 9037 : || (INTVAL (parts.disp) & 3))
1449 : : return false;
1450 : : }
1451 : :
1452 : : /* Didn't find one -- this must be an aligned address. */
1453 : : return true;
1454 : : })
1455 : :
1456 : : ;; Return true if OP is memory operand with a displacement.
1457 : 24364500 : (define_predicate "memory_displacement_operand"
1458 : : (match_operand 0 "memory_operand")
1459 : 48256885 : {
1460 : 23892385 : struct ix86_address parts;
1461 : 0 : int ok;
1462 : :
1463 : 0 : ok = ix86_decompose_address (XEXP (op, 0), &parts);
1464 : 0 : gcc_assert (ok);
1465 : 0 : return parts.disp != NULL_RTX;
1466 : : })
1467 : :
1468 : : ;; Return true if OP is memory operand with a displacement only.
1469 : 0 : (define_predicate "memory_displacement_only_operand"
1470 : : (match_operand 0 "memory_operand")
1471 : 0 : {
1472 : 0 : struct ix86_address parts;
1473 : 34812272 : int ok;
1474 : :
1475 : 34812272 : if (TARGET_64BIT)
1476 : 34812272 : return false;
1477 : :
1478 : 17944665 : ok = ix86_decompose_address (XEXP (op, 0), &parts);
1479 : 17944665 : gcc_assert (ok);
1480 : :
1481 : 17944665 : if (parts.base || parts.index)
1482 : : return false;
1483 : :
1484 : 261850 : return parts.disp != NULL_RTX;
1485 : : })
1486 : :
1487 : : ;; Return true if OP is memory operand that cannot be represented
1488 : 55811757 : ;; by the modRM array.
1489 : : (define_predicate "long_memory_operand"
1490 : 90624029 : (and (match_operand 0 "memory_operand")
1491 : 34812272 : (match_test "memory_address_length (op, false)")))
1492 : :
1493 : : ;; Return true if OP is a comparison operator that can be issued by fcmov.
1494 : : (define_predicate "fcmov_comparison_operator"
1495 : 70574 : (match_operand 0 "comparison_operator")
1496 : : {
1497 : 0 : machine_mode inmode = GET_MODE (XEXP (op, 0));
1498 : 70574 : enum rtx_code code = GET_CODE (op);
1499 : :
1500 : 70574 : if (inmode == CCFPmode)
1501 : 5793 : code = ix86_fp_compare_code_to_integer (code);
1502 : :
1503 : : /* i387 supports just limited amount of conditional codes. */
1504 : 70574 : switch (code)
1505 : : {
1506 : 1466 : case GEU: case LTU:
1507 : 1466 : if (inmode == CCCmode || inmode == CCGZmode)
1508 : : return true;
1509 : : /* FALLTHRU */
1510 : 4633 : case GTU: case LEU:
1511 : 4633 : if (inmode == CCmode || inmode == CCFPmode)
1512 : : return true;
1513 : : return false;
1514 : : case ORDERED: case UNORDERED:
1515 : : case EQ: case NE:
1516 : : return true;
1517 : : default:
1518 : : return false;
1519 : : }
1520 : : })
1521 : :
1522 : : ;; Return true if OP is a comparison that can be used in the CMPSS/CMPPS insns.
1523 : 70574 : ;; The first set are supported directly; the second set can't be done with
1524 : : ;; full IEEE support, i.e. NaNs.
1525 : 141148 :
1526 : 70574 : (define_predicate "sse_comparison_operator"
1527 : : (ior (match_code "eq,ne,lt,le,unordered,unge,ungt,ordered")
1528 : 59388 : (and (match_test "TARGET_AVX")
1529 : 59388 : (match_code "ge,gt,uneq,unle,unlt,ltgt"))))
1530 : 60624 :
1531 : : (define_predicate "ix86_comparison_int_operator"
1532 : 60624 : (match_code "ne,eq,ge,gt,le,lt"))
1533 : 143401 :
1534 : : (define_predicate "ix86_comparison_uns_operator"
1535 : 143401 : (match_code "ne,eq,geu,gtu,leu,ltu"))
1536 : :
1537 : 143401 : (define_predicate "bt_comparison_operator"
1538 : 143401 : (match_code "ne,eq"))
1539 : 143401 :
1540 : 143401 : (define_predicate "shr_comparison_operator"
1541 : 143401 : (match_code "gtu,leu"))
1542 : 143401 :
1543 : 143401 : (define_predicate "add_comparison_operator"
1544 : : (match_code "geu,ltu"))
1545 : :
1546 : : ;; Return true if OP is a valid comparison operator in valid mode.
1547 : 143401 : (define_predicate "ix86_comparison_operator"
1548 : 143401 : (match_operand 0 "comparison_operator")
1549 : : {
1550 : 45206375 : machine_mode inmode = GET_MODE (XEXP (op, 0));
1551 : 45206375 : enum rtx_code code = GET_CODE (op);
1552 : 77272 :
1553 : 45206375 : if (inmode == CCFPmode)
1554 : 4245566 : return ix86_trivial_fp_comparison_operator (op, mode);
1555 : :
1556 : 41038081 : switch (code)
1557 : 77272 : {
1558 : 31393790 : case EQ: case NE:
1559 : 31316518 : if (inmode == CCGZmode)
1560 : 0 : return false;
1561 : 77272 : return true;
1562 : 2151368 : case GE: case LT:
1563 : 2074096 : if (inmode == CCmode || inmode == CCGCmode
1564 : 1244942 : || inmode == CCGOCmode || inmode == CCNOmode || inmode == CCGZmode)
1565 : 1784341 : return true;
1566 : 77272 : return false;
1567 : 77272 : case GEU: case LTU:
1568 : 3710454 : if (inmode == CCCmode || inmode == CCGZmode)
1569 : : return true;
1570 : : /* FALLTHRU */
1571 : 53543685 : case GTU: case LEU:
1572 : 4855054 : if (inmode == CCmode)
1573 : 52965613 : return true;
1574 : : return false;
1575 : 40117604 : case ORDERED: case UNORDERED:
1576 : 2161 : if (inmode == CCmode)
1577 : 1844 : return true;
1578 : : return false;
1579 : 2565183 : case GT: case LE:
1580 : 2565183 : if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
1581 : 2158012 : return true;
1582 : 40115443 : return false;
1583 : : default:
1584 : : return false;
1585 : : }
1586 : 683052 : })
1587 : :
1588 : 683052 : ;; Return true if OP is a valid comparison operator
1589 : 57937011 : ;; testing carry flag to be set.
1590 : 683052 : (define_predicate "ix86_carry_flag_operator"
1591 : 103143386 : (match_code "ltu,unlt")
1592 : 45206375 : {
1593 : 420373 : machine_mode inmode = GET_MODE (XEXP (op, 0));
1594 : 420373 : enum rtx_code code = GET_CODE (op);
1595 : :
1596 : 420373 : if (inmode == CCFPmode)
1597 : 691386 : code = ix86_fp_compare_code_to_integer (code);
1598 : 412039 : else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
1599 : : return false;
1600 : :
1601 : 305988 : return code == LTU;
1602 : : })
1603 : 1060715 :
1604 : : ;; Return true if OP is a valid comparison operator
1605 : 3154545 : ;; testing carry flag to be unset.
1606 : 1060715 : (define_predicate "ix86_carry_flag_unset_operator"
1607 : 2093830 : (match_code "geu,ge")
1608 : : {
1609 : 420741 : machine_mode inmode = GET_MODE (XEXP (op, 0));
1610 : 420741 : enum rtx_code code = GET_CODE (op);
1611 : 1481088 :
1612 : 1060715 : if (inmode == CCFPmode)
1613 : 48 : code = ix86_fp_compare_code_to_integer (code);
1614 : 320 : else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
1615 : 420373 : return false;
1616 : 45626748 :
1617 : 249547 : return code == GEU;
1618 : : })
1619 : :
1620 : : ;; Return true if this comparison only requires testing one flag bit.
1621 : 1651943 : (define_predicate "ix86_trivial_fp_comparison_operator"
1622 : : (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered"))
1623 : 1651575 :
1624 : : ;; Return true if we know how to do this comparison. Others require
1625 : 368 : ;; testing more than one flag bit, and we let the generic middle-end
1626 : 368 : ;; code do that.
1627 : 368 : (define_predicate "ix86_fp_comparison_operator"
1628 : 3642190 : (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
1629 : 3642190 : == IX86_FPCMP_ARITH")
1630 : : (match_operand 0 "comparison_operator")
1631 : 368 : (match_operand 0 "ix86_trivial_fp_comparison_operator")))
1632 : 368 :
1633 : 317310 : ;; Return true if we can perform this comparison on TImode operands.
1634 : : (define_predicate "ix86_timode_comparison_operator"
1635 : 317065 : (if_then_else (match_test "TARGET_64BIT")
1636 : : (match_operand 0 "ordered_comparison_operator")
1637 : 7810484 : (match_operand 0 "bt_comparison_operator")))
1638 : :
1639 : 7810484 : ;; Return true if this is a valid second operand for a TImode comparison.
1640 : : (define_predicate "ix86_timode_comparison_operand"
1641 : 128006 : (if_then_else (match_test "TARGET_64BIT")
1642 : 5805602 : (match_operand 0 "x86_64_general_operand")
1643 : 5805602 : (match_operand 0 "nonimmediate_operand")))
1644 : 5805602 :
1645 : 7633942 : ;; Nearly general operand, but accept any const_double, since we wish
1646 : 5805602 : ;; to be able to drop them into memory rather than have them get pulled
1647 : 507536 : ;; into registers.
1648 : 2335876 : (define_predicate "cmp_fp_expander_operand"
1649 : 5805602 : (ior (match_code "const_double")
1650 : : (match_operand 0 "general_operand")))
1651 : :
1652 : 2221847 : ;; Return true if this is a valid binary floating-point operation.
1653 : 5805602 : (define_predicate "binary_fp_operator"
1654 : 8027449 : (match_code "plus,minus,mult,div"))
1655 : :
1656 : 2211442 : ;; Return true if this is a multiply operation.
1657 : 2211442 : (define_predicate "mult_operator"
1658 : 5853632 : (match_code "mult"))
1659 : 2211442 :
1660 : 3642190 : ;; Return true if this is a division operation.
1661 : : (define_predicate "div_operator"
1662 : : (match_code "div"))
1663 : :
1664 : 2211442 : ;; Return true if this is a and, ior or xor operation.
1665 : 2211442 : (define_predicate "logic_operator"
1666 : : (match_code "and,ior,xor"))
1667 : :
1668 : : ;; Return true if this is a plus, minus, and, ior or xor operation.
1669 : 16556217 : (define_predicate "plusminuslogic_operator"
1670 : : (match_code "plus,minus,and,ior,xor"))
1671 : 16556217 :
1672 : 3404403 : ;; Return true for ARITHMETIC_P.
1673 : : (define_predicate "arith_or_logical_operator"
1674 : : (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div,
1675 : : mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert"))
1676 : 2410287 :
1677 : : ;; Return true for COMMUTATIVE_P.
1678 : 2410287 : (define_predicate "commutative_operator"
1679 : 793389 : (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax"))
1680 : :
1681 : : ;; Return true if OP is a binary operator that can be promoted to wider mode.
1682 : : (define_predicate "promotable_binary_operator"
1683 : 0 : (ior (match_code "plus,minus,and,ior,xor,ashift")
1684 : : (and (match_code "mult")
1685 : 23449229 : (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL"))))
1686 : 0 :
1687 : 0 : (define_predicate "compare_operator"
1688 : 0 : (match_code "compare"))
1689 : 0 :
1690 : 6929490 : (define_predicate "extract_operator"
1691 : : (match_code "zero_extract,sign_extract"))
1692 : 6929490 :
1693 : 0 : ;; Return true if OP is a memory operand, aligned to
1694 : 0 : ;; less than its natural alignment.
1695 : 0 : (define_predicate "misaligned_operand"
1696 : : (and (match_code "mem")
1697 : 5572185 : (match_test "MEM_ALIGN (op) < GET_MODE_BITSIZE (mode)")))
1698 : 1356148 :
1699 : 50766 : ;; Return true if OP is a parallel for an mov{d,q,dqa,ps,pd} vec_select,
1700 : : ;; where one of the two operands of the vec_concat is const0_operand.
1701 : 282618 : (define_predicate "movq_parallel"
1702 : 1071284 : (match_code "parallel")
1703 : 279654 : {
1704 : 1249406 : unsigned nelt = XVECLEN (op, 0);
1705 : 1249406 : unsigned nelt2 = nelt >> 1;
1706 : 1249406 : unsigned i;
1707 : 279654 :
1708 : 1071284 : if (nelt < 2)
1709 : : return false;
1710 : :
1711 : : /* Validate that all of the elements are constants,
1712 : 7821043 : lower halves of permute are lower halves of the first operand,
1713 : 228888 : upper halves of permute come from any of the second operand. */
1714 : 13446765 : for (i = 0; i < nelt; ++i)
1715 : : {
1716 : 1579655 : rtx er = XVECEXP (op, 0, i);
1717 : 5513399 : unsigned HOST_WIDE_INT ei;
1718 : :
1719 : 5513399 : if (!CONST_INT_P (er))
1720 : : return false;
1721 : 5513399 : ei = INTVAL (er);
1722 : 1579655 : if (i < nelt2 && ei != i)
1723 : 3933744 : return false;
1724 : 630261 : if (i >= nelt2 && (ei < nelt || ei >= nelt << 1))
1725 : 3933744 : return false;
1726 : 3933744 : }
1727 : 3933744 :
1728 : 3933744 : return true;
1729 : 3933744 : })
1730 : 3933744 :
1731 : 3933744 : ;; Return true if OP is a vzeroall operation, known to be a PARALLEL.
1732 : 4954262 : (define_predicate "vzeroall_operation"
1733 : 3933744 : (match_code "parallel")
1734 : 5974780 : {
1735 : 1020518 : unsigned i, nregs = TARGET_64BIT ? 16 : 8;
1736 : 0 :
1737 : 142 : if ((unsigned) XVECLEN (op, 0) != 1 + nregs)
1738 : 3933744 : return false;
1739 : 3933744 :
1740 : 2548 : for (i = 0; i < nregs; i++)
1741 : 3933744 : {
1742 : 2264 : rtx elt = XVECEXP (op, 0, i+1);
1743 : :
1744 : 2264 : if (GET_CODE (elt) != SET
1745 : 2264 : || GET_CODE (SET_DEST (elt)) != REG
1746 : 3936008 : || GET_MODE (SET_DEST (elt)) != V8SImode
1747 : 2264 : || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
1748 : 4528 : || SET_SRC (elt) != CONST0_RTX (V8SImode))
1749 : : return false;
1750 : 949259 : }
1751 : : return true;
1752 : 949259 : })
1753 : :
1754 : 360775 : ;; return true if OP is a vzeroall pattern.
1755 : 360917 : (define_predicate "vzeroall_pattern"
1756 : 360775 : (and (match_code "parallel")
1757 : 361059 : (match_code "unspec_volatile" "a")
1758 : 277 : (match_test "XINT (XVECEXP (op, 0, 0), 1) == UNSPECV_VZEROALL")))
1759 : 0 :
1760 : 360775 : ;; return true if OP is a vzeroupper pattern.
1761 : 360775 : (define_predicate "vzeroupper_pattern"
1762 : 360775 : (and (match_code "parallel")
1763 : 249031913 : (match_code "unspec" "b")
1764 : 641598 : (match_test "XINT (XVECEXP (op, 0, 1), 1) == UNSPEC_CALLEE_ABI")
1765 : 248671138 : (match_test "INTVAL (XVECEXP (XVECEXP (op, 0, 1), 0, 0)) == ABI_VZEROUPPER")))
1766 : 0 :
1767 : 360775 : ;; Return true if OP is an addsub vec_merge operation
1768 : 360775 : (define_predicate "addsub_vm_operator"
1769 : : (match_code "vec_merge")
1770 : 4785 : {
1771 : 4785 : rtx op0, op1;
1772 : 23454014 : int swapped;
1773 : 4785 : HOST_WIDE_INT mask;
1774 : 23449229 : int nunits, elt;
1775 : :
1776 : 4785 : op0 = XEXP (op, 0);
1777 : 4785 : op1 = XEXP (op, 1);
1778 : :
1779 : : /* Sanity check. */
1780 : 4785 : if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
1781 : : swapped = 0;
1782 : 2656 : else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
1783 : : swapped = 1;
1784 : : else
1785 : 0 : gcc_unreachable ();
1786 : :
1787 : 4785 : mask = INTVAL (XEXP (op, 2));
1788 : 4785 : nunits = GET_MODE_NUNITS (mode);
1789 : :
1790 : 19589 : for (elt = 0; elt < nunits; elt++)
1791 : : {
1792 : : /* bit clear: take from op0, set: take from op1 */
1793 : 15364 : int bit = !(mask & (HOST_WIDE_INT_1U << elt));
1794 : :
1795 : 15364 : if (bit != ((elt & 1) ^ swapped))
1796 : : return false;
1797 : : }
1798 : :
1799 : : return true;
1800 : : })
1801 : :
1802 : : ;; Return true if OP is an addsub vec_select/vec_concat operation
1803 : 4785 : (define_predicate "addsub_vs_operator"
1804 : : (and (match_code "vec_select")
1805 : 4785 : (match_code "vec_concat" "0"))
1806 : 9010 : {
1807 : 4225 : rtx op0, op1;
1808 : 0 : bool swapped;
1809 : 0 : int nunits, elt;
1810 : :
1811 : 0 : op0 = XEXP (XEXP (op, 0), 0);
1812 : 0 : op1 = XEXP (XEXP (op, 0), 1);
1813 : :
1814 : : /* Sanity check. */
1815 : 0 : if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
1816 : : swapped = false;
1817 : 0 : else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
1818 : : swapped = true;
1819 : : else
1820 : 0 : gcc_unreachable ();
1821 : :
1822 : 0 : nunits = GET_MODE_NUNITS (mode);
1823 : 0 : if (XVECLEN (XEXP (op, 1), 0) != nunits)
1824 : : return false;
1825 : :
1826 : : /* We already checked that permutation is suitable for addsub,
1827 : : so only look at the first element of the parallel. */
1828 : 0 : elt = INTVAL (XVECEXP (XEXP (op, 1), 0, 0));
1829 : :
1830 : 0 : return elt == (swapped ? nunits : 0);
1831 : : })
1832 : :
1833 : : ;; Return true if OP is a parallel for an addsub vec_select.
1834 : 0 : (define_predicate "addsub_vs_parallel"
1835 : : (and (match_code "parallel")
1836 : 0 : (match_code "const_int" "a"))
1837 : 0 : {
1838 : 0 : int nelt = XVECLEN (op, 0);
1839 : 549 : int elt, i;
1840 : :
1841 : 549 : if (nelt < 2)
1842 : 549 : return false;
1843 : :
1844 : : /* Check that the permutation is suitable for addsub.
1845 : : For example, { 0 9 2 11 4 13 6 15 } or { 8 1 10 3 12 5 14 7 }. */
1846 : 549 : elt = INTVAL (XVECEXP (op, 0, 0));
1847 : 549 : if (elt == 0)
1848 : : {
1849 : 413 : for (i = 1; i < nelt; ++i)
1850 : 405 : if (INTVAL (XVECEXP (op, 0, i)) != (i + (i & 1) * nelt))
1851 : : return false;
1852 : : }
1853 : 144 : else if (elt == nelt)
1854 : : {
1855 : 0 : for (i = 1; i < nelt; ++i)
1856 : 0 : if (INTVAL (XVECEXP (op, 0, i)) != (elt + i - (i & 1) * nelt))
1857 : : return false;
1858 : : }
1859 : : else
1860 : : return false;
1861 : :
1862 : : return true;
1863 : : })
1864 : :
1865 : : ;; Return true if OP is a constant pool in perm{w,d,b} which constains index
1866 : 549 : ;; match pmov{dw,wb,qd}.
1867 : : (define_predicate "permvar_truncate_operand"
1868 : 549 : (match_code "mem")
1869 : 1098 : {
1870 : 0 : int nelt = GET_MODE_NUNITS (mode);
1871 : 16 : int perm[128];
1872 : 16 : int id;
1873 : :
1874 : 32 : if (!INTEGRAL_MODE_P (mode) || !VECTOR_MODE_P (mode))
1875 : : return false;
1876 : :
1877 : 16 : if (nelt < 2)
1878 : : return false;
1879 : :
1880 : 16 : if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
1881 : : return false;
1882 : :
1883 : 16 : id = exact_log2 (nelt);
1884 : :
1885 : : /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
1886 : : For example V16HImode to V8HImode
1887 : : { 0 2 4 6 8 10 12 14 * * * * * * * * }. */
1888 : 232 : for (int i = 0; i != nelt / 2; i++)
1889 : 216 : if ((perm[i] & ((1 << id) - 1)) != i * 2)
1890 : : return false;
1891 : :
1892 : : return true;
1893 : : })
1894 : :
1895 : : ;; Return true if OP is a constant pool in shufb which constains index
1896 : 34 : ;; match pmovdw.
1897 : : (define_predicate "pshufb_truncv4siv4hi_operand"
1898 : 16 : (match_code "mem")
1899 : 50 : {
1900 : 16 : int perm[128];
1901 : :
1902 : 8 : if (mode != E_V16QImode)
1903 : : return false;
1904 : 8 :
1905 : 8 : if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
1906 : : return false;
1907 : :
1908 : : /* Check that the permutation is suitable for pmovdw.
1909 : : For example V4SImode to V4HImode
1910 : : { 0 1 4 5 8 9 12 13 * * * * * * * * }.
1911 : : index = i % 2 + (i / 2) * 4. */
1912 : 58 : for (int i = 0; i != 8; i++)
1913 : : {
1914 : : /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0; */
1915 : 52 : if (perm[i] & 128)
1916 : : return false;
1917 : :
1918 : 52 : if ((perm[i] & 15) != ((i & 1) + (i & 0xFE) * 2))
1919 : : return false;
1920 : : }
1921 : :
1922 : : return true;
1923 : : })
1924 : :
1925 : : ;; Return true if OP is a constant pool in shufb which constains index
1926 : 11 : ;; match pmovdw.
1927 : : (define_predicate "pshufb_truncv8hiv8qi_operand"
1928 : 8 : (match_code "mem")
1929 : 17 : {
1930 : 6 : int perm[128];
1931 : :
1932 : 11 : if (mode != E_V16QImode)
1933 : : return false;
1934 : 11 :
1935 : 11 : if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
1936 : : return false;
1937 : :
1938 : : /* Check that the permutation is suitable for pmovwb.
1939 : : For example V16QImode to V8QImode
1940 : : { 0 2 4 6 8 10 12 14 * * * * * * * * }.
1941 : : index = i % 2 + (i / 2) * 4. */
1942 : 57 : for (int i = 0; i != 8; i++)
1943 : : {
1944 : : /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0; */
1945 : 52 : if (perm[i] & 128)
1946 : : return false;
1947 : :
1948 : 52 : if ((perm[i] & 15) != i * 2)
1949 : : return false;
1950 : : }
1951 : :
1952 : : return true;
1953 : : })
1954 : :
1955 : : ;; Return true if OP is a parallel for an pmovz{bw,wd,dq} vec_select,
1956 : 14 : ;; where one of the two operands of the vec_concat is const0_operand.
1957 : : (define_predicate "pmovzx_parallel"
1958 : 11 : (and (match_code "parallel")
1959 : 19 : (match_code "const_int" "a"))
1960 : 5 : {
1961 : 1056684 : int nelt = XVECLEN (op, 0);
1962 : 1056684 : int elt, i;
1963 : :
1964 : 1056684 : if (nelt < 2)
1965 : : return false;
1966 : :
1967 : : /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
1968 : : For example { 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23 }. */
1969 : 1056684 : elt = INTVAL (XVECEXP (op, 0, 0));
1970 : 1056684 : if (elt == 0)
1971 : : {
1972 : 2361634 : for (i = 1; i < nelt; ++i)
1973 : 2021691 : if ((i & 1) != 0)
1974 : : {
1975 : 1260614 : if (INTVAL (XVECEXP (op, 0, i)) < nelt)
1976 : : return false;
1977 : : }
1978 : 761077 : else if (INTVAL (XVECEXP (op, 0, i)) != i / 2)
1979 : : return false;
1980 : : }
1981 : : else
1982 : : return false;
1983 : :
1984 : : return true;
1985 : : })
1986 : :
1987 : : ;; Return true if OP is a const vector with duplicate value.
1988 : 1056684 : (define_predicate "const_vector_duplicate_operand"
1989 : : (match_code "const_vector")
1990 : 1056684 : {
1991 : 2113368 : rtx elt = XVECEXP (op, 0, 0);
1992 : 0 : int i, nelt = XVECLEN (op, 0);
1993 : :
1994 : 96 : for (i = 1; i < nelt; ++i)
1995 : 93 : if (!rtx_equal_p (elt, XVECEXP (op, 0, i)))
1996 : 3 : return false;
1997 : : return true;
1998 : : })
1999 : :
2000 : : ;; Return true if OP is a parallel for a vbroadcast permute.
2001 : 3 : (define_predicate "avx_vbroadcast_operand"
2002 : : (and (match_code "parallel")
2003 : 3 : (match_code "const_int" "a"))
2004 : 6 : {
2005 : 3 : rtx elt = XVECEXP (op, 0, 0);
2006 : 414322 : int i, nelt = XVECLEN (op, 0);
2007 : :
2008 : : /* Don't bother checking there are the right number of operands,
2009 : 414322 : merely that they're all identical. */
2010 : 501041 : for (i = 1; i < nelt; ++i)
2011 : 264538 : if (XVECEXP (op, 0, i) != elt)
2012 : : return false;
2013 : : return true;
2014 : : })
2015 : :
2016 : : ;; Return true if OP is a parallel for a palignr permute.
2017 : 414322 : (define_predicate "palignr_operand"
2018 : : (and (match_code "parallel")
2019 : 414322 : (match_code "const_int" "a"))
2020 : 828644 : {
2021 : 0 : int elt = INTVAL (XVECEXP (op, 0, 0));
2022 : 22874 : int i, nelt = XVECLEN (op, 0);
2023 : :
2024 : : /* Check that an order in the permutation is suitable for palignr.
2025 : 22874 : For example, {5 6 7 0 1 2 3 4} is "palignr 5, xmm, xmm". */
2026 : 51823 : for (i = 1; i < nelt; ++i)
2027 : 49381 : if (INTVAL (XVECEXP (op, 0, i)) != ((elt + i) % nelt))
2028 : : return false;
2029 : : return true;
2030 : : })
2031 : :
2032 : : ;; Return true if OP is a proper third operand to vpblendw256.
2033 : 22874 : (define_predicate "avx2_pblendw_operand"
2034 : : (match_code "const_int")
2035 : 22874 : {
2036 : 45748 : HOST_WIDE_INT val = INTVAL (op);
2037 : 0 : HOST_WIDE_INT low = val & 0xff;
2038 : 162 : return val == ((low << 8) | low);
2039 : : })
2040 : :
2041 : 162 : ;; Return true if OP is vector_operand or CONST_VECTOR.
2042 : 162 : (define_predicate "general_vector_operand"
2043 : : (ior (match_operand 0 "vector_operand")
2044 : 162 : (match_code "const_vector")))
2045 : 162 :
2046 : : ;; Return true if OP is either -1 constant or stored in register.
2047 : : (define_predicate "register_or_constm1_operand"
2048 : : (ior (match_operand 0 "register_operand")
2049 : 9960 : (and (match_code "const_int")
2050 : 0 : (match_test "op == constm1_rtx"))))
2051 : 9960 :
2052 : 1995 : ;; Return true if the vector ends with between 12 and 18 register saves using
2053 : : ;; RAX as the base address.
2054 : : (define_predicate "save_multiple"
2055 : 204609 : (match_code "parallel")
2056 : 1319 : {
2057 : 204609 : const unsigned len = XVECLEN (op, 0);
2058 : 1319 : unsigned i;
2059 : :
2060 : : /* Starting from end of vector, count register saves. */
2061 : 299534 : for (i = 0; i < len; ++i)
2062 : : {
2063 : 299534 : rtx src, dest, addr;
2064 : 299534 : rtx e = XVECEXP (op, 0, len - 1 - i);
2065 : :
2066 : 299534 : if (GET_CODE (e) != SET)
2067 : : break;
2068 : :
2069 : 292489 : src = SET_SRC (e);
2070 : 292489 : dest = SET_DEST (e);
2071 : :
2072 : 292489 : if (!REG_P (src) || !MEM_P (dest))
2073 : : break;
2074 : :
2075 : 94925 : addr = XEXP (dest, 0);
2076 : :
2077 : : /* Good if dest address is in RAX. */
2078 : 94925 : if (REG_P (addr) && REGNO (addr) == AX_REG)
2079 : 4223 : continue;
2080 : :
2081 : : /* Good if dest address is offset of RAX. */
2082 : 181404 : if (GET_CODE (addr) == PLUS
2083 : 90702 : && REG_P (XEXP (addr, 0))
2084 : 181404 : && REGNO (XEXP (addr, 0)) == AX_REG)
2085 : 90702 : continue;
2086 : :
2087 : : break;
2088 : : }
2089 : 204609 : return (i >= 12 && i <= 18);
2090 : : })
2091 : :
2092 : :
2093 : 204609 : ;; Return true if the vector ends with between 12 and 18 register loads using
2094 : : ;; RSI as the base address.
2095 : 409218 : (define_predicate "restore_multiple"
2096 : 204609 : (match_code "parallel")
2097 : 0 : {
2098 : 6949174 : const unsigned len = XVECLEN (op, 0);
2099 : 6949174 : unsigned i;
2100 : :
2101 : 6949174 : /* Starting from end of vector, count register restores. */
2102 : 7061442 : for (i = 0; i < len; ++i)
2103 : : {
2104 : 7061442 : rtx src, dest, addr;
2105 : 7061442 : rtx e = XVECEXP (op, 0, len - 1 - i);
2106 : :
2107 : 7061442 : if (GET_CODE (e) != SET)
2108 : : break;
2109 : :
2110 : 3600657 : src = SET_SRC (e);
2111 : 3600657 : dest = SET_DEST (e);
2112 : :
2113 : 3600657 : if (!MEM_P (src) || !REG_P (dest))
2114 : : break;
2115 : :
2116 : 1048156 : addr = XEXP (src, 0);
2117 : :
2118 : : /* Good if src address is in RSI. */
2119 : 1048156 : if (REG_P (addr) && REGNO (addr) == SI_REG)
2120 : 5352 : continue;
2121 : :
2122 : : /* Good if src address is offset of RSI. */
2123 : 1149720 : if (GET_CODE (addr) == PLUS
2124 : 694493 : && REG_P (XEXP (addr, 0))
2125 : 1663995 : && REGNO (XEXP (addr, 0)) == SI_REG)
2126 : 106916 : continue;
2127 : :
2128 : : break;
2129 : : }
2130 : 6949174 : return (i >= 12 && i <= 18);
2131 : : })
2132 : :
2133 : : ;; Keylocker specific predicates
2134 : 6949174 : (define_predicate "encodekey128_operation"
2135 : : (match_code "parallel")
2136 : 13898348 : {
2137 : 6949174 : unsigned i;
2138 : 0 : rtx elt;
2139 : :
2140 : 29 : if (XVECLEN (op, 0) != 8)
2141 : : return false;
2142 : 29 :
2143 : 80 : for(i = 0; i < 3; i++)
2144 : : {
2145 : 60 : elt = XVECEXP (op, 0, i + 1);
2146 : 60 : if (GET_CODE (elt) != SET
2147 : 60 : || GET_CODE (SET_DEST (elt)) != REG
2148 : 60 : || GET_MODE (SET_DEST (elt)) != V2DImode
2149 : 60 : || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
2150 : 60 : || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
2151 : 60 : || GET_MODE (SET_SRC (elt)) != V2DImode
2152 : 60 : || XVECLEN(SET_SRC (elt), 0) != 1
2153 : 120 : || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
2154 : : return false;
2155 : : }
2156 : :
2157 : 80 : for(i = 4; i < 7; i++)
2158 : : {
2159 : 60 : elt = XVECEXP (op, 0, i);
2160 : 60 : if (GET_CODE (elt) != CLOBBER
2161 : 60 : || GET_MODE (elt) != VOIDmode
2162 : 60 : || GET_CODE (XEXP (elt, 0)) != REG
2163 : 60 : || GET_MODE (XEXP (elt, 0)) != V2DImode
2164 : 120 : || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
2165 : : return false;
2166 : : }
2167 : :
2168 : 20 : elt = XVECEXP (op, 0, 7);
2169 : 20 : if (GET_CODE (elt) != CLOBBER
2170 : 20 : || GET_MODE (elt) != VOIDmode
2171 : 20 : || GET_CODE (XEXP (elt, 0)) != REG
2172 : 20 : || GET_MODE (XEXP (elt, 0)) != CCmode
2173 : 40 : || REGNO (XEXP (elt, 0)) != FLAGS_REG)
2174 : : return false;
2175 : : return true;
2176 : : })
2177 : :
2178 : : (define_predicate "encodekey256_operation"
2179 : 29 : (match_code "parallel")
2180 : : {
2181 : 79 : unsigned i;
2182 : 29 : rtx elt;
2183 : 0 :
2184 : 21 : if (XVECLEN (op, 0) != 9)
2185 : : return false;
2186 : :
2187 : 21 : elt = SET_SRC (XVECEXP (op, 0, 0));
2188 : 13 : elt = XVECEXP (elt, 0, 2);
2189 : 13 : if (!REG_P (elt)
2190 : 13 : || REGNO(elt) != GET_SSE_REGNO (1))
2191 : : return false;
2192 : :
2193 : 65 : for(i = 0; i < 4; i++)
2194 : : {
2195 : 52 : elt = XVECEXP (op, 0, i + 1);
2196 : 52 : if (GET_CODE (elt) != SET
2197 : 52 : || GET_CODE (SET_DEST (elt)) != REG
2198 : 52 : || GET_MODE (SET_DEST (elt)) != V2DImode
2199 : 52 : || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
2200 : 52 : || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
2201 : 52 : || GET_MODE (SET_SRC (elt)) != V2DImode
2202 : 52 : || XVECLEN(SET_SRC (elt), 0) != 1
2203 : 104 : || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
2204 : : return false;
2205 : : }
2206 : :
2207 : 52 : for(i = 4; i < 7; i++)
2208 : : {
2209 : 39 : elt = XVECEXP (op, 0, i + 1);
2210 : 39 : if (GET_CODE (elt) != CLOBBER
2211 : 39 : || GET_MODE (elt) != VOIDmode
2212 : 39 : || GET_CODE (XEXP (elt, 0)) != REG
2213 : 39 : || GET_MODE (XEXP (elt, 0)) != V2DImode
2214 : 78 : || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
2215 : : return false;
2216 : : }
2217 : :
2218 : 13 : elt = XVECEXP (op, 0, 8);
2219 : 13 : if (GET_CODE (elt) != CLOBBER
2220 : 13 : || GET_MODE (elt) != VOIDmode
2221 : 13 : || GET_CODE (XEXP (elt, 0)) != REG
2222 : 13 : || GET_MODE (XEXP (elt, 0)) != CCmode
2223 : 26 : || REGNO (XEXP (elt, 0)) != FLAGS_REG)
2224 : : return false;
2225 : : return true;
2226 : : })
2227 : :
2228 : :
2229 : 21 : (define_predicate "aeswidekl_operation"
2230 : : (match_code "parallel")
2231 : 42 : {
2232 : 21 : unsigned i;
2233 : 0 : rtx elt;
2234 : :
2235 : 396 : for (i = 0; i < 8; i++)
2236 : : {
2237 : 44 : elt = XVECEXP (op, 0, i + 1);
2238 : 352 : if (GET_CODE (elt) != SET
2239 : 352 : || GET_CODE (SET_DEST (elt)) != REG
2240 : 352 : || GET_MODE (SET_DEST (elt)) != V2DImode
2241 : 352 : || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
2242 : 352 : || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
2243 : 352 : || GET_MODE (SET_SRC (elt)) != V2DImode
2244 : 352 : || XVECLEN (SET_SRC (elt), 0) != 1
2245 : 352 : || !REG_P (XVECEXP (SET_SRC (elt), 0, 0))
2246 : 704 : || REGNO (XVECEXP (SET_SRC (elt), 0, 0)) != GET_SSE_REGNO (i))
2247 : : return false;
2248 : : }
2249 : : return true;
2250 : : })
2251 : :
2252 : : ;; Return true if OP is a memory operand that can be also used in APX
2253 : 44 : ;; NDD patterns with immediate operand. With non-default address space,
2254 : : ;; segment register or address size prefix, APX NDD instruction length
2255 : 88 : ;; can exceed the 15 byte size limit.
2256 : 44 : (define_predicate "apx_ndd_memory_operand"
2257 : 0 : (match_operand 0 "memory_operand")
2258 : : {
2259 : : /* OK if immediate operand size < 4 bytes. */
2260 : 1513 : if (GET_MODE_SIZE (mode) < 4)
2261 : 1513 : return true;
2262 : :
2263 : 1339 : bool default_addr = ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (op));
2264 : 1339 : bool address_size_prefix = TARGET_X32 && Pmode == SImode;
2265 : :
2266 : 1339 : struct ix86_address parts;
2267 : 1339 : int ok;
2268 : :
2269 : 1339 : op = XEXP (op, 0);
2270 : 1339 : ok = ix86_decompose_address (op, &parts);
2271 : 1339 : gcc_assert (ok);
2272 : :
2273 : 1339 : if (default_addr)
2274 : : {
2275 : : /* Default address space. */
2276 : :
2277 : : /* Not OK with address size prefix, index register and disp. */
2278 : 621 : if (address_size_prefix
2279 : 140 : && parts.index
2280 : 14 : && parts.disp
2281 : 14 : && parts.disp != const0_rtx)
2282 : : return false;
2283 : : }
2284 : : else
2285 : : {
2286 : : /* Non-default address space. */
2287 : :
2288 : : /* Not OK without base register. */
2289 : 718 : if (!parts.base)
2290 : : return false;
2291 : :
2292 : : /* Not OK with disp and address size prefix. */
2293 : 660 : if (address_size_prefix && parts.disp)
2294 : : return false;
2295 : : }
2296 : :
2297 : : return true;
2298 : : })
2299 : :
2300 : : ;; Return true if OP is a memory operand which can be used in APX NDD
2301 : 1540 : ;; ADD with register source operand. UNSPEC_GOTNTPOFF memory operand
2302 : : ;; is allowed with APX NDD ADD only if R_X86_64_CODE_6_GOTTPOFF works.
2303 : 3053 : (define_predicate "apx_ndd_add_memory_operand"
2304 : 1513 : (match_operand 0 "memory_operand")
2305 : : {
2306 : : /* OK if "add %reg1, name@gottpoff(%rip), %reg2" is supported. */
2307 : 689 : if (HAVE_AS_R_X86_64_CODE_6_GOTTPOFF)
2308 : 689 : return true;
2309 : :
2310 : 689 : op = XEXP (op, 0);
2311 : :
2312 : : /* Disallow APX NDD ADD with UNSPEC_GOTNTPOFF. */
2313 : 689 : if (GET_CODE (op) == CONST
2314 : 6 : && GET_CODE (XEXP (op, 0)) == UNSPEC
2315 : 6 : && XINT (XEXP (op, 0), 1) == UNSPEC_GOTNTPOFF)
2316 : 2 : return false;
2317 : :
2318 : : return true;
2319 : : })
2320 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2321 : : /* (content generated from line coverage data) */
2322 : 689 : /* ... */
2323 : : /* ... */
2324 : 689 : /* ... */
2325 : 689 : /* ... */
2326 : : /* ... */
2327 : : /* ... */
2328 : : /* ... */
2329 : 926599059 : /* ... */
2330 : : /* ... */
2331 : 926599059 : /* ... */
2332 : : /* ... */
2333 : : /* ... */
2334 : : /* ... */
2335 : 0 : /* ... */
2336 : 0 : /* ... */
2337 : 0 : /* ... */
2338 : 0 : /* ... */
2339 : 541962661 : /* ... */
2340 : 541962661 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2341 : : /* (content generated from line coverage data) */
2342 : : /* ... */
2343 : 5751593 : /* ... */
2344 : : /* ... */
2345 : 135613437 : /* ... */
2346 : : /* ... */
2347 : 126889 : /* ... */
2348 : : /* ... */
2349 : 1518972 : /* ... */
2350 : : /* ... */
2351 : 1280291 : /* ... */
2352 : : /* ... */
2353 : 53080117 : /* ... */
2354 : : /* ... */
2355 : 48341563 : /* ... */
2356 : : /* ... */
2357 : 87278136 : /* ... */
2358 : : /* ... */
2359 : 38370676 : /* ... */
2360 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2361 : 105515825 : /* (content generated from line coverage data) */
2362 : : /* ... */
2363 : 65084407 : /* ... */
2364 : : /* ... */
2365 : 755 : /* ... */
2366 : : /* ... */
2367 : 0 : /* ... */
2368 : 0 : /* ... */
2369 : 0 : /* ... */
2370 : 0 : /* ... */
2371 : 0 : /* ... */
2372 : 0 : /* ... */
2373 : 0 : /* ... */
2374 : 0 : /* ... */
2375 : 0 : /* ... */
2376 : 0 : /* ... */
2377 : 0 : /* ... */
2378 : 0 : /* ... */
2379 : 0 : /* ... */
2380 : 0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2381 : 0 : /* (content generated from line coverage data) */
2382 : 0 : /* ... */
2383 : 0 : /* ... */
2384 : 0 : /* ... */
2385 : 0 : /* ... */
2386 : 0 : /* ... */
2387 : 0 : /* ... */
2388 : 0 : /* ... */
2389 : 0 : /* ... */
2390 : 0 : /* ... */
2391 : 0 : /* ... */
2392 : 0 : /* ... */
2393 : 0 : /* ... */
2394 : 0 : /* ... */
2395 : 0 : /* ... */
2396 : 0 : /* ... */
2397 : 28036704 : /* ... */
2398 : 28036704 : /* ... */
2399 : : /* ... */
2400 : 24880 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2401 : : /* (content generated from line coverage data) */
2402 : : /* ... */
2403 : 0 : /* ... */
2404 : 0 : /* ... */
2405 : 0 : /* ... */
2406 : 0 : /* ... */
2407 : 2339954 : /* ... */
2408 : 2339954 : /* ... */
2409 : : /* ... */
2410 : : /* ... */
2411 : 301815 : /* ... */
2412 : : /* ... */
2413 : 1782291 : /* ... */
2414 : : /* ... */
2415 : 247268 : /* ... */
2416 : : /* ... */
2417 : 1346 : /* ... */
2418 : : /* ... */
2419 : 236 : /* ... */
2420 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2421 : 3576 : /* (content generated from line coverage data) */
2422 : : /* ... */
2423 : 0 : /* ... */
2424 : 0 : /* ... */
2425 : 346266403 : /* ... */
2426 : 346266403 : /* ... */
2427 : : /* ... */
2428 : : /* ... */
2429 : 9402263 : /* ... */
2430 : : /* ... */
2431 : 1046184 : /* ... */
2432 : : /* ... */
2433 : 1357662 : /* ... */
2434 : : /* ... */
2435 : 18406 : /* ... */
2436 : : /* ... */
2437 : 190296985 : /* ... */
2438 : : /* ... */
2439 : 796864 : /* ... */
2440 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2441 : 139147976 : /* (content generated from line coverage data) */
2442 : : /* ... */
2443 : 2897211 : /* ... */
2444 : : /* ... */
2445 : 337829 : /* ... */
2446 : : /* ... */
2447 : 940548 : /* ... */
2448 : : /* ... */
2449 : 0 : /* ... */
2450 : 0 : /* ... */
2451 : 0 : /* ... */
2452 : 0 : /* ... */
2453 : 0 : /* ... */
2454 : 0 : /* ... */
2455 : 0 : /* ... */
2456 : 0 : /* ... */
2457 : 0 : /* ... */
2458 : 0 : /* ... */
2459 : 0 : /* ... */
2460 : 0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2461 : 0 : /* (content generated from line coverage data) */
2462 : 0 : /* ... */
2463 : 0 : /* ... */
2464 : 0 : /* ... */
2465 : 7993337 : /* ... */
2466 : 7993337 : /* ... */
2467 : : /* ... */
2468 : : /* ... */
2469 : 938268 : /* ... */
2470 : : /* ... */
2471 : 0 : /* ... */
2472 : : /* ... */
2473 : 0 : /* ... */
2474 : : /* ... */
2475 : 0 : /* ... */
2476 : : /* ... */
2477 : 0 : /* ... */
2478 : : /* ... */
2479 : 0 : /* ... */
2480 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2481 : 137718 : /* (content generated from line coverage data) */
2482 : : /* ... */
2483 : 8406 : /* ... */
2484 : : /* ... */
2485 : 6022646 : /* ... */
2486 : : /* ... */
2487 : 150738 : /* ... */
2488 : : /* ... */
2489 : 260662 : /* ... */
2490 : : /* ... */
2491 : 3139 : /* ... */
2492 : : /* ... */
2493 : 0 : /* ... */
2494 : : /* ... */
2495 : 0 : /* ... */
2496 : 0 : /* ... */
2497 : 0 : /* ... */
2498 : 0 : /* ... */
2499 : 0 : /* ... */
2500 : 0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2501 : 0 : /* (content generated from line coverage data) */
2502 : 0 : /* ... */
2503 : 0 : /* ... */
2504 : 0 : /* ... */
2505 : 0 : /* ... */
2506 : 0 : /* ... */
2507 : 0 : /* ... */
2508 : 0 : /* ... */
2509 : 0 : /* ... */
2510 : 0 : /* ... */
2511 : 0 : /* ... */
2512 : 0 : /* ... */
2513 : 0 : /* ... */
2514 : 0 : /* ... */
2515 : 0 : /* ... */
2516 : 0 : /* ... */
2517 : 0 : /* ... */
2518 : 0 : /* ... */
2519 : 0 : /* ... */
2520 : 0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2521 : 0 : /* (content generated from line coverage data) */
2522 : 0 : /* ... */
2523 : : /* ... */
2524 : : /* ... */
2525 : 1337 : /* ... */
2526 : : /* ... */
2527 : : /* ... */
2528 : : /* ... */
2529 : : /* ... */
2530 : : /* ... */
2531 : : /* ... */
2532 : : /* ... */
2533 : : /* ... */
2534 : : /* ... */
2535 : : /* ... */
2536 : : /* ... */
2537 : : /* ... */
2538 : : /* ... */
2539 : : /* ... */
2540 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2541 : : /* (content generated from line coverage data) */
2542 : : /* ... */
2543 : : /* ... */
2544 : : /* ... */
2545 : : /* ... */
2546 : : /* ... */
2547 : : /* ... */
2548 : : /* ... */
2549 : : /* ... */
2550 : : /* ... */
2551 : : /* ... */
2552 : : /* ... */
2553 : : /* ... */
2554 : : /* ... */
2555 : : /* ... */
2556 : : /* ... */
2557 : : /* ... */
2558 : : /* ... */
2559 : : /* ... */
2560 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2561 : : /* (content generated from line coverage data) */
2562 : : /* ... */
2563 : : /* ... */
2564 : : /* ... */
2565 : : /* ... */
2566 : : /* ... */
2567 : : /* ... */
2568 : : /* ... */
2569 : : /* ... */
2570 : : /* ... */
2571 : : /* ... */
2572 : : /* ... */
2573 : : /* ... */
2574 : : /* ... */
2575 : : /* ... */
2576 : : /* ... */
2577 : : /* ... */
2578 : : /* ... */
2579 : : /* ... */
2580 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2581 : : /* (content generated from line coverage data) */
2582 : : /* ... */
2583 : : /* ... */
2584 : : /* ... */
2585 : : /* ... */
2586 : : /* ... */
2587 : : /* ... */
2588 : : /* ... */
2589 : : /* ... */
2590 : : /* ... */
2591 : : /* ... */
2592 : : /* ... */
2593 : : /* ... */
2594 : : /* ... */
2595 : : /* ... */
2596 : : /* ... */
2597 : : /* ... */
2598 : : /* ... */
2599 : : /* ... */
2600 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2601 : : /* (content generated from line coverage data) */
2602 : : /* ... */
2603 : : /* ... */
2604 : : /* ... */
2605 : : /* ... */
2606 : : /* ... */
2607 : : /* ... */
2608 : : /* ... */
2609 : : /* ... */
2610 : : /* ... */
2611 : : /* ... */
2612 : : /* ... */
2613 : : /* ... */
2614 : : /* ... */
2615 : : /* ... */
2616 : : /* ... */
2617 : : /* ... */
2618 : : /* ... */
2619 : : /* ... */
2620 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2621 : : /* (content generated from line coverage data) */
2622 : : /* ... */
2623 : : /* ... */
2624 : : /* ... */
2625 : : /* ... */
2626 : : /* ... */
2627 : : /* ... */
2628 : : /* ... */
2629 : : /* ... */
2630 : : /* ... */
2631 : : /* ... */
2632 : : /* ... */
2633 : : /* ... */
2634 : : /* ... */
2635 : : /* ... */
2636 : : /* ... */
2637 : : /* ... */
2638 : : /* ... */
2639 : : /* ... */
2640 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2641 : : /* (content generated from line coverage data) */
2642 : : /* ... */
2643 : : /* ... */
2644 : : /* ... */
2645 : : /* ... */
2646 : : /* ... */
2647 : : /* ... */
2648 : : /* ... */
2649 : : /* ... */
2650 : : /* ... */
2651 : : /* ... */
2652 : : /* ... */
2653 : : /* ... */
2654 : : /* ... */
2655 : : /* ... */
2656 : : /* ... */
2657 : : /* ... */
2658 : : /* ... */
2659 : : /* ... */
2660 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2661 : : /* (content generated from line coverage data) */
2662 : : /* ... */
2663 : : /* ... */
2664 : : /* ... */
2665 : : /* ... */
2666 : : /* ... */
2667 : : /* ... */
2668 : : /* ... */
2669 : : /* ... */
2670 : : /* ... */
2671 : : /* ... */
2672 : : /* ... */
2673 : : /* ... */
2674 : : /* ... */
2675 : : /* ... */
2676 : : /* ... */
2677 : : /* ... */
2678 : : /* ... */
2679 : : /* ... */
2680 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2681 : : /* (content generated from line coverage data) */
2682 : : /* ... */
2683 : : /* ... */
2684 : : /* ... */
2685 : : /* ... */
2686 : : /* ... */
2687 : : /* ... */
2688 : : /* ... */
2689 : : /* ... */
2690 : : /* ... */
2691 : : /* ... */
2692 : : /* ... */
2693 : : /* ... */
2694 : : /* ... */
2695 : : /* ... */
2696 : : /* ... */
2697 : : /* ... */
2698 : : /* ... */
2699 : : /* ... */
2700 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2701 : : /* (content generated from line coverage data) */
2702 : : /* ... */
2703 : : /* ... */
2704 : : /* ... */
2705 : : /* ... */
2706 : : /* ... */
2707 : : /* ... */
2708 : : /* ... */
2709 : : /* ... */
2710 : : /* ... */
2711 : : /* ... */
2712 : : /* ... */
2713 : : /* ... */
2714 : : /* ... */
2715 : : /* ... */
2716 : : /* ... */
2717 : : /* ... */
2718 : : /* ... */
2719 : : /* ... */
2720 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2721 : : /* (content generated from line coverage data) */
2722 : : /* ... */
2723 : : /* ... */
2724 : : /* ... */
2725 : : /* ... */
2726 : : /* ... */
2727 : : /* ... */
2728 : : /* ... */
2729 : : /* ... */
2730 : : /* ... */
2731 : : /* ... */
2732 : : /* ... */
2733 : : /* ... */
2734 : : /* ... */
2735 : : /* ... */
2736 : : /* ... */
2737 : : /* ... */
2738 : : /* ... */
2739 : : /* ... */
2740 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2741 : : /* (content generated from line coverage data) */
2742 : : /* ... */
2743 : : /* ... */
2744 : : /* ... */
2745 : : /* ... */
2746 : : /* ... */
2747 : : /* ... */
2748 : : /* ... */
2749 : : /* ... */
2750 : : /* ... */
2751 : : /* ... */
2752 : : /* ... */
2753 : : /* ... */
2754 : : /* ... */
2755 : : /* ... */
2756 : : /* ... */
2757 : : /* ... */
2758 : : /* ... */
2759 : : /* ... */
2760 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2761 : : /* (content generated from line coverage data) */
2762 : : /* ... */
2763 : : /* ... */
2764 : : /* ... */
2765 : : /* ... */
2766 : : /* ... */
2767 : : /* ... */
2768 : : /* ... */
2769 : : /* ... */
2770 : : /* ... */
2771 : : /* ... */
2772 : : /* ... */
2773 : : /* ... */
2774 : : /* ... */
2775 : : /* ... */
2776 : : /* ... */
2777 : : /* ... */
2778 : : /* ... */
2779 : : /* ... */
2780 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2781 : : /* (content generated from line coverage data) */
2782 : : /* ... */
2783 : : /* ... */
2784 : : /* ... */
2785 : : /* ... */
2786 : : /* ... */
2787 : : /* ... */
2788 : 6906919632 : /* ... */
2789 : : /* ... */
2790 : 6906919632 : /* ... */
2791 : : /* ... */
2792 : : /* ... */
2793 : : /* ... */
2794 : 121492288 : /* ... */
2795 : : /* ... */
2796 : 48750948 : /* ... */
2797 : 26454827 : /* ... */
2798 : : /* ... */
2799 : 24679514 : /* ... */
2800 : 11757777 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2801 : 841512 : /* (content generated from line coverage data) */
2802 : 1201225 : /* ... */
2803 : 635457 : /* ... */
2804 : 1301657 : /* ... */
2805 : 210933592 : /* ... */
2806 : 82725 : /* ... */
2807 : 8498 : /* ... */
2808 : 740306 : /* ... */
2809 : 204219287 : /* ... */
2810 : 657312950 : /* ... */
2811 : 216566988 : /* ... */
2812 : 1416376880 : /* ... */
2813 : 13460 : /* ... */
2814 : 9402263 : /* ... */
2815 : 1046184 : /* ... */
2816 : 0 : /* ... */
2817 : 1357662 : /* ... */
2818 : 13502 : /* ... */
2819 : 179922456 : /* ... */
2820 : 122192 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2821 : 138978321 : /* (content generated from line coverage data) */
2822 : 2651371 : /* ... */
2823 : 295684 : /* ... */
2824 : : /* ... */
2825 : 74119 : /* ... */
2826 : 6022646 : /* ... */
2827 : : /* ... */
2828 : : /* ... */
2829 : : /* ... */
2830 : : /* ... */
2831 : : /* ... */
2832 : : /* ... */
2833 : : /* ... */
2834 : : /* ... */
2835 : : /* ... */
2836 : : /* ... */
2837 : : /* ... */
2838 : : /* ... */
2839 : : /* ... */
2840 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2841 : : /* (content generated from line coverage data) */
2842 : : /* ... */
2843 : : /* ... */
2844 : : /* ... */
2845 : : /* ... */
2846 : : /* ... */
2847 : : /* ... */
2848 : : /* ... */
2849 : : /* ... */
2850 : : /* ... */
2851 : : /* ... */
2852 : : /* ... */
2853 : : /* ... */
2854 : : /* ... */
2855 : : /* ... */
2856 : : /* ... */
2857 : : /* ... */
2858 : : /* ... */
2859 : : /* ... */
2860 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2861 : : /* (content generated from line coverage data) */
2862 : : /* ... */
2863 : : /* ... */
2864 : : /* ... */
2865 : : /* ... */
2866 : : /* ... */
2867 : : /* ... */
2868 : : /* ... */
2869 : : /* ... */
2870 : : /* ... */
2871 : : /* ... */
2872 : : /* ... */
2873 : : /* ... */
2874 : : /* ... */
2875 : : /* ... */
2876 : : /* ... */
2877 : : /* ... */
2878 : : /* ... */
2879 : : /* ... */
2880 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2881 : : /* (content generated from line coverage data) */
2882 : : /* ... */
2883 : : /* ... */
2884 : : /* ... */
2885 : : /* ... */
2886 : : /* ... */
2887 : : /* ... */
2888 : : /* ... */
2889 : : /* ... */
2890 : : /* ... */
2891 : : /* ... */
2892 : 6519108 : /* ... */
2893 : : /* ... */
2894 : 6519108 : /* ... */
2895 : : /* ... */
2896 : 1256695 : /* ... */
2897 : 1256695 : /* ... */
|
