Line data Source code
1 : ;; Predicate definitions for IA-32 and x86-64.
2 : ;; Copyright (C) 2004-2026 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 134130112 : (match_test "ANY_FP_REGNO_P (REGNO (op))")))
24 40554 :
25 : ;; Return true if OP is an i387 fp register.
26 : (define_predicate "fp_register_operand"
27 : (and (match_code "reg")
28 1546298 : (match_test "STACK_REGNO_P (REGNO (op))")))
29 1457623 :
30 441467120 : ;; True if the operand is a GENERAL class register.
31 : (define_predicate "general_reg_operand"
32 : (and (match_code "reg")
33 275472468 : (match_test "GENERAL_REGNO_P (REGNO (op))")))
34 207123731 :
35 459179307 : ;; True if the operand is an INDEX class register.
36 : (define_predicate "index_reg_operand"
37 : (and (match_code "reg")
38 674188 : (match_test "INDEX_REGNO_P (REGNO (op))")))
39 674113 :
40 674889 : ;; 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 57301459 : (match_test "GENERAL_REGNO_P (REGNO (op))")
44 63641742 : (match_operand 0 "nonimmediate_operand")))
45 79648204 :
46 : ;; True if the operand is a general operand with GENERAL class register.
47 : (define_predicate "general_gr_operand"
48 92927127 : (if_then_else (match_code "reg")
49 40369895 : (match_test "GENERAL_REGNO_P (REGNO (op))")
50 117877670 : (match_operand 0 "general_operand")))
51 :
52 : ;; True if the operand is an MMX register.
53 : (define_predicate "mmx_reg_operand"
54 39967602 : (and (match_code "reg")
55 192 : (match_test "MMX_REGNO_P (REGNO (op))")))
56 39967602 :
57 : ;; Match register operands, but include memory operands for
58 : ;; !TARGET_MMX_WITH_SSE.
59 : (define_predicate "register_mmxmem_operand"
60 644131 : (ior (match_operand 0 "register_operand")
61 12 : (and (not (match_test "TARGET_MMX_WITH_SSE"))
62 644131 : (match_operand 0 "memory_operand"))))
63 :
64 : ;; True if the operand is an SSE register.
65 160980807 : (define_predicate "sse_reg_operand"
66 : (and (match_code "reg")
67 160980807 : (match_test "SSE_REGNO_P (REGNO (op))")))
68 1704657 :
69 : ;; Return true if op is a QImode register.
70 : (define_predicate "any_QIreg_operand"
71 : (and (match_code "reg")
72 8169940 : (match_test "ANY_QI_REGNO_P (REGNO (op))")))
73 3830314 :
74 9779868 : ;; Return true if op is one of QImode registers: %[abcd][hl].
75 : (define_predicate "QIreg_operand"
76 : (and (match_code "reg")
77 2308473 : (match_test "QI_REGNO_P (REGNO (op))")))
78 2178326 :
79 6179849 : ;; Return true if op is a QImode register operand other than %[abcd][hl].
80 : (define_predicate "ext_QIreg_operand"
81 3337385 : (and (match_test "TARGET_64BIT")
82 3337688 : (match_code "reg")
83 951179 : (not (match_test "QI_REGNO_P (REGNO (op))"))))
84 3591486 :
85 : ;; Return true if op is the AX register.
86 : (define_predicate "ax_reg_operand"
87 : (and (match_code "reg")
88 23228174 : (match_test "REGNO (op) == AX_REG")))
89 0 :
90 117413628 : ;; Return true if op is the flags register.
91 : (define_special_predicate "flags_reg_operand"
92 : (and (match_code "reg")
93 115364924 : (match_test "REGNO (op) == FLAGS_REG")))
94 :
95 41550772 : ;; True if the operand is a MASK register.
96 : (define_predicate "mask_reg_operand"
97 9742763 : (and (match_code "reg")
98 4552 : (match_test "MASK_REGNO_P (REGNO (op))")))
99 9747315 :
100 : ;; Return true if op is the block scale register.
101 : (define_special_predicate "bsr0_operand"
102 : (and (match_code "reg")
103 869 : (match_test "REGNO (op) == BSR0_REG")))
104 :
105 291 : ;; Match a DI, SI or HImode register operand.
106 : (define_special_predicate "int248_register_operand"
107 575193 : (and (match_operand 0 "register_operand")
108 862935 : (ior (and (match_test "TARGET_64BIT")
109 575193 : (match_test "GET_MODE (op) == DImode"))
110 339333 : (match_test "GET_MODE (op) == SImode")
111 575193 : (match_test "GET_MODE (op) == HImode"))))
112 :
113 : ;; Match a DI, SI, HI or QImode nonimmediate_operand.
114 : (define_special_predicate "int_nonimmediate_operand"
115 386516 : (and (match_operand 0 "nonimmediate_operand")
116 451933 : (ior (and (match_test "TARGET_64BIT")
117 386516 : (match_test "GET_MODE (op) == DImode"))
118 174509 : (match_test "GET_MODE (op) == SImode")
119 : (match_test "GET_MODE (op) == HImode")
120 386516 : (match_test "GET_MODE (op) == QImode"))))
121 :
122 : ;; Match register operands, but include memory operands for TARGET_SSE_MATH.
123 : (define_predicate "register_ssemem_operand"
124 2900547 : (if_then_else
125 2900547 : (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
126 2900547 : (match_operand 0 "nonimmediate_operand")
127 : (match_operand 0 "register_operand")))
128 :
129 1082713 : ;; Match nonimmediate operands, but exclude memory operands
130 : ;; for TARGET_SSE_MATH if TARGET_MIX_SSE_I387 is not enabled.
131 1082713 : (define_predicate "nonimm_ssenomem_operand"
132 : (if_then_else
133 1082713 : (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
134 2165426 : (not (match_test "TARGET_MIX_SSE_I387")))
135 : (match_operand 0 "register_operand")
136 : (match_operand 0 "nonimmediate_operand")))
137 :
138 772669 : ;; The above predicate, suitable for x87 arithmetic operators.
139 : (define_predicate "x87nonimm_ssenomem_operand"
140 772669 : (if_then_else
141 772669 : (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
142 1545338 : (not (match_test "TARGET_MIX_SSE_I387 && X87_ENABLE_ARITH (mode)")))
143 : (match_operand 0 "register_operand")
144 : (match_operand 0 "nonimmediate_operand")))
145 :
146 35278 : ;; Match register operands, include memory operand for TARGET_SSE4_1.
147 : (define_predicate "register_sse4nonimm_operand"
148 35278 : (if_then_else (match_test "TARGET_SSE4_1")
149 : (match_operand 0 "nonimmediate_operand")
150 : (match_operand 0 "register_operand")))
151 :
152 14090 : ;; Return true if VALUE is symbol reference
153 : (define_predicate "symbol_operand"
154 14090 : (match_code "symbol_ref"))
155 14090 :
156 : ;; Return true if VALUE is an ENDBR opcode in immediate field.
157 : (define_predicate "ix86_endbr_immediate_operand"
158 : (match_code "const_int")
159 6480842843 : {
160 6480842843 : if (flag_cf_protection & CF_BRANCH)
161 : {
162 1193121225 : unsigned HOST_WIDE_INT imm = UINTVAL (op);
163 1193121225 : unsigned HOST_WIDE_INT val = TARGET_64BIT ? 0xfa1e0ff3 : 0xfb1e0ff3;
164 :
165 1193121225 : if (imm == val)
166 : return true;
167 :
168 : /* NB: Encoding is byte based. */
169 1193121017 : if (TARGET_64BIT)
170 2300145680 : for (; imm >= val; imm >>= 8)
171 1296402688 : if (imm == val)
172 : return true;
173 : }
174 :
175 : return false;
176 : })
177 :
178 : ;; Return true if VALUE can be stored in a sign extended immediate field.
179 8403731057 : (define_predicate "x86_64_immediate_operand"
180 : (match_code "const_int,symbol_ref,label_ref,const")
181 8403731057 : {
182 11498609538 : if (ix86_endbr_immediate_operand (op, VOIDmode))
183 : return false;
184 :
185 5017766444 : if (!TARGET_64BIT)
186 5204830086 : return immediate_operand (op, mode);
187 :
188 4830703053 : switch (GET_CODE (op))
189 : {
190 3957165213 : case CONST_INT:
191 3957165213 : {
192 3957165213 : HOST_WIDE_INT val = INTVAL (op);
193 3957165213 : return trunc_int_for_mode (val, SImode) == val;
194 : }
195 705775626 : case SYMBOL_REF:
196 : /* TLS symbols are not constant. */
197 705775626 : if (SYMBOL_REF_TLS_MODEL (op))
198 : return false;
199 :
200 : /* Load the external function address via the GOT slot. */
201 705739484 : if (ix86_force_load_from_GOT_p (op))
202 : return false;
203 :
204 : /* For certain code models, the symbolic references are known to fit.
205 : in CM_SMALL_PIC model we know it fits if it is local to the shared
206 : library. Don't count TLS SYMBOL_REFs here, since they should fit
207 : only if inside of UNSPEC handled below. */
208 705739382 : return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
209 705739382 : || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
210 :
211 23749986 : case LABEL_REF:
212 : /* For certain code models, the code is near as well. */
213 23749986 : return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
214 : || ix86_cmodel == CM_KERNEL);
215 :
216 144012228 : case CONST:
217 : /* We also may accept the offsetted memory references in certain
218 : special cases. */
219 144012228 : if (GET_CODE (XEXP (op, 0)) == UNSPEC)
220 736612 : switch (XINT (XEXP (op, 0), 1))
221 : {
222 : case UNSPEC_GOTPCREL:
223 : case UNSPEC_DTPOFF:
224 : case UNSPEC_GOTNTPOFF:
225 : case UNSPEC_NTPOFF:
226 : case UNSPEC_SECREL32:
227 : return true;
228 : default:
229 : break;
230 : }
231 :
232 143277126 : if (GET_CODE (XEXP (op, 0)) == PLUS)
233 : {
234 143275616 : rtx op1 = XEXP (XEXP (op, 0), 0);
235 143275616 : rtx op2 = XEXP (XEXP (op, 0), 1);
236 :
237 143275616 : if (ix86_cmodel == CM_LARGE && GET_CODE (op1) != UNSPEC)
238 : return false;
239 143275611 : if (!CONST_INT_P (op2))
240 : return false;
241 :
242 143275611 : HOST_WIDE_INT offset = INTVAL (op2);
243 143275611 : if (trunc_int_for_mode (offset, SImode) != offset)
244 : return false;
245 :
246 143270208 : switch (GET_CODE (op1))
247 : {
248 142924337 : case SYMBOL_REF:
249 : /* TLS symbols are not constant. */
250 142924337 : if (SYMBOL_REF_TLS_MODEL (op1))
251 : return false;
252 :
253 : /* Load the external function address via the GOT slot. */
254 142913801 : if (ix86_force_load_from_GOT_p (op1))
255 : return false;
256 :
257 : /* For CM_SMALL assume that latest object is 16MB before
258 : end of 31bits boundary. We may also accept pretty
259 : large negative constants knowing that all objects are
260 : in the positive half of address space. */
261 142913795 : if ((ix86_cmodel == CM_SMALL
262 266806 : || (ix86_cmodel == CM_MEDIUM
263 0 : && !SYMBOL_REF_FAR_ADDR_P (op1)))
264 142913795 : && offset < 16*1024*1024)
265 : return true;
266 : /* For CM_KERNEL we know that all object resist in the
267 : negative half of 32bits address space. We may not
268 : accept negative offsets, since they may be just off
269 : and we may accept pretty large positive ones. */
270 269751 : if (ix86_cmodel == CM_KERNEL
271 0 : && offset > 0)
272 : return true;
273 : break;
274 :
275 6026 : case LABEL_REF:
276 : /* These conditions are similar to SYMBOL_REF ones, just the
277 : constraints for code models differ. */
278 6026 : if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
279 6026 : && offset < 16*1024*1024)
280 : return true;
281 0 : if (ix86_cmodel == CM_KERNEL
282 0 : && offset > 0)
283 : return true;
284 : break;
285 :
286 339845 : case UNSPEC:
287 339845 : switch (XINT (op1, 1))
288 : {
289 : case UNSPEC_DTPOFF:
290 : case UNSPEC_NTPOFF:
291 : return true;
292 : }
293 : break;
294 :
295 : default:
296 : break;
297 : }
298 : }
299 : break;
300 :
301 0 : default:
302 0 : gcc_unreachable ();
303 : }
304 :
305 : return false;
306 : })
307 :
308 : ;; Return true if VALUE can be stored in the zero extended immediate field.
309 5508398301 : (define_predicate "x86_64_zext_immediate_operand"
310 : (match_code "const_int,symbol_ref,label_ref,const")
311 5508398301 : {
312 755826003 : if (ix86_endbr_immediate_operand (op, VOIDmode))
313 5017766695 : return false;
314 5017766695 :
315 755825855 : switch (GET_CODE (op))
316 5017766695 : {
317 5704606241 : case CONST_INT:
318 686839546 : return !(INTVAL (op) & ~HOST_WIDE_INT_C (0xffffffff));
319 :
320 62597302 : case SYMBOL_REF:
321 5017766695 : /* TLS symbols are not constant. */
322 5080363997 : if (SYMBOL_REF_TLS_MODEL (op))
323 271442492 : return false;
324 :
325 : /* Load the external function address via the GOT slot. */
326 62562031 : if (ix86_force_load_from_GOT_p (op))
327 755826003 : return false;
328 :
329 : /* For certain code models, the symbolic references are known to fit. */
330 62561930 : return (ix86_cmodel == CM_SMALL
331 62561930 : || (ix86_cmodel == CM_MEDIUM
332 218 : && !SYMBOL_REF_FAR_ADDR_P (op)));
333 :
334 2374807 : case LABEL_REF:
335 : /* For certain code models, the code is near as well. */
336 2374807 : return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
337 :
338 4014200 : case CONST:
339 : /* We also may accept the offsetted memory references in certain
340 : special cases. */
341 4014200 : if (GET_CODE (XEXP (op, 0)) == PLUS)
342 : {
343 4009558 : rtx op1 = XEXP (XEXP (op, 0), 0);
344 4009558 : rtx op2 = XEXP (XEXP (op, 0), 1);
345 :
346 4009558 : if (ix86_cmodel == CM_LARGE)
347 : return false;
348 4009556 : if (!CONST_INT_P (op2))
349 : return false;
350 :
351 4009556 : HOST_WIDE_INT offset = INTVAL (op2);
352 4009556 : if (trunc_int_for_mode (offset, SImode) != offset)
353 : return false;
354 :
355 4006723 : switch (GET_CODE (op1))
356 : {
357 4006228 : case SYMBOL_REF:
358 : /* TLS symbols are not constant. */
359 4006228 : if (SYMBOL_REF_TLS_MODEL (op1))
360 : return false;
361 :
362 : /* Load the external function address via the GOT slot. */
363 3996920 : if (ix86_force_load_from_GOT_p (op1))
364 : return false;
365 :
366 : /* For small code model we may accept pretty large positive
367 : offsets, since one bit is available for free. Negative
368 : offsets are limited by the size of NULL pointer area
369 : specified by the ABI. */
370 3996914 : if ((ix86_cmodel == CM_SMALL
371 234651 : || (ix86_cmodel == CM_MEDIUM
372 0 : && !SYMBOL_REF_FAR_ADDR_P (op1)))
373 3996914 : && offset > -0x10000)
374 : return true;
375 : /* ??? For the kernel, we may accept adjustment of
376 : -0x10000000, since we know that it will just convert
377 : negative address space to positive, but perhaps this
378 : is not worthwhile. */
379 : break;
380 :
381 0 : case LABEL_REF:
382 : /* These conditions are similar to SYMBOL_REF ones, just the
383 : constraints for code models differ. */
384 0 : if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
385 0 : && offset > -0x10000)
386 : return true;
387 : break;
388 :
389 : default:
390 : return false;
391 : }
392 : }
393 : break;
394 :
395 0 : default:
396 0 : gcc_unreachable ();
397 : }
398 : return false;
399 : })
400 :
401 : ;; Return true if VALUE is a constant integer whose negation satisfies
402 1008388345 : ;; x86_64_immediate_operand.
403 : (define_predicate "x86_64_neg_const_int_operand"
404 1008388345 : (match_code "const_int")
405 : {
406 755860377 : HOST_WIDE_INT val = -UINTVAL (op);
407 16456 : if (mode == DImode && trunc_int_for_mode (val, SImode) != val)
408 755826003 : return false;
409 33777 : if (flag_cf_protection & CF_BRANCH)
410 755826003 : {
411 13799 : unsigned HOST_WIDE_INT endbr = TARGET_64BIT ? 0xfa1e0ff3 : 0xfb1e0ff3;
412 13799 : if ((val & HOST_WIDE_INT_C (0xffffffff)) == endbr)
413 0 : return false;
414 755826003 : }
415 755826003 : return true;
416 54755020 : })
417 :
418 : ;; Return true if VALUE is a constant integer whose low and high words satisfy
419 48322 : ;; x86_64_immediate_operand.
420 34374 : (define_predicate "x86_64_hilo_int_operand"
421 82696 : (match_code "const_int,const_wide_int")
422 34374 : {
423 44285318 : switch (GET_CODE (op))
424 : {
425 44225897 : case CONST_INT:
426 44285318 : return x86_64_immediate_operand (op, mode);
427 :
428 59421 : case CONST_WIDE_INT:
429 59421 : gcc_assert (CONST_WIDE_INT_NUNITS (op) == 2);
430 59421 : return (x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op, 0)),
431 : DImode)
432 59421 : && x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op,
433 : 1)),
434 : DImode));
435 :
436 0 : default:
437 0 : gcc_unreachable ();
438 : }
439 : })
440 :
441 : ;; Return true if VALUE is a constant integer whose value is
442 44876390 : ;; x86_64_immediate_operand value zero extended from word mode to mode.
443 : (define_predicate "x86_64_dwzext_immediate_operand"
444 44876390 : (match_code "const_int,const_wide_int")
445 : {
446 3742 : if (ix86_endbr_immediate_operand (op, VOIDmode))
447 44285318 : return false;
448 44285318 :
449 3742 : switch (GET_CODE (op))
450 : {
451 1624 : case CONST_INT:
452 1624 : if (!TARGET_64BIT)
453 44285318 : return UINTVAL (op) <= HOST_WIDE_INT_UC (0xffffffff);
454 1624 : return UINTVAL (op) <= HOST_WIDE_INT_UC (0x7fffffff);
455 :
456 2118 : case CONST_WIDE_INT:
457 5860 : if (!TARGET_64BIT)
458 : return false;
459 2118 : return (CONST_WIDE_INT_NUNITS (op) == 2
460 2118 : && CONST_WIDE_INT_ELT (op, 1) == 0
461 4236 : && (trunc_int_for_mode (CONST_WIDE_INT_ELT (op, 0), SImode)
462 2118 : == (HOST_WIDE_INT) CONST_WIDE_INT_ELT (op, 0)));
463 :
464 0 : default:
465 0 : gcc_unreachable ();
466 : }
467 : })
468 :
469 : ;; Return true if OP is general operand representable on x86_64.
470 3742 : (define_predicate "x86_64_general_operand"
471 150350915 : (if_then_else (match_test "TARGET_64BIT")
472 3742 : (ior (match_operand 0 "nonimmediate_operand")
473 : (match_operand 0 "x86_64_immediate_operand"))
474 3742 : (match_operand 0 "general_operand")))
475 63245969 :
476 3742 : ;; Return true if OP's both words are general operands representable
477 63242227 : ;; on x86_64.
478 : (define_predicate "x86_64_hilo_general_operand"
479 63242227 : (if_then_else (match_test "TARGET_64BIT")
480 3742 : (ior (match_operand 0 "nonimmediate_operand")
481 3742 : (match_operand 0 "x86_64_hilo_int_operand"))
482 : (match_operand 0 "general_operand")))
483 282037 :
484 : ;; Return true if OP is non-VOIDmode general operand representable
485 150632952 : ;; on x86_64. This predicate is used in sign-extending conversion
486 : ;; operations that require non-VOIDmode immediate operands.
487 150350915 : (define_predicate "x86_64_sext_operand"
488 282037 : (and (match_test "GET_MODE (op) != VOIDmode")
489 : (match_operand 0 "x86_64_general_operand")))
490 :
491 : ;; Return true if OP is non-VOIDmode general operand. This predicate
492 11347 : ;; is used in sign-extending conversion operations that require
493 : ;; non-VOIDmode immediate operands.
494 11347 : (define_predicate "sext_operand"
495 11347 : (and (match_test "GET_MODE (op) != VOIDmode")
496 : (match_operand 0 "general_operand")))
497 :
498 : ;; Return true if OP is representable on x86_64 as zero-extended operand.
499 3659824 : ;; This predicate is used in zero-extending conversion operations that
500 : ;; require non-VOIDmode immediate operands.
501 3659824 : (define_predicate "x86_64_zext_operand"
502 3659824 : (if_then_else (match_test "TARGET_64BIT")
503 : (ior (match_operand 0 "nonimmediate_operand")
504 : (and (match_operand 0 "x86_64_zext_immediate_operand")
505 136001 : (match_test "GET_MODE (op) != VOIDmode")))
506 : (match_operand 0 "nonimmediate_operand")))
507 :
508 : ;; Return true if OP is general operand representable on x86_64
509 2543560 : ;; as either sign extended or zero extended constant.
510 : (define_predicate "x86_64_szext_general_operand"
511 2543560 : (if_then_else (match_test "TARGET_64BIT")
512 : (ior (match_operand 0 "nonimmediate_operand")
513 : (match_operand 0 "x86_64_immediate_operand")
514 : (match_operand 0 "x86_64_zext_immediate_operand"))
515 30542821 : (match_operand 0 "general_operand")))
516 :
517 30542821 : ;; Return true if OP is nonmemory operand representable on x86_64.
518 : (define_predicate "x86_64_nonmemory_operand"
519 30542821 : (if_then_else (match_test "TARGET_64BIT")
520 : (ior (match_operand 0 "register_operand")
521 : (match_operand 0 "x86_64_immediate_operand"))
522 : (match_operand 0 "nonmemory_operand")))
523 19819 :
524 : ;; Return true if OP is nonmemory operand representable on x86_64.
525 19819 : (define_predicate "x86_64_szext_nonmemory_operand"
526 19819 : (if_then_else (match_test "TARGET_64BIT")
527 : (ior (match_operand 0 "register_operand")
528 : (match_operand 0 "x86_64_immediate_operand")
529 : (match_operand 0 "x86_64_zext_immediate_operand"))
530 180312472 : (match_operand 0 "nonmemory_operand")))
531 :
532 : ;; Return true when operand is PIC expression that can be computed by lea
533 : ;; operation.
534 : (define_predicate "pic_32bit_operand"
535 : (match_code "const,symbol_ref,label_ref")
536 : {
537 180312472 : if (!flag_pic)
538 : return false;
539 :
540 : /* Rule out relocations that translate into 64bit constants. */
541 20912741 : if (TARGET_64BIT && GET_CODE (op) == CONST)
542 : {
543 185027 : rtx tmp = XEXP (op, 0);
544 185027 : if (GET_CODE (tmp) == PLUS && CONST_INT_P (XEXP (tmp, 1)))
545 183565 : tmp = XEXP (tmp, 0);
546 185027 : if (GET_CODE (tmp) == UNSPEC
547 1462 : && (XINT (tmp, 1) == UNSPEC_GOTOFF
548 1462 : || XINT (tmp, 1) == UNSPEC_GOT))
549 : return false;
550 : }
551 :
552 20911819 : return symbolic_operand (op, mode);
553 : })
554 :
555 : ;; Return true if OP is nonmemory operand acceptable by movabs patterns.
556 1322255601 : (define_predicate "x86_64_movabs_operand"
557 : (and (match_operand 0 "nonmemory_operand")
558 1322255601 : (not (match_operand 0 "pic_32bit_operand"))))
559 :
560 180312472 : ;; Return true if OP is either a symbol reference or a sum of a symbol
561 180312472 : ;; reference and a constant.
562 180312472 : (define_predicate "symbolic_operand"
563 180312472 : (match_code "symbol_ref,label_ref,const")
564 : {
565 21653624 : switch (GET_CODE (op))
566 : {
567 180312472 : case SYMBOL_REF:
568 180312472 : case LABEL_REF:
569 555475 : return true;
570 :
571 221765 : case CONST:
572 221765 : op = XEXP (op, 0);
573 524583147 : if (SYMBOL_REF_P (op)
574 221765 : || LABEL_REF_P (op)
575 524583147 : || (GET_CODE (op) == UNSPEC
576 8401 : && (XINT (op, 1) == UNSPEC_GOT
577 8401 : || XINT (op, 1) == UNSPEC_GOTOFF
578 697 : || XINT (op, 1) == UNSPEC_SECREL32
579 21654321 : || XINT (op, 1) == UNSPEC_PCREL
580 697 : || XINT (op, 1) == UNSPEC_GOTPCREL)))
581 : return true;
582 214033 : if (GET_CODE (op) != PLUS
583 213364 : || !CONST_INT_P (XEXP (op, 1)))
584 : return false;
585 :
586 213364 : op = XEXP (op, 0);
587 213364 : if (SYMBOL_REF_P (op)
588 213364 : || LABEL_REF_P (op))
589 : return true;
590 : /* Only @GOTOFF and @SECREL32 get offsets. */
591 2137 : if (GET_CODE (op) != UNSPEC
592 2137 : || (XINT (op, 1) != UNSPEC_GOTOFF
593 0 : && XINT (op, 1) != UNSPEC_SECREL32))
594 : return false;
595 :
596 2137 : op = XVECEXP (op, 0, 0);
597 2137 : if (SYMBOL_REF_P (op)
598 2137 : || LABEL_REF_P (op))
599 2137 : return true;
600 : return false;
601 :
602 0 : default:
603 0 : gcc_unreachable ();
604 : }
605 : })
606 :
607 : ;; Return true if OP is a symbolic operand that resolves locally.
608 31354819 : (define_predicate "local_symbolic_operand"
609 : (match_code "const,label_ref,symbol_ref")
610 31354819 : {
611 2925396 : if (GET_CODE (op) == CONST
612 16176 : && GET_CODE (XEXP (op, 0)) == PLUS
613 8529 : && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
614 8529 : op = XEXP (XEXP (op, 0), 0);
615 21653624 :
616 2925396 : if (LABEL_REF_P (op))
617 : return true;
618 :
619 2879246 : if (!SYMBOL_REF_P (op))
620 21653624 : return false;
621 1297151 :
622 2869462 : if (SYMBOL_REF_TLS_MODEL (op))
623 : return false;
624 :
625 2925396 : /* Dll-imported symbols are always external. */
626 2869462 : if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
627 : return false;
628 2869462 : if (SYMBOL_REF_LOCAL_P (op))
629 : return true;
630 :
631 : /* There is, however, a not insubstantial body of code in the rest of
632 : the compiler that assumes it can just stick the results of
633 : ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done. */
634 : /* ??? This is a hack. Should update the body of the compiler to
635 : always create a DECL an invoke targetm.encode_section_info. */
636 93664 : if (strncmp (XSTR (op, 0), internal_label_prefix,
637 : internal_label_prefix_len) == 0)
638 0 : return true;
639 :
640 : return false;
641 : })
642 :
643 : (define_predicate "local_func_symbolic_operand"
644 2934141 : (match_operand 0 "local_symbolic_operand")
645 : {
646 2934141 : if (GET_CODE (op) == CONST
647 0 : && GET_CODE (XEXP (op, 0)) == PLUS
648 0 : && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
649 0 : op = XEXP (XEXP (op, 0), 0);
650 2925396 :
651 2925408 : if (SYMBOL_REF_P (op)
652 12 : && !SYMBOL_REF_FUNCTION_P (op))
653 0 : return false;
654 :
655 2925396 : return true;
656 2925396 : })
657 2821939 :
658 : ;; Test for a legitimate @GOTOFF operand.
659 30 : ;;
660 : ;; VxWorks does not impose a fixed gap between segments; the run-time
661 42 : ;; gap can be different from the object-file gap. We therefore can't
662 12 : ;; use @GOTOFF unless we are absolutely sure that the symbol is in the
663 : ;; same segment as the GOT. Unfortunately, the flexibility of linker
664 : ;; scripts means that we can't be sure of that in general, so assume
665 : ;; @GOTOFF is not valid on VxWorks, except with the large code model.
666 2934074 : ;; The comments above seem to apply only to VxWorks releases before 7.
667 : (define_predicate "gotoff_operand"
668 2934074 : (and (ior (not (match_test "TARGET_VXWORKS_VAROFF"))
669 : (match_test "ix86_cmodel == CM_LARGE")
670 2934074 : (match_test "ix86_cmodel == CM_LARGE_PIC"))
671 : (match_operand 0 "local_symbolic_operand")))
672 :
673 : ;; Test for various thread-local symbols.
674 30008 : (define_special_predicate "tls_symbolic_operand"
675 : (and (match_code "symbol_ref")
676 30008 : (match_test "SYMBOL_REF_TLS_MODEL (op)")))
677 :
678 : (define_special_predicate "tls_modbase_operand"
679 : (and (match_code "symbol_ref")
680 72 : (match_test "op == ix86_tls_module_base ()")))
681 :
682 144 : (define_predicate "tls_address_pattern"
683 : (and (match_code "set,parallel,unspec,unspec_volatile")
684 239701054 : (match_test "ix86_tls_address_pattern_p (op)")))
685 0 :
686 239701054 : ;; Test for a pc-relative call operand
687 : (define_predicate "constant_call_address_operand"
688 239701054 : (match_code "symbol_ref")
689 375898706 : {
690 136197443 : if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC
691 136197432 : || flag_force_indirect_call
692 272393580 : || (TARGET_INDIRECT_BRANCH_REGISTER
693 1022 : && ix86_nopic_noplt_attribute_p (op)))
694 1748 : return false;
695 : if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
696 239701054 : return false;
697 : return true;
698 : })
699 :
700 : ;; True for any non-virtual and non-eliminable register. Used in places where
701 141860373 : ;; instantiation of such a register may cause the pattern to not be recognized.
702 : (define_predicate "register_no_elim_operand"
703 136197652 : (match_operand 0 "register_operand")
704 278056277 : {
705 98183869 : if (SUBREG_P (op))
706 58525 : op = SUBREG_REG (op);
707 :
708 : /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
709 20739210 : because it is guaranteed to be reloaded into one. */
710 20739210 : if (MEM_P (op))
711 : return true;
712 :
713 20739210 : return !(op == arg_pointer_rtx
714 20710864 : || op == frame_pointer_rtx
715 20708596 : || VIRTUAL_REGISTER_P (op));
716 : })
717 :
718 : ;; Similarly, but include the stack pointer. This is used
719 24725383 : ;; to prevent esp from being used as an index reg.
720 : (define_predicate "register_no_SP_operand"
721 24725383 : (match_operand 0 "register_operand")
722 20739210 : {
723 329474 : if (SUBREG_P (op))
724 7899 : op = SUBREG_REG (op);
725 :
726 329474 : /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
727 : because it is guaranteed to be reloaded into one. */
728 329474 : if (MEM_P (op))
729 : return true;
730 :
731 329474 : return !(op == arg_pointer_rtx
732 329474 : || op == frame_pointer_rtx
733 329474 : || op == stack_pointer_rtx
734 329474 : || VIRTUAL_REGISTER_P (op));
735 : })
736 :
737 : ;; P6 processors will jump to the address after the decrement when %esp
738 366343 : ;; is used as a call operand, so they will execute return address as a code.
739 : ;; See Pentium Pro errata 70, Pentium 2 errata A33 and Pentium 3 errata E17.
740 366343 :
741 329474 : (define_predicate "call_register_operand"
742 1839874 : (if_then_else (match_test "TARGET_64BIT")
743 : (match_operand 0 "register_operand")
744 : (match_operand 0 "register_no_SP_operand")))
745 1839874 :
746 17943786 : ;; Return false if this is any eliminable register. Otherwise general_operand.
747 1839874 : (define_predicate "general_no_elim_operand"
748 17943786 : (if_then_else (match_code "reg,subreg")
749 : (match_operand 0 "register_no_elim_operand")
750 : (match_operand 0 "general_operand")))
751 :
752 11605363 : ;; Return false if this is any eliminable register. Otherwise
753 : ;; register_operand or a constant.
754 11605363 : (define_predicate "nonmemory_no_elim_operand"
755 : (ior (match_operand 0 "register_no_elim_operand")
756 : (match_operand 0 "immediate_operand")))
757 :
758 630486 : ;; Test for a valid operand for indirect branch.
759 : (define_predicate "indirect_branch_operand"
760 630486 : (ior (match_operand 0 "register_operand")
761 573590 : (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
762 573563 : (not (match_test "TARGET_X32"))
763 : (match_operand 0 "memory_operand"))))
764 :
765 : ;; Return true if OP is a memory operands that can be used in sibcalls.
766 24051 : ;; Since sibcall never returns, we can only use call-clobbered register
767 : ;; as GOT base. Allow GOT slot here only with pseudo register as GOT
768 : ;; base. Properly handle sibcall over GOT slot with *sibcall_GOT_32
769 : ;; and *sibcall_value_GOT_32 patterns.
770 : (define_predicate "sibcall_memory_operand"
771 : (match_operand 0 "memory_operand")
772 : {
773 24051 : op = XEXP (op, 0);
774 24051 : if (CONSTANT_P (op))
775 : return true;
776 10510 : if (GET_CODE (op) == PLUS && REG_P (XEXP (op, 0)))
777 : {
778 9492 : int regno = REGNO (XEXP (op, 0));
779 9492 : if (!HARD_REGISTER_NUM_P (regno) || call_used_or_fixed_reg_p (regno))
780 : {
781 7768 : op = XEXP (op, 1);
782 7768 : if (GOT32_symbol_operand (op, VOIDmode))
783 : return true;
784 : }
785 : }
786 : return false;
787 : })
788 :
789 : ;; Return true if OP is a GOT memory operand.
790 1352766 : (define_predicate "GOT_memory_operand"
791 : (and (match_operand 0 "memory_operand")
792 1376817 : (match_code "const" "0")
793 24051 : (match_code "unspec" "00")
794 566 : (match_test "XINT (XEXP (XEXP (op, 0), 0), 1) == UNSPEC_GOTPCREL")))
795 :
796 : ;; Test for a valid operand for a call instruction.
797 464 : ;; Allow constant call address operands in Pmode only.
798 48696499 : (define_special_predicate "call_insn_operand"
799 464 : (ior (match_test "constant_call_address_operand
800 54857579 : (op, mode == VOIDmode ? mode : Pmode)")
801 : (match_operand 0 "call_register_operand")
802 841157 : (match_test "satisfies_constraint_Bw (op)")))
803 :
804 : ;; Similarly, but for tail calls, in which we cannot allow memory references.
805 : (define_special_predicate "sibcall_insn_operand"
806 1201394 : (ior (match_test "constant_call_address_operand
807 1362191 : (op, mode == VOIDmode ? mode : Pmode)")
808 1201394 : (match_operand 0 "register_no_elim_operand")
809 123141 : (match_test "satisfies_constraint_Bs (op)")))
810 :
811 : ;; Return true if OP is a 32-bit GOT symbol operand.
812 : (define_predicate "GOT32_symbol_operand"
813 9680 : (and (match_code "const")
814 : (match_code "unspec" "0")
815 9680 : (match_test "XINT (XEXP (op, 0), 1) == UNSPEC_GOT")))
816 0 :
817 : ;; Return true if OP is a PLTOFF symbol operand.
818 : (define_predicate "pltoff_symbol_operand"
819 : (and (match_code "const")
820 6 : (match_code "unspec" "0")
821 6 : (match_test "XINT (XEXP (op, 0), 1) == UNSPEC_PLTOFF")))
822 12 :
823 : ;; Match exactly zero.
824 : (define_predicate "const0_operand"
825 : (match_code "const_int,const_double,const_vector")
826 139590134 : {
827 139590134 : if (mode == VOIDmode)
828 21871690 : mode = GET_MODE (op);
829 139590134 : return op == CONST0_RTX (mode);
830 : })
831 :
832 : ;; Match one or a vector with all elements equal to one.
833 995320265 : (define_predicate "const1_operand"
834 : (match_code "const_int,const_double,const_vector")
835 995320265 : {
836 11765298 : if (mode == VOIDmode)
837 11702067 : mode = GET_MODE (op);
838 151355432 : return op == CONST1_RTX (mode);
839 139590134 : })
840 139590134 :
841 : ;; Match exactly -1.
842 13031500 : (define_predicate "constm1_operand"
843 : (and (match_code "const_int")
844 152621634 : (match_test "op == constm1_rtx")))
845 139590134 :
846 63639032 : ;; Match 0 or -1.
847 11765298 : (define_predicate "const0_or_m1_operand"
848 11768212 : (ior (match_operand 0 "const0_operand")
849 11765298 : (match_operand 0 "constm1_operand")))
850 2914 :
851 : ;; Match exactly eight.
852 : (define_predicate "const8_operand"
853 11765298 : (and (match_code "const_int")
854 11765298 : (match_test "INTVAL (op) == 8")))
855 10164 :
856 205152 : ;; Match exactly 128.
857 : (define_predicate "const128_operand"
858 27763969 : (and (match_code "const_int")
859 245312257 : (match_test "INTVAL (op) == 128")))
860 27763969 :
861 194406262 : ;; Match exactly 0x0FFFFFFFF in anddi as a zero-extension operation
862 : (define_predicate "const_32bit_mask"
863 2951681 : (and (match_code "const_int")
864 1955874 : (match_test "trunc_int_for_mode (INTVAL (op), DImode)
865 4907555 : == HOST_WIDE_INT_C (0xffffffff)")))
866 :
867 : ;; Match 2, 4, or 8. Used for leal multiplicands.
868 : (define_predicate "const248_operand"
869 304267 : (match_code "const_int")
870 : {
871 304267 : HOST_WIDE_INT i = INTVAL (op);
872 304267 : return i == 2 || i == 4 || i == 8;
873 : })
874 :
875 : ;; Match 1, 2, or 3. Used for lea shift amounts.
876 1041624 : (define_predicate "const123_operand"
877 : (match_code "const_int")
878 1041624 : {
879 1278483 : HOST_WIDE_INT i = INTVAL (op);
880 236859 : return i == 1 || i == 2 || i == 3;
881 : })
882 :
883 236859 : ;; Match 1, 2, 4, or 8
884 245263 : (define_predicate "const1248_operand"
885 : (match_code "const_int")
886 245263 : {
887 236859 : HOST_WIDE_INT i = INTVAL (op);
888 110168 : return i == 1 || i == 2 || i == 4 || i == 8;
889 : })
890 :
891 110168 : ;; Match 3, 5, or 9. Used for leal multiplicands.
892 546676 : (define_predicate "const359_operand"
893 : (match_code "const_int")
894 546676 : {
895 594038 : HOST_WIDE_INT i = INTVAL (op);
896 47362 : return i == 3 || i == 5 || i == 9;
897 : })
898 :
899 47362 : ;; Match 4 or 8 to 11. Used for embedded rounding.
900 227715 : (define_predicate "const_4_or_8_to_11_operand"
901 : (match_code "const_int")
902 227715 : {
903 307856 : HOST_WIDE_INT i = INTVAL (op);
904 80141 : return i == 4 || (i >= 8 && i <= 11);
905 : })
906 :
907 80141 : ;; Match 4 or 8. Used for SAE.
908 80143 : (define_predicate "const48_operand"
909 : (match_code "const_int")
910 80143 : {
911 80141 : HOST_WIDE_INT i = INTVAL (op);
912 65849 : return i == 4 || i == 8;
913 : })
914 :
915 65849 : ;; Match 0 or 1.
916 65849 : (define_predicate "const_0_to_1_operand"
917 : (and (match_code "const_int")
918 65849 : (ior (match_test "op == const0_rtx")
919 300807 : (match_test "op == const1_rtx"))))
920 :
921 : ;; Match 0 to 3.
922 : (define_predicate "const_0_to_3_operand"
923 7877825 : (and (match_code "const_int")
924 14968400 : (match_test "IN_RANGE (INTVAL (op), 0, 3)")))
925 7877825 :
926 : ;; Match 0 to 7.
927 : (define_predicate "const_0_to_7_operand"
928 790410 : (and (match_code "const_int")
929 1580805 : (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
930 790410 :
931 : ;; Match 0 to 15.
932 : (define_predicate "const_0_to_15_operand"
933 81953 : (and (match_code "const_int")
934 163890 : (match_test "IN_RANGE (INTVAL (op), 0, 15)")))
935 81953 :
936 : ;; Match 0 to 31.
937 : (define_predicate "const_0_to_31_operand"
938 57234 : (and (match_code "const_int")
939 112182 : (match_test "IN_RANGE (INTVAL (op), 0, 31)")))
940 57234 :
941 : ;; Match 0 to 63.
942 : (define_predicate "const_0_to_63_operand"
943 30848 : (and (match_code "const_int")
944 59602 : (match_test "IN_RANGE (INTVAL (op), 0, 63)")))
945 30848 :
946 : ;; Match 0 to 127.
947 : (define_predicate "const_0_to_127_operand"
948 9933 : (and (match_code "const_int")
949 18762 : (match_test "IN_RANGE (INTVAL (op), 0, 127)")))
950 9933 :
951 : ;; Match 0 to 255.
952 : (define_predicate "const_0_to_255_operand"
953 8937757 : (and (match_code "const_int")
954 17849551 : (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
955 8937757 :
956 : ;; Match (0 to 255) * 8
957 : (define_predicate "const_0_to_255_mul_8_operand"
958 510199 : (match_code "const_int")
959 : {
960 510199 : unsigned HOST_WIDE_INT val = INTVAL (op);
961 510199 : return val <= 255*8 && val % 8 == 0;
962 : })
963 :
964 : ;; Match 1 to 255 except multiples of 8
965 510201 : (define_predicate "const_0_to_255_not_mul_8_operand"
966 : (match_code "const_int")
967 510201 : {
968 9 : unsigned HOST_WIDE_INT val = INTVAL (op);
969 918111 : return val <= 255 && val % 8 != 0;
970 : })
971 :
972 918125 : ;; Return true if OP is CONST_INT >= 1 and <= 31 (a valid operand
973 918125 : ;; for shift & compare patterns, as shifting by 0 does not change flags).
974 : (define_predicate "const_1_to_31_operand"
975 918125 : (and (match_code "const_int")
976 695560 : (match_test "IN_RANGE (INTVAL (op), 1, 31)")))
977 :
978 : ;; Return true if OP is CONST_INT >= 1 and <= 63 (a valid operand
979 : ;; for 64bit shift & compare patterns, as shifting by 0 does not change flags).
980 304572 : (define_predicate "const_1_to_63_operand"
981 : (and (match_code "const_int")
982 304572 : (match_test "IN_RANGE (INTVAL (op), 1, 63)")))
983 :
984 : ;; Match 2 or 3.
985 : (define_predicate "const_2_to_3_operand"
986 73373 : (and (match_code "const_int")
987 146746 : (match_test "IN_RANGE (INTVAL (op), 2, 3)")))
988 73373 :
989 : ;; Match 4 to 5.
990 : (define_predicate "const_4_to_5_operand"
991 5339 : (and (match_code "const_int")
992 10678 : (match_test "IN_RANGE (INTVAL (op), 4, 5)")))
993 5339 :
994 : ;; Match 4 to 7.
995 : (define_predicate "const_4_to_7_operand"
996 1109537 : (and (match_code "const_int")
997 2219074 : (match_test "IN_RANGE (INTVAL (op), 4, 7)")))
998 1109537 :
999 : ;; Match 6 to 7.
1000 : (define_predicate "const_6_to_7_operand"
1001 701 : (and (match_code "const_int")
1002 1402 : (match_test "IN_RANGE (INTVAL (op), 6, 7)")))
1003 701 :
1004 : ;; Match 8 to 9.
1005 : (define_predicate "const_8_to_9_operand"
1006 513 : (and (match_code "const_int")
1007 1026 : (match_test "IN_RANGE (INTVAL (op), 8, 9)")))
1008 513 :
1009 : ;; Match 8 to 11.
1010 : (define_predicate "const_8_to_11_operand"
1011 35204 : (and (match_code "const_int")
1012 70408 : (match_test "IN_RANGE (INTVAL (op), 8, 11)")))
1013 35204 :
1014 : ;; Match 8 to 15.
1015 : (define_predicate "const_8_to_15_operand"
1016 39521 : (and (match_code "const_int")
1017 79042 : (match_test "IN_RANGE (INTVAL (op), 8, 15)")))
1018 39521 :
1019 : ;; Match 10 to 11.
1020 : (define_predicate "const_10_to_11_operand"
1021 267 : (and (match_code "const_int")
1022 534 : (match_test "IN_RANGE (INTVAL (op), 10, 11)")))
1023 267 :
1024 : ;; Match 12 to 13.
1025 : (define_predicate "const_12_to_13_operand"
1026 266 : (and (match_code "const_int")
1027 532 : (match_test "IN_RANGE (INTVAL (op), 12, 13)")))
1028 266 :
1029 : ;; Match 12 to 15.
1030 : (define_predicate "const_12_to_15_operand"
1031 23618 : (and (match_code "const_int")
1032 47236 : (match_test "IN_RANGE (INTVAL (op), 12, 15)")))
1033 23618 :
1034 : ;; Match 14 to 15.
1035 : (define_predicate "const_14_to_15_operand"
1036 266 : (and (match_code "const_int")
1037 532 : (match_test "IN_RANGE (INTVAL (op), 14, 15)")))
1038 266 :
1039 : ;; Match 16 to 19.
1040 : (define_predicate "const_16_to_19_operand"
1041 927 : (and (match_code "const_int")
1042 1854 : (match_test "IN_RANGE (INTVAL (op), 16, 19)")))
1043 927 :
1044 : ;; Match 16 to 31.
1045 : (define_predicate "const_16_to_31_operand"
1046 10187 : (and (match_code "const_int")
1047 20374 : (match_test "IN_RANGE (INTVAL (op), 16, 31)")))
1048 10187 :
1049 : ;; Match 20 to 23.
1050 : (define_predicate "const_20_to_23_operand"
1051 532 : (and (match_code "const_int")
1052 1064 : (match_test "IN_RANGE (INTVAL (op), 20, 23)")))
1053 532 :
1054 : ;; Match 24 to 27.
1055 : (define_predicate "const_24_to_27_operand"
1056 532 : (and (match_code "const_int")
1057 1064 : (match_test "IN_RANGE (INTVAL (op), 24, 27)")))
1058 532 :
1059 : ;; Match 28 to 31.
1060 : (define_predicate "const_28_to_31_operand"
1061 532 : (and (match_code "const_int")
1062 1064 : (match_test "IN_RANGE (INTVAL (op), 28, 31)")))
1063 532 :
1064 : (define_predicate "cmpps_imm_operand"
1065 : (ior (match_operand 0 "const_0_to_7_operand")
1066 4063 : (and (match_test "TARGET_AVX")
1067 : (match_operand 0 "const_0_to_31_operand"))))
1068 60925 :
1069 : ;; True if this is a constant appropriate for an increment or decrement.
1070 102949525 : (define_predicate "incdec_operand"
1071 : (match_code "const_int")
1072 : {
1073 : /* On Pentium4, the inc and dec operations causes extra dependency on flag
1074 : registers, since carry flag is not set. */
1075 102949525 : if (!TARGET_USE_INCDEC && !optimize_insn_for_size_p ())
1076 : return false;
1077 2681901 : return op == const1_rtx || op == constm1_rtx;
1078 : })
1079 :
1080 : ;; True for registers, or const_int_operand, used to vec_setm expander.
1081 128487608 : (define_predicate "vec_setm_sse41_operand"
1082 : (ior (and (match_operand 0 "register_operand")
1083 231438011 : (match_test "TARGET_SSE4_1"))
1084 102949525 : (match_code "const_int")))
1085 :
1086 : (define_predicate "vec_setm_avx2_operand"
1087 : (ior (and (match_operand 0 "register_operand")
1088 1049 : (match_test "TARGET_AVX2"))
1089 0 : (match_code "const_int")))
1090 1353 :
1091 : (define_predicate "vec_setm_mmx_operand"
1092 : (ior (and (match_operand 0 "register_operand")
1093 22 : (match_test "TARGET_SSE4_1")
1094 260 : (match_test "TARGET_MMX_WITH_SSE"))
1095 260 : (match_code "const_int")))
1096 :
1097 : ;; True for registers, or 1 or -1. Used to optimize double-word shifts.
1098 : (define_predicate "reg_or_pm1_operand"
1099 4461479 : (ior (match_operand 0 "register_operand")
1100 : (and (match_code "const_int")
1101 4461479 : (ior (match_test "op == const1_rtx")
1102 259904 : (match_test "op == constm1_rtx")))))
1103 243559 :
1104 : ;; True for expressions valid for 3-operand ternlog instructions.
1105 : (define_predicate "ternlog_operand"
1106 : (and (match_code "not,and,ior,xor")
1107 2345732 : (match_test "ix86_ternlog_operand_p (op)")))
1108 257428 :
1109 66665981 : ;; True if OP is acceptable as operand of DImode shift expander.
1110 : (define_predicate "shiftdi_operand"
1111 1387587 : (if_then_else (match_test "TARGET_64BIT")
1112 3733319 : (match_operand 0 "nonimmediate_operand")
1113 2345732 : (match_operand 0 "register_operand")))
1114 1387587 :
1115 2992636 : (define_predicate "ashldi_input_operand"
1116 646904 : (if_then_else (match_test "TARGET_64BIT")
1117 646904 : (match_operand 0 "nonimmediate_operand")
1118 : (match_operand 0 "reg_or_pm1_operand")))
1119 2345732 :
1120 588003 : ;; Return true if OP is a vector load from the constant pool with just
1121 : ;; the first element nonzero.
1122 : (define_predicate "zero_extended_scalar_load_operand"
1123 : (match_code "mem")
1124 : {
1125 588003 : unsigned n_elts;
1126 588003 : op = avoid_constant_pool_reference (op);
1127 :
1128 588003 : if (!CONST_VECTOR_P (op))
1129 : return false;
1130 :
1131 98696 : n_elts = CONST_VECTOR_NUNITS (op);
1132 :
1133 194661 : for (n_elts--; n_elts > 0; n_elts--)
1134 : {
1135 143699 : rtx elt = CONST_VECTOR_ELT (op, n_elts);
1136 287398 : if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
1137 : return false;
1138 : }
1139 : return true;
1140 : })
1141 :
1142 : /* Return true if operand is a float vector constant that is all ones. */
1143 1968781 : (define_predicate "float_vector_all_ones_operand"
1144 : (match_code "const_vector,mem")
1145 588003 : {
1146 2019743 : mode = GET_MODE (op);
1147 50962 : if (!FLOAT_MODE_P (mode)
1148 13544345 : || (MEM_P (op)
1149 11644039 : && (!SYMBOL_REF_P (XEXP (op, 0))
1150 1656302 : || !CONSTANT_POOL_ADDRESS_P (XEXP (op, 0)))))
1151 16374127 : return false;
1152 :
1153 3303775 : if (MEM_P (op))
1154 : {
1155 1403469 : op = get_pool_constant (XEXP (op, 0));
1156 1403469 : if (!CONST_VECTOR_P (op))
1157 : return false;
1158 :
1159 1403465 : if (GET_MODE (op) != mode
1160 5948 : && INTEGRAL_MODE_P (GET_MODE (op))
1161 5948 : && op == CONSTM1_RTX (GET_MODE (op)))
1162 : return true;
1163 : }
1164 :
1165 3303771 : rtx first = XVECEXP (op, 0, 0);
1166 10759196 : for (int i = 1; i != GET_MODE_NUNITS (GET_MODE (op)); i++)
1167 : {
1168 4559210 : rtx tmp = XVECEXP (op, 0, i);
1169 4559210 : if (!rtx_equal_p (tmp, first))
1170 : return false;
1171 : }
1172 820388 : if (GET_MODE (first) == E_SFmode)
1173 : {
1174 458167 : long l;
1175 458167 : REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (first), l);
1176 458167 : return (l & 0xffffffff) == 0xffffffff;
1177 : }
1178 362221 : else if (GET_MODE (first) == E_DFmode)
1179 : {
1180 355255 : long l[2];
1181 355255 : REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (first), l);
1182 355255 : return ((l[0] & 0xffffffff) == 0xffffffff
1183 355255 : && (l[1] & 0xffffffff) == 0xffffffff);
1184 : }
1185 : else
1186 : return false;
1187 : })
1188 :
1189 : /* Return true if operand is an integral vector constant that is all ones. */
1190 55943390 : (define_predicate "vector_all_ones_operand"
1191 : (and (match_code "const_vector")
1192 69714888 : (match_test "INTEGRAL_MODE_P (GET_MODE (op))")
1193 11936381 : (match_test "op == CONSTM1_RTX (GET_MODE (op))")))
1194 1113153 :
1195 16374127 : /* Return true if operand is a vector constant that is all ones. */
1196 16374127 : (define_predicate "int_float_vector_all_ones_operand"
1197 : (ior (match_operand 0 "vector_all_ones_operand")
1198 9119055 : (match_operand 0 "float_vector_all_ones_operand")
1199 0 : (match_test "op == constm1_rtx")))
1200 9119055 :
1201 16374127 : /* Return true if operand is an 128/256bit all ones vector
1202 3078 : that zero-extends to 256/512bit. */
1203 : (define_predicate "vector_all_ones_zero_extend_half_operand"
1204 12191049 : (match_code "const_vector")
1205 : {
1206 175986226 : mode = GET_MODE (op);
1207 12191049 : if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
1208 186542624 : || (GET_MODE_SIZE (mode) != 32
1209 10248581 : && GET_MODE_SIZE (mode) != 64))
1210 : return false;
1211 :
1212 478353 : int nelts = CONST_VECTOR_NUNITS (op);
1213 551996 : for (int i = 0; i != nelts; i++)
1214 : {
1215 550988 : rtx elt = CONST_VECTOR_ELT (op, i);
1216 550988 : if (i < nelts / 2
1217 1083159 : && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
1218 : return false;
1219 84749 : if (i >= nelts / 2
1220 103566 : && elt != CONST0_RTX (GET_MODE_INNER (mode)))
1221 : return false;
1222 : }
1223 : return true;
1224 : })
1225 :
1226 : /* Return true if operand is an 128bit all ones vector
1227 177390201 : that zero extends to 512bit. */
1228 : (define_predicate "vector_all_ones_zero_extend_quarter_operand"
1229 12191049 : (match_code "const_vector")
1230 177391209 : {
1231 1008 : mode = GET_MODE (op);
1232 12190041 : if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
1233 10555390 : || GET_MODE_SIZE (mode) != 64)
1234 : return false;
1235 12190041 :
1236 170317 : int nelts = CONST_VECTOR_NUNITS (op);
1237 184299 : for (int i = 0; i != nelts; i++)
1238 : {
1239 184207 : rtx elt = CONST_VECTOR_ELT (op, i);
1240 184207 : if (i < nelts / 4
1241 364860 : && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
1242 : return false;
1243 16666 : if (i >= nelts / 4
1244 20220 : && elt != CONST0_RTX (GET_MODE_INNER (mode)))
1245 : return false;
1246 : }
1247 : return true;
1248 : })
1249 :
1250 : ; Return true when OP is operand acceptable for vector memory operand.
1251 177389193 : ; Only AVX can have misaligned memory operand.
1252 : (define_predicate "vector_memory_operand"
1253 12190041 : (and (match_operand 0 "memory_operand")
1254 178481102 : (ior (match_test "TARGET_AVX")
1255 1091909 : (match_test "MEM_ALIGN (op) >= GET_MODE_ALIGNMENT (mode)"))))
1256 :
1257 : ; Return true when OP is register_operand or vector_memory_operand.
1258 : (define_predicate "vector_operand"
1259 20416873 : (ior (match_operand 0 "register_operand")
1260 : (match_operand 0 "vector_memory_operand")))
1261 20416873 :
1262 : ; Return true when OP is register_operand, vector_memory_operand
1263 : ; or const_vector.
1264 : (define_predicate "vector_or_const_vector_operand"
1265 94903 : (ior (match_operand 0 "register_operand")
1266 : (match_operand 0 "vector_memory_operand")
1267 94903 : (match_code "const_vector")))
1268 45320 :
1269 : (define_predicate "bcst_mem_operand"
1270 : (and (match_code "vec_duplicate")
1271 14397 : (and (match_test "TARGET_AVX512F")
1272 167157075 : (ior (match_test "TARGET_AVX512VL")
1273 9064 : (match_test "GET_MODE_SIZE (GET_MODE (op)) == 64")))
1274 151436 : (match_test "VALID_BCST_MODE_P (GET_MODE_INNER (GET_MODE (op)))")
1275 13457 : (match_test "GET_MODE (XEXP (op, 0))
1276 40360 : == GET_MODE_INNER (GET_MODE (op))")
1277 167171313 : (match_test "memory_operand (XEXP (op, 0), GET_MODE (XEXP (op, 0)))")))
1278 5324 :
1279 : ; Return true when OP is bcst_mem_operand or vector_memory_operand.
1280 : (define_predicate "bcst_vector_operand"
1281 : (ior (match_operand 0 "vector_operand")
1282 5398333 : (match_operand 0 "bcst_mem_operand")))
1283 :
1284 5398333 : ;; Return true when OP is either nonimmediate operand, or any
1285 : ;; CONST_VECTOR.
1286 : (define_predicate "nonimmediate_or_const_vector_operand"
1287 : (ior (match_operand 0 "nonimmediate_operand")
1288 93070 : (match_code "const_vector")))
1289 :
1290 93070 : (define_predicate "nonimmediate_or_const_vec_dup_operand"
1291 15319 : (ior (match_operand 0 "nonimmediate_operand")
1292 46 : (match_test "const_vec_duplicate_p (op)")))
1293 46 :
1294 : ;; Return true when OP is either register operand, or any
1295 94 : ;; CONST_VECTOR.
1296 : (define_predicate "reg_or_const_vector_operand"
1297 94 : (ior (match_operand 0 "register_operand")
1298 : (match_code "const_vector")))
1299 275 :
1300 173 : ;; Return true when OP is CONST_VECTOR which can be converted to a
1301 : ;; sign extended 32-bit integer.
1302 : (define_predicate "x86_64_const_vector_operand"
1303 : (match_code "const_vector")
1304 158528 : {
1305 158528 : if (mode == VOIDmode)
1306 0 : mode = GET_MODE (op);
1307 158528 : else if (GET_MODE (op) != mode)
1308 : return false;
1309 373515 : if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
1310 : return false;
1311 115512 : HOST_WIDE_INT val = ix86_convert_const_vector_to_integer (op, mode);
1312 115512 : return trunc_int_for_mode (val, SImode) == val;
1313 : })
1314 :
1315 : (define_predicate "nonimmediate_or_x86_64_const_vector_operand"
1316 982139 : (ior (match_operand 0 "nonimmediate_operand")
1317 : (match_operand 0 "x86_64_const_vector_operand")))
1318 158528 :
1319 1063902 : ;; Return true when OP is nonimmediate or standard SSE constant.
1320 81763 : (define_predicate "nonimmediate_or_sse_const_operand"
1321 : (ior (match_operand 0 "nonimmediate_operand")
1322 25350722 : (match_test "standard_sse_constant_p (op, mode)")))
1323 2848901 :
1324 6681 : ;; Return true if OP is a register or a zero.
1325 : (define_predicate "reg_or_0_operand"
1326 6681 : (ior (match_operand 0 "register_operand")
1327 397529 : (match_operand 0 "const0_operand")))
1328 :
1329 397529 : ; Return true when OP is a nonimmediate or zero.
1330 95357689 : (define_predicate "nonimm_or_0_operand"
1331 : (ior (match_operand 0 "nonimmediate_operand")
1332 117859510 : (match_operand 0 "const0_operand")))
1333 127734580 :
1334 : ; Return true when OP is a nonimmediate or zero or all ones.
1335 127734580 : (define_predicate "nonimm_or_0_or_1s_operand"
1336 : (ior (match_operand 0 "nonimmediate_operand")
1337 : (match_operand 0 "const0_operand")
1338 : (match_operand 0 "int_float_vector_all_ones_operand")))
1339 82261 :
1340 : ;; Return true for RTX codes that force SImode address.
1341 82261 : (define_predicate "SImode_address_operand"
1342 : (match_code "subreg,zero_extend,and"))
1343 :
1344 : ;; Return true if op is a valid address for LEA, and does not contain
1345 275797950 : ;; a segment override. Defined as a special predicate to allow
1346 : ;; mode-less const_int operands pass to address_operand.
1347 275797950 : (define_special_predicate "address_no_seg_operand"
1348 183196716 : (match_test "address_operand (op, VOIDmode)")
1349 67104977 : {
1350 67483560 : struct ix86_address parts;
1351 67483560 : int ok;
1352 378583 :
1353 67143257 : if (!CONST_INT_P (op)
1354 64175551 : && mode != VOIDmode
1355 64175551 : && GET_MODE (op) != mode)
1356 378583 : return false;
1357 378583 :
1358 67104913 : ok = ix86_decompose_address (op, &parts);
1359 67104913 : gcc_assert (ok);
1360 67104913 : return parts.seg == ADDR_SPACE_GENERIC;
1361 67104977 : })
1362 :
1363 : ;; Return true if op if a valid base register, displacement or
1364 116091739 : ;; sum of base register and displacement for VSIB addressing.
1365 : (define_predicate "vsib_address_operand"
1366 116130019 : (match_test "address_operand (op, VOIDmode)")
1367 77321 : {
1368 37570 : struct ix86_address parts;
1369 38280 : int ok;
1370 38280 : rtx disp;
1371 :
1372 38280 : ok = ix86_decompose_address (op, &parts);
1373 38280 : gcc_assert (ok);
1374 64148 : if (parts.index || parts.seg != ADDR_SPACE_GENERIC)
1375 25868 : return false;
1376 :
1377 : /* VSIB addressing doesn't support (%rip). */
1378 38260 : if (parts.disp)
1379 26175277 : {
1380 6329 : disp = parts.disp;
1381 6329 : if (GET_CODE (disp) == CONST)
1382 : {
1383 148 : disp = XEXP (disp, 0);
1384 148 : if (GET_CODE (disp) == PLUS)
1385 148 : disp = XEXP (disp, 0);
1386 148 : if (GET_CODE (disp) == UNSPEC)
1387 0 : switch (XINT (disp, 1))
1388 : {
1389 : case UNSPEC_GOTPCREL:
1390 : case UNSPEC_PCREL:
1391 : case UNSPEC_GOTNTPOFF:
1392 : return false;
1393 : }
1394 : }
1395 6329 : if (TARGET_64BIT
1396 6329 : && flag_pic
1397 0 : && (SYMBOL_REF_P (disp)
1398 0 : || LABEL_REF_P (disp)))
1399 0 : return false;
1400 : }
1401 :
1402 : return true;
1403 : })
1404 :
1405 : (define_predicate "vsib_mem_operator"
1406 39061 : (match_code "mem"))
1407 :
1408 39061 : ;; Return true if the rtx is known to be at least 32 bits aligned.
1409 : (define_predicate "aligned_operand"
1410 : (match_operand 0 "general_operand")
1411 : {
1412 26175277 : struct ix86_address parts;
1413 26175277 : int ok;
1414 :
1415 : /* Registers and immediate operands are always "aligned". */
1416 26175277 : if (!MEM_P (op))
1417 : return true;
1418 :
1419 : /* All patterns using aligned_operand on memory operands ends up
1420 : in promoting memory operand to 64bit and thus causing memory mismatch. */
1421 8263039 : if (TARGET_MEMORY_MISMATCH_STALL && !optimize_insn_for_size_p ())
1422 : return false;
1423 :
1424 : /* Don't even try to do any aligned optimizations with volatiles. */
1425 124497 : if (MEM_VOLATILE_P (op))
1426 : return false;
1427 :
1428 118532 : if (MEM_ALIGN (op) >= 32)
1429 : return true;
1430 :
1431 46092 : op = XEXP (op, 0);
1432 :
1433 : /* Pushes and pops are only valid on the stack pointer. */
1434 46092 : if (GET_CODE (op) == PRE_DEC
1435 46092 : || GET_CODE (op) == POST_INC)
1436 : return true;
1437 :
1438 : /* Decode the address. */
1439 46092 : ok = ix86_decompose_address (op, &parts);
1440 46092 : gcc_assert (ok);
1441 :
1442 46092 : if (parts.base && SUBREG_P (parts.base))
1443 0 : parts.base = SUBREG_REG (parts.base);
1444 46092 : if (parts.index && SUBREG_P (parts.index))
1445 0 : parts.index = SUBREG_REG (parts.index);
1446 :
1447 : /* Look for some component that isn't known to be aligned. */
1448 46092 : if (parts.index)
1449 : {
1450 3340 : if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
1451 : return false;
1452 : }
1453 42752 : if (parts.base)
1454 : {
1455 35771 : if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
1456 : return false;
1457 : }
1458 13335 : if (parts.disp)
1459 : {
1460 13335 : if (!CONST_INT_P (parts.disp)
1461 6460 : || (INTVAL (parts.disp) & 3))
1462 13037 : return false;
1463 : }
1464 :
1465 : /* Didn't find one -- this must be an aligned address. */
1466 : return true;
1467 : })
1468 :
1469 : ;; Return true if OP is memory operand with a displacement.
1470 26684023 : (define_predicate "memory_displacement_operand"
1471 : (match_operand 0 "memory_operand")
1472 52859300 : {
1473 26175277 : struct ix86_address parts;
1474 0 : int ok;
1475 :
1476 0 : ok = ix86_decompose_address (XEXP (op, 0), &parts);
1477 0 : gcc_assert (ok);
1478 0 : return parts.disp != NULL_RTX;
1479 : })
1480 :
1481 : ;; Return true if OP is memory operand with a displacement only.
1482 0 : (define_predicate "memory_displacement_only_operand"
1483 : (match_operand 0 "memory_operand")
1484 0 : {
1485 0 : struct ix86_address parts;
1486 39688588 : int ok;
1487 :
1488 39688588 : if (TARGET_64BIT)
1489 39688588 : return false;
1490 :
1491 19119002 : ok = ix86_decompose_address (XEXP (op, 0), &parts);
1492 19119002 : gcc_assert (ok);
1493 :
1494 19119002 : if (parts.base || parts.index)
1495 : return false;
1496 :
1497 239553 : return parts.disp != NULL_RTX;
1498 : })
1499 :
1500 : ;; Return true if OP is memory operand that cannot be represented
1501 61420385 : ;; by the modRM array.
1502 : (define_predicate "long_memory_operand"
1503 101108973 : (and (match_operand 0 "memory_operand")
1504 39688588 : (match_test "memory_address_length (op, false)")))
1505 :
1506 : ;; Return true if OP is a comparison operator that can be issued by fcmov.
1507 : (define_predicate "fcmov_comparison_operator"
1508 70177 : (match_operand 0 "comparison_operator")
1509 : {
1510 0 : machine_mode inmode = GET_MODE (XEXP (op, 0));
1511 70177 : enum rtx_code code = GET_CODE (op);
1512 :
1513 70177 : if (inmode == CCFPmode)
1514 9926 : code = ix86_fp_compare_code_to_integer (code);
1515 :
1516 : /* i387 supports just limited amount of conditional codes. */
1517 70177 : switch (code)
1518 : {
1519 2414 : case GEU: case LTU:
1520 2414 : if (inmode == CCCmode || inmode == CCGZmode)
1521 : return true;
1522 : /* FALLTHRU */
1523 7848 : case GTU: case LEU:
1524 7848 : if (inmode == CCmode || inmode == CCFPmode)
1525 : return true;
1526 : return false;
1527 : case ORDERED: case UNORDERED:
1528 : case EQ: case NE:
1529 : return true;
1530 : default:
1531 : return false;
1532 : }
1533 : })
1534 :
1535 : ;; Return true if OP is a comparison that can be used in the CMPSS/CMPPS insns.
1536 70177 : ;; The first set are supported directly; the second set can't be done with
1537 : ;; full IEEE support, i.e. NaNs.
1538 140354 :
1539 70177 : (define_predicate "sse_comparison_operator"
1540 : (ior (match_code "eq,ne,lt,le,unordered,unge,ungt,ordered")
1541 402521 : (and (match_test "TARGET_AVX")
1542 402521 : (match_code "ge,gt,uneq,unle,unlt,ltgt"))))
1543 516667 :
1544 : ;; SSE2 doesn't have quiet vector compare for UNLT/UNLE/UNGT/UNGE, so reject
1545 516667 : ;; them in the packed FP vec_cmp expanders when trapping math is in effect
1546 105000 : ;; and NaNs are honored
1547 :
1548 105000 : (define_predicate "ix86_fp_vec_cmp_operator"
1549 : (and (match_operand 0 "comparison_operator")
1550 : (ior (not (match_code "unlt,unle,ungt,unge"))
1551 8455 : (match_test "TARGET_AVX")
1552 15508 : (not (match_test "flag_trapping_math"))
1553 7721 : (not (match_test "HONOR_NANS (GET_MODE (XEXP (op, 0)))")))))
1554 :
1555 : (define_predicate "ix86_comparison_int_operator"
1556 : (match_code "ne,eq,ge,gt,le,lt"))
1557 218048 :
1558 : (define_predicate "ix86_comparison_uns_operator"
1559 218048 : (match_code "ne,eq,geu,gtu,leu,ltu"))
1560 :
1561 218048 : (define_predicate "bt_comparison_operator"
1562 218048 : (match_code "ne,eq"))
1563 218048 :
1564 218048 : (define_predicate "shr_comparison_operator"
1565 218048 : (match_code "gtu,leu"))
1566 218048 :
1567 218048 : (define_predicate "add_comparison_operator"
1568 : (match_code "geu,ltu"))
1569 :
1570 : (define_predicate "ieee_maxmin_comparison_operator"
1571 218048 : (match_code "lt,gt"))
1572 218048 :
1573 : ;; Return true if OP is a valid comparison operator in valid mode.
1574 : (define_predicate "ix86_comparison_operator"
1575 : (match_operand 0 "comparison_operator")
1576 113932 : {
1577 101695697 : machine_mode inmode = GET_MODE (XEXP (op, 0));
1578 113932 : enum rtx_code code = GET_CODE (op);
1579 :
1580 101809629 : if (inmode == CCFPmode)
1581 6972795 : return ix86_trivial_fp_comparison_operator (op, mode);
1582 113932 :
1583 94722902 : switch (code)
1584 113932 : {
1585 72791858 : case EQ: case NE:
1586 72677926 : if (inmode == CCGZmode)
1587 0 : return false;
1588 : return true;
1589 4349092 : case GE: case LT:
1590 4349092 : if (inmode == CCmode || inmode == CCGCmode
1591 2493994 : || inmode == CCGOCmode || inmode == CCNOmode || inmode == CCGZmode)
1592 3837050 : return true;
1593 : return false;
1594 7741902 : case GEU: case LTU:
1595 7741902 : if (inmode == CCCmode || inmode == CCGZmode)
1596 : return true;
1597 63681983 : /* FALLTHRU */
1598 10881689 : case GTU: case LEU:
1599 10881689 : if (inmode == CCmode)
1600 9651325 : return true;
1601 52409939 : return false;
1602 3520 : case ORDERED: case UNORDERED:
1603 3520 : if (inmode == CCmode)
1604 3337 : return true;
1605 52409939 : return false;
1606 52409939 : case GT: case LE:
1607 6307205 : if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
1608 5529375 : return true;
1609 : return false;
1610 834232 : default:
1611 : return false;
1612 834232 : }
1613 : })
1614 834232 :
1615 834232 : ;; Return true if OP is a valid comparison operator
1616 117356701 : ;; testing carry flag to be set.
1617 : (define_predicate "ix86_carry_flag_operator"
1618 218218166 : (match_code "ltu,unlt")
1619 101695697 : {
1620 1724248 : machine_mode inmode = GET_MODE (XEXP (op, 0));
1621 834232 : enum rtx_code code = GET_CODE (op);
1622 :
1623 890016 : if (inmode == CCFPmode)
1624 14883 : code = ix86_fp_compare_code_to_integer (code);
1625 1364020 : else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
1626 : return false;
1627 1364020 :
1628 696518 : return code == LTU;
1629 1364020 : })
1630 1364020 :
1631 1364020 : ;; Return true if OP is a valid comparison operator
1632 3755349 : ;; testing carry flag to be unset.
1633 : (define_predicate "ix86_carry_flag_unset_operator"
1634 3755349 : (match_code "geu,ge")
1635 1364020 : {
1636 1364020 : machine_mode inmode = GET_MODE (XEXP (op, 0));
1637 892395 : enum rtx_code code = GET_CODE (op);
1638 890016 :
1639 2379 : if (inmode == CCFPmode)
1640 93 : code = ix86_fp_compare_code_to_integer (code);
1641 : else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
1642 1346 : return false;
1643 890016 :
1644 438294 : return code == GEU;
1645 1346 : })
1646 1346 :
1647 : ;; Return true if this comparison only requires testing one flag bit.
1648 2606881 : ;; VCOMX/VUCOMX set ZF, SF, OF, differently from COMI/UCOMI.
1649 : (define_predicate "ix86_trivial_fp_comparison_operator"
1650 12092621 : (if_then_else (match_test "TARGET_AVX10_2")
1651 674884 : (match_code "gt,ge,unlt,unle,eq,uneq,ne,ltgt,ordered,unordered")
1652 2379 : (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered")))
1653 2379 :
1654 2379 : (define_predicate "ix86_trivial_fp_comparison_operator_xf"
1655 103075577 : (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered"))
1656 :
1657 1379880 : ;; Return true if we know how to do this comparison. Others require
1658 2379 : ;; testing more than one flag bit, and we let the generic middle-end
1659 415353 : ;; code do that.
1660 414736 : (define_predicate "ix86_fp_comparison_operator"
1661 2928298 : (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
1662 2928298 : == IX86_FPCMP_ARITH")
1663 412974 : (match_operand 0 "comparison_operator")
1664 9901093 : (match_operand 0 "ix86_trivial_fp_comparison_operator")))
1665 412974 :
1666 9901093 : (define_predicate "ix86_fp_comparison_operator_xf"
1667 1792854 : (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
1668 1379880 : == IX86_FPCMP_ARITH")
1669 : (match_operand 0 "comparison_operator")
1670 : (match_operand 0 "ix86_trivial_fp_comparison_operator_xf")))
1671 412974 :
1672 850738 : ;; Return true if we can perform this comparison on TImode operands.
1673 : (define_predicate "ix86_timode_comparison_operator"
1674 437764 : (if_then_else (match_test "TARGET_64BIT")
1675 : (match_operand 0 "ordered_comparison_operator")
1676 2515324 : (match_operand 0 "bt_comparison_operator")))
1677 :
1678 2515324 : ;; Return true if this is a valid second operand for a TImode comparison.
1679 : (define_predicate "ix86_timode_comparison_operand"
1680 157686 : (if_then_else (match_test "TARGET_64BIT")
1681 : (match_operand 0 "x86_64_general_operand")
1682 : (match_operand 0 "nonimmediate_operand")))
1683 :
1684 2047434 : ;; Nearly general operand, but accept any const_double, since we wish
1685 : ;; to be able to drop them into memory rather than have them get pulled
1686 518961 : ;; into registers.
1687 2566395 : (define_predicate "cmp_fp_expander_operand"
1688 : (ior (match_code "const_double")
1689 : (match_operand 0 "general_operand")))
1690 :
1691 5012001 : ;; Return true if this is a valid binary floating-point operation.
1692 : (define_predicate "binary_fp_operator"
1693 5012001 : (match_code "plus,minus,mult,div"))
1694 :
1695 5002898 : ;; Return true if this is a multiply operation.
1696 5002898 : (define_predicate "mult_operator"
1697 5002898 : (match_code "mult"))
1698 5002898 :
1699 5002898 : ;; Return true if this is a division operation.
1700 : (define_predicate "div_operator"
1701 : (match_code "div"))
1702 :
1703 5002898 : ;; Return true if this is an and, ior or xor operation.
1704 5002898 : (define_predicate "logic_operator"
1705 : (match_code "and,ior,xor"))
1706 :
1707 : ;; Return true if this is an and operation.
1708 17140219 : (define_predicate "and_operator"
1709 : (match_code "and"))
1710 17140219 :
1711 3457147 : ;; Return true if this is a plus, minus, and, ior or xor operation.
1712 : (define_predicate "plusminuslogic_operator"
1713 : (match_code "plus,minus,and,ior,xor"))
1714 :
1715 2772029 : ;; Return true for ARITHMETIC_P.
1716 : (define_predicate "arith_or_logical_operator"
1717 2772029 : (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div,
1718 958005 : mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert"))
1719 :
1720 : ;; Return true for COMMUTATIVE_P.
1721 : (define_predicate "commutative_operator"
1722 0 : (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax"))
1723 :
1724 0 : ;; Return true if OP is a binary operator that can be promoted to wider mode.
1725 : (define_predicate "promotable_binary_operator"
1726 0 : (ior (match_code "plus,minus,and,ior,xor,ashift")
1727 0 : (and (match_code "mult")
1728 25738785 : (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL"))))
1729 0 :
1730 : (define_predicate "compare_operator"
1731 : (match_code "compare"))
1732 :
1733 7612611 : (define_predicate "extract_high_operator"
1734 0 : (match_code "zero_extract,sign_extract,ashiftrt,lshiftrt")
1735 7612611 : {
1736 0 : return (const8_operand (XEXP (op, 1), VOIDmode)
1737 144867 : && (BINARY_P (op) || const8_operand (XEXP (op, 2), VOIDmode)));
1738 100 : })
1739 :
1740 144967 : ;; Return true if OP is a memory operand, aligned to
1741 0 : ;; less than its natural alignment.
1742 : (define_predicate "misaligned_operand"
1743 144867 : (and (match_code "mem")
1744 6326649 : (match_test "MEM_ALIGN (op) < GET_MODE_BITSIZE (mode)")))
1745 1602907 :
1746 144867 : ;; Return true if OP is a parallel for an mov{d,q,dqa,ps,pd} vec_select,
1747 545435 : ;; where one of the two operands of the vec_concat is const0_operand.
1748 144867 : (define_predicate "movq_parallel"
1749 2105877 : (match_code "parallel")
1750 540836 : {
1751 1961010 : unsigned nelt = XVECLEN (op, 0);
1752 1961010 : unsigned nelt2 = nelt >> 1;
1753 2105877 : unsigned i;
1754 144867 :
1755 1475004 : if (nelt < 2)
1756 : return false;
1757 :
1758 540836 : /* Validate that all of the elements are constants,
1759 540836 : lower halves of permute are lower halves of the first operand,
1760 : upper halves of permute come from any of the second operand. */
1761 15848615 : for (i = 0; i < nelt; ++i)
1762 : {
1763 6860720 : rtx er = XVECEXP (op, 0, i);
1764 2482774 : unsigned HOST_WIDE_INT ei;
1765 4377946 :
1766 2482774 : if (!CONST_INT_P (er))
1767 4377946 : return false;
1768 6860720 : ei = INTVAL (er);
1769 2482774 : if (i < nelt2 && ei != i)
1770 4377946 : return false;
1771 1221653 : if (i >= nelt2 && (ei < nelt || ei >= nelt << 1))
1772 4377946 : return false;
1773 4377946 : }
1774 4377946 :
1775 4377946 : return true;
1776 4377946 : })
1777 4377946 :
1778 4377946 : ;; Return true if OP is a vzeroall operation, known to be a PARALLEL.
1779 5798120 : (define_predicate "vzeroall_operation"
1780 4377946 : (match_code "parallel")
1781 7218294 : {
1782 1420193 : unsigned i, nregs = TARGET_64BIT ? 16 : 8;
1783 0 :
1784 3896 : if ((unsigned) XVECLEN (op, 0) != 1 + nregs)
1785 4377946 : return false;
1786 4377946 :
1787 69976 : for (i = 0; i < nregs; i++)
1788 : {
1789 62184 : rtx elt = XVECEXP (op, 0, i+1);
1790 :
1791 4440130 : if (GET_CODE (elt) != SET
1792 4440130 : || GET_CODE (SET_DEST (elt)) != REG
1793 62184 : || GET_MODE (SET_DEST (elt)) != V8SImode
1794 62184 : || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
1795 124368 : || SET_SRC (elt) != CONST0_RTX (V8SImode))
1796 994155 : return false;
1797 : }
1798 994155 : return true;
1799 : })
1800 339150 :
1801 339150 : ;; return true if OP is a vzeroall pattern.
1802 343046 : (define_predicate "vzeroall_pattern"
1803 339150 : (and (match_code "parallel")
1804 346942 : (match_code "unspec_volatile" "a")
1805 4009 : (match_test "XINT (XVECEXP (op, 0, 0), 1) == UNSPECV_VZEROALL")))
1806 0 :
1807 339150 : ;; return true if OP is a vzeroupper pattern.
1808 339150 : (define_predicate "vzeroupper_pattern"
1809 339150 : (and (match_code "parallel")
1810 4242109 : (match_code "unspec" "b")
1811 4642 : (match_test "XINT (XVECEXP (op, 0, 1), 1) == UNSPEC_CALLEE_ABI")
1812 4242109 : (match_test "INTVAL (XVECEXP (XVECEXP (op, 0, 1), 0, 0)) == ABI_VZEROUPPER")))
1813 0 :
1814 339150 : ;; Return true if OP is an addsub vec_merge operation
1815 : (define_predicate "addsub_vm_operator"
1816 : (match_code "vec_merge")
1817 8485 : {
1818 25747270 : rtx op0, op1;
1819 8485 : int swapped;
1820 25738785 : HOST_WIDE_INT mask;
1821 8485 : int nunits, elt;
1822 :
1823 8485 : op0 = XEXP (op, 0);
1824 8485 : op1 = XEXP (op, 1);
1825 :
1826 : /* Sanity check. */
1827 8485 : if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
1828 : swapped = 0;
1829 4328 : else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
1830 : swapped = 1;
1831 : else
1832 0 : gcc_unreachable ();
1833 :
1834 8485 : mask = INTVAL (XEXP (op, 2));
1835 8485 : nunits = GET_MODE_NUNITS (mode);
1836 :
1837 32835 : for (elt = 0; elt < nunits; elt++)
1838 : {
1839 : /* bit clear: take from op0, set: take from op1 */
1840 24593 : int bit = !(mask & (HOST_WIDE_INT_1U << elt));
1841 :
1842 24593 : if (bit != ((elt & 1) ^ swapped))
1843 : return false;
1844 : }
1845 :
1846 : return true;
1847 : })
1848 :
1849 : ;; Return true if OP is an addsub vec_select/vec_concat operation
1850 8485 : (define_predicate "addsub_vs_operator"
1851 : (and (match_code "vec_select")
1852 8485 : (match_code "vec_concat" "0"))
1853 16727 : {
1854 8242 : rtx op0, op1;
1855 0 : bool swapped;
1856 0 : int nunits, elt;
1857 :
1858 0 : op0 = XEXP (XEXP (op, 0), 0);
1859 0 : op1 = XEXP (XEXP (op, 0), 1);
1860 :
1861 : /* Sanity check. */
1862 0 : if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
1863 : swapped = false;
1864 0 : else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
1865 : swapped = true;
1866 : else
1867 0 : gcc_unreachable ();
1868 :
1869 0 : nunits = GET_MODE_NUNITS (mode);
1870 0 : if (XVECLEN (XEXP (op, 1), 0) != nunits)
1871 : return false;
1872 :
1873 : /* We already checked that permutation is suitable for addsub,
1874 : so only look at the first element of the parallel. */
1875 0 : elt = INTVAL (XVECEXP (XEXP (op, 1), 0, 0));
1876 :
1877 0 : return elt == (swapped ? nunits : 0);
1878 : })
1879 :
1880 : ;; Return true if OP is a parallel for an addsub vec_select.
1881 0 : (define_predicate "addsub_vs_parallel"
1882 : (and (match_code "parallel")
1883 0 : (match_code "const_int" "a"))
1884 0 : {
1885 0 : int nelt = XVECLEN (op, 0);
1886 492 : int elt, i;
1887 :
1888 492 : if (nelt < 2)
1889 492 : return false;
1890 :
1891 : /* Check that the permutation is suitable for addsub.
1892 : For example, { 0 9 2 11 4 13 6 15 } or { 8 1 10 3 12 5 14 7 }. */
1893 492 : elt = INTVAL (XVECEXP (op, 0, 0));
1894 492 : if (elt == 0)
1895 : {
1896 446 : for (i = 1; i < nelt; ++i)
1897 438 : if (INTVAL (XVECEXP (op, 0, i)) != (i + (i & 1) * nelt))
1898 : return false;
1899 : }
1900 54 : else if (elt == nelt)
1901 : {
1902 0 : for (i = 1; i < nelt; ++i)
1903 0 : if (INTVAL (XVECEXP (op, 0, i)) != (elt + i - (i & 1) * nelt))
1904 : return false;
1905 : }
1906 : else
1907 : return false;
1908 :
1909 : return true;
1910 : })
1911 :
1912 : ;; Return true if OP is a constant pool in perm{w,d,b} which contains index
1913 492 : ;; match pmov{dw,wb,qd}.
1914 : (define_predicate "permvar_truncate_operand"
1915 492 : (match_code "mem")
1916 984 : {
1917 0 : int nelt = GET_MODE_NUNITS (mode);
1918 16 : int perm[128];
1919 16 : int id;
1920 :
1921 32 : if (!INTEGRAL_MODE_P (mode) || !VECTOR_MODE_P (mode))
1922 : return false;
1923 :
1924 16 : if (nelt < 2)
1925 : return false;
1926 :
1927 16 : if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
1928 : return false;
1929 :
1930 16 : id = exact_log2 (nelt);
1931 :
1932 : /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
1933 : For example V16HImode to V8HImode
1934 : { 0 2 4 6 8 10 12 14 * * * * * * * * }. */
1935 232 : for (int i = 0; i != nelt / 2; i++)
1936 216 : if ((perm[i] & ((1 << id) - 1)) != i * 2)
1937 : return false;
1938 :
1939 : return true;
1940 : })
1941 :
1942 : ;; Return true if OP is a constant pool in shufb which contains index
1943 49 : ;; match pmovdw.
1944 : (define_predicate "pshufb_truncv4siv4hi_operand"
1945 16 : (match_code "mem")
1946 65 : {
1947 16 : int perm[128];
1948 :
1949 8 : if (mode != E_V16QImode)
1950 : return false;
1951 8 :
1952 8 : if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
1953 : return false;
1954 :
1955 : /* Check that the permutation is suitable for pmovdw.
1956 : For example V4SImode to V4HImode
1957 : { 0 1 4 5 8 9 12 13 * * * * * * * * }.
1958 : index = i % 2 + (i / 2) * 4. */
1959 58 : for (int i = 0; i != 8; i++)
1960 : {
1961 : /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0; */
1962 52 : if (perm[i] & 128)
1963 : return false;
1964 :
1965 52 : if ((perm[i] & 15) != ((i & 1) + (i & 0xFE) * 2))
1966 : return false;
1967 : }
1968 :
1969 : return true;
1970 : })
1971 :
1972 : ;; Return true if OP is a constant pool in shufb which contains index
1973 11 : ;; match pmovdw.
1974 : (define_predicate "pshufb_truncv8hiv8qi_operand"
1975 8 : (match_code "mem")
1976 17 : {
1977 6 : int perm[128];
1978 :
1979 11 : if (mode != E_V16QImode)
1980 : return false;
1981 11 :
1982 11 : if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
1983 : return false;
1984 :
1985 : /* Check that the permutation is suitable for pmovwb.
1986 : For example V16QImode to V8QImode
1987 : { 0 2 4 6 8 10 12 14 * * * * * * * * }.
1988 : index = i % 2 + (i / 2) * 4. */
1989 57 : for (int i = 0; i != 8; i++)
1990 : {
1991 : /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0; */
1992 52 : if (perm[i] & 128)
1993 : return false;
1994 :
1995 52 : if ((perm[i] & 15) != i * 2)
1996 : return false;
1997 : }
1998 :
1999 : return true;
2000 : })
2001 :
2002 : ;; Return true if OP is a parallel for an pmovz{bw,wd,dq} vec_select,
2003 14 : ;; where one of the two operands of the vec_concat is const0_operand.
2004 : (define_predicate "pmovzx_parallel"
2005 11 : (and (match_code "parallel")
2006 19 : (match_code "const_int" "a"))
2007 5 : {
2008 1491533 : int nelt = XVECLEN (op, 0);
2009 1491533 : int elt, i;
2010 :
2011 1491533 : if (nelt < 2)
2012 : return false;
2013 :
2014 : /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
2015 : For example { 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23 }. */
2016 1491531 : elt = INTVAL (XVECEXP (op, 0, 0));
2017 1491531 : if (elt == 0)
2018 : {
2019 3448698 : for (i = 1; i < nelt; ++i)
2020 2958357 : if ((i & 1) != 0)
2021 : {
2022 1895946 : if (INTVAL (XVECEXP (op, 0, i)) < nelt)
2023 : return false;
2024 : }
2025 1062411 : else if (INTVAL (XVECEXP (op, 0, i)) != i / 2)
2026 : return false;
2027 : }
2028 : else
2029 : return false;
2030 :
2031 : return true;
2032 : })
2033 :
2034 : ;; Return true if OP is a parallel for an insertps vec_select,
2035 1491533 : ;; where one of the two operands of the vec_concat is const0_operand.
2036 : (define_predicate "insertps_parallel"
2037 1491533 : (and (match_code "parallel")
2038 2983066 : (match_code "const_int" "a"))
2039 0 : {
2040 12632 : int i;
2041 :
2042 12632 : if (XVECLEN (op, 0) != 4)
2043 12632 : return false;
2044 :
2045 : /* One element in [0..3], and the other 3 in [4..7]. */
2046 : bool found = false;
2047 40817 : for (i = 0; i < 4; ++i)
2048 39216 : if (INTVAL (XVECEXP (op, 0, i)) < 4)
2049 : {
2050 23663 : if (found)
2051 : return false;
2052 : found = true;
2053 : }
2054 :
2055 : return found;
2056 : })
2057 :
2058 : ;; Return true if OP is a const vector with duplicate value.
2059 12632 : (define_predicate "const_vector_duplicate_operand"
2060 : (match_code "const_vector")
2061 12632 : {
2062 25264 : rtx elt = XVECEXP (op, 0, 0);
2063 0 : int i, nelt = XVECLEN (op, 0);
2064 :
2065 96 : for (i = 1; i < nelt; ++i)
2066 93 : if (!rtx_equal_p (elt, XVECEXP (op, 0, i)))
2067 3 : return false;
2068 : return true;
2069 : })
2070 :
2071 : ;; Return true if OP is a parallel for a vbroadcast permute.
2072 3 : (define_predicate "avx_vbroadcast_operand"
2073 : (and (match_code "parallel")
2074 3 : (match_code "const_int" "a"))
2075 6 : {
2076 3 : rtx elt = XVECEXP (op, 0, 0);
2077 392192 : int i, nelt = XVECLEN (op, 0);
2078 :
2079 : /* Don't bother checking there are the right number of operands,
2080 392192 : merely that they're all identical. */
2081 496661 : for (i = 1; i < nelt; ++i)
2082 281032 : if (XVECEXP (op, 0, i) != elt)
2083 : return false;
2084 : return true;
2085 : })
2086 :
2087 : ;; Return true if OP is a parallel for a vbroadcastf128 permute.
2088 392192 : (define_predicate "avx_vbroadcast128_operand"
2089 : (and (match_code "parallel")
2090 392192 : (match_code "const_int" "a"))
2091 784384 : {
2092 0 : int i, nelt = XVECLEN (op, 0);
2093 1408574 : int half = nelt / 2;
2094 :
2095 2347981 : for (i = 0; i < nelt; ++i)
2096 1408574 : {
2097 2347831 : int index = INTVAL (XVECEXP (op, 0, i));
2098 2347831 : if ((i < half && index != i)
2099 1097927 : || (i >= half && index != (i - half)))
2100 : return false;
2101 : }
2102 :
2103 : return true;
2104 : })
2105 :
2106 : ;; Return true if OP is a parallel for a palignr permute.
2107 1408574 : (define_predicate "palignr_operand"
2108 : (and (match_code "parallel")
2109 1408574 : (match_code "const_int" "a"))
2110 2817148 : {
2111 0 : int elt = INTVAL (XVECEXP (op, 0, 0));
2112 27137 : int i, nelt = XVECLEN (op, 0);
2113 :
2114 : /* Check that an order in the permutation is suitable for palignr.
2115 27137 : For example, {5 6 7 0 1 2 3 4} is "palignr 5, xmm, xmm". */
2116 63406 : for (i = 1; i < nelt; ++i)
2117 59029 : if (INTVAL (XVECEXP (op, 0, i)) != ((elt + i) % nelt))
2118 : return false;
2119 : return true;
2120 : })
2121 :
2122 : ;; Return true if OP is a proper third operand to vpblendw256.
2123 27137 : (define_predicate "avx2_pblendw_operand"
2124 : (match_code "const_int")
2125 27137 : {
2126 54274 : HOST_WIDE_INT val = INTVAL (op);
2127 0 : HOST_WIDE_INT low = val & 0xff;
2128 7033 : return val == ((low << 8) | low);
2129 : })
2130 :
2131 7033 : ;; Return true if OP is vector_operand or CONST_VECTOR.
2132 7033 : (define_predicate "general_vector_operand"
2133 : (ior (match_operand 0 "vector_operand")
2134 7033 : (match_code "const_vector")))
2135 7033 :
2136 : ;; Return true if OP is either -1 constant or stored in register.
2137 : (define_predicate "register_or_constm1_operand"
2138 : (ior (match_operand 0 "register_operand")
2139 13096 : (and (match_code "const_int")
2140 0 : (match_test "op == constm1_rtx"))))
2141 13096 :
2142 2440 : ;; Return true if the vector ends with between 12 and 18 register saves using
2143 : ;; RAX as the base address.
2144 : (define_predicate "save_multiple"
2145 228417 : (match_code "parallel")
2146 1324 : {
2147 228417 : const unsigned len = XVECLEN (op, 0);
2148 1324 : unsigned i;
2149 :
2150 : /* Starting from end of vector, count register saves. */
2151 321126 : for (i = 0; i < len; ++i)
2152 : {
2153 321126 : rtx src, dest, addr;
2154 321126 : rtx e = XVECEXP (op, 0, len - 1 - i);
2155 :
2156 321126 : if (GET_CODE (e) != SET)
2157 : break;
2158 :
2159 314081 : src = SET_SRC (e);
2160 314081 : dest = SET_DEST (e);
2161 :
2162 314081 : if (!REG_P (src) || !MEM_P (dest))
2163 : break;
2164 :
2165 92709 : addr = XEXP (dest, 0);
2166 :
2167 : /* Good if dest address is in RAX. */
2168 92709 : if (REG_P (addr) && REGNO (addr) == AX_REG)
2169 4202 : continue;
2170 :
2171 : /* Good if dest address is offset of RAX. */
2172 177014 : if (GET_CODE (addr) == PLUS
2173 88507 : && REG_P (XEXP (addr, 0))
2174 177014 : && REGNO (XEXP (addr, 0)) == AX_REG)
2175 88507 : continue;
2176 :
2177 : break;
2178 : }
2179 228417 : return (i >= 12 && i <= 18);
2180 : })
2181 :
2182 :
2183 228417 : ;; Return true if the vector ends with between 12 and 18 register loads using
2184 : ;; RSI as the base address.
2185 456834 : (define_predicate "restore_multiple"
2186 228417 : (match_code "parallel")
2187 0 : {
2188 7926693 : const unsigned len = XVECLEN (op, 0);
2189 7926693 : unsigned i;
2190 :
2191 7926693 : /* Starting from end of vector, count register restores. */
2192 8033021 : for (i = 0; i < len; ++i)
2193 : {
2194 8033021 : rtx src, dest, addr;
2195 8033021 : rtx e = XVECEXP (op, 0, len - 1 - i);
2196 :
2197 8033021 : if (GET_CODE (e) != SET)
2198 : break;
2199 :
2200 4504878 : src = SET_SRC (e);
2201 4504878 : dest = SET_DEST (e);
2202 :
2203 4504878 : if (!MEM_P (src) || !REG_P (dest))
2204 : break;
2205 :
2206 1387323 : addr = XEXP (src, 0);
2207 :
2208 : /* Good if src address is in RSI. */
2209 1387323 : if (REG_P (addr) && REGNO (addr) == SI_REG)
2210 5129 : continue;
2211 :
2212 : /* Good if src address is offset of RSI. */
2213 1483393 : if (GET_CODE (addr) == PLUS
2214 941849 : && REG_P (XEXP (addr, 0))
2215 2258429 : && REGNO (XEXP (addr, 0)) == SI_REG)
2216 101199 : continue;
2217 :
2218 : break;
2219 : }
2220 7926693 : return (i >= 12 && i <= 18);
2221 : })
2222 :
2223 : ;; Keylocker specific predicates
2224 7926693 : (define_predicate "encodekey128_operation"
2225 : (match_code "parallel")
2226 15853386 : {
2227 7926693 : unsigned i;
2228 0 : rtx elt;
2229 :
2230 108 : if (XVECLEN (op, 0) != 8)
2231 : return false;
2232 108 :
2233 392 : for(i = 0; i < 3; i++)
2234 : {
2235 294 : elt = XVECEXP (op, 0, i + 1);
2236 294 : if (GET_CODE (elt) != SET
2237 294 : || GET_CODE (SET_DEST (elt)) != REG
2238 294 : || GET_MODE (SET_DEST (elt)) != V2DImode
2239 294 : || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
2240 294 : || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
2241 294 : || GET_MODE (SET_SRC (elt)) != V2DImode
2242 294 : || XVECLEN(SET_SRC (elt), 0) != 1
2243 588 : || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
2244 : return false;
2245 : }
2246 :
2247 392 : for(i = 4; i < 7; i++)
2248 : {
2249 294 : elt = XVECEXP (op, 0, i);
2250 294 : if (GET_CODE (elt) != CLOBBER
2251 294 : || GET_MODE (elt) != VOIDmode
2252 294 : || GET_CODE (XEXP (elt, 0)) != REG
2253 294 : || GET_MODE (XEXP (elt, 0)) != V2DImode
2254 588 : || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
2255 : return false;
2256 : }
2257 :
2258 98 : elt = XVECEXP (op, 0, 7);
2259 98 : if (GET_CODE (elt) != CLOBBER
2260 98 : || GET_MODE (elt) != VOIDmode
2261 98 : || GET_CODE (XEXP (elt, 0)) != REG
2262 98 : || GET_MODE (XEXP (elt, 0)) != CCmode
2263 196 : || REGNO (XEXP (elt, 0)) != FLAGS_REG)
2264 0 : return false;
2265 : return true;
2266 : })
2267 :
2268 : (define_predicate "encodekey256_operation"
2269 108 : (match_code "parallel")
2270 : {
2271 337 : unsigned i;
2272 108 : rtx elt;
2273 0 :
2274 121 : if (XVECLEN (op, 0) != 9)
2275 : return false;
2276 :
2277 121 : elt = SET_SRC (XVECEXP (op, 0, 0));
2278 112 : elt = XVECEXP (elt, 0, 2);
2279 112 : if (!REG_P (elt)
2280 112 : || REGNO(elt) != GET_SSE_REGNO (1))
2281 : return false;
2282 :
2283 560 : for(i = 0; i < 4; i++)
2284 : {
2285 448 : elt = XVECEXP (op, 0, i + 1);
2286 448 : if (GET_CODE (elt) != SET
2287 448 : || GET_CODE (SET_DEST (elt)) != REG
2288 448 : || GET_MODE (SET_DEST (elt)) != V2DImode
2289 448 : || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
2290 448 : || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
2291 448 : || GET_MODE (SET_SRC (elt)) != V2DImode
2292 448 : || XVECLEN(SET_SRC (elt), 0) != 1
2293 896 : || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
2294 : return false;
2295 : }
2296 :
2297 448 : for(i = 4; i < 7; i++)
2298 : {
2299 336 : elt = XVECEXP (op, 0, i + 1);
2300 336 : if (GET_CODE (elt) != CLOBBER
2301 336 : || GET_MODE (elt) != VOIDmode
2302 336 : || GET_CODE (XEXP (elt, 0)) != REG
2303 336 : || GET_MODE (XEXP (elt, 0)) != V2DImode
2304 672 : || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
2305 : return false;
2306 : }
2307 :
2308 112 : elt = XVECEXP (op, 0, 8);
2309 112 : if (GET_CODE (elt) != CLOBBER
2310 112 : || GET_MODE (elt) != VOIDmode
2311 112 : || GET_CODE (XEXP (elt, 0)) != REG
2312 112 : || GET_MODE (XEXP (elt, 0)) != CCmode
2313 224 : || REGNO (XEXP (elt, 0)) != FLAGS_REG)
2314 0 : return false;
2315 : return true;
2316 : })
2317 :
2318 :
2319 121 : (define_predicate "aeswidekl_operation"
2320 : (match_code "parallel")
2321 242 : {
2322 121 : unsigned i;
2323 0 : rtx elt;
2324 :
2325 5796 : for (i = 0; i < 8; i++)
2326 : {
2327 660 : elt = XVECEXP (op, 0, i + 1);
2328 5168 : if (GET_CODE (elt) != SET
2329 5168 : || GET_CODE (SET_DEST (elt)) != REG
2330 5168 : || GET_MODE (SET_DEST (elt)) != V2DImode
2331 5168 : || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
2332 5168 : || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
2333 5168 : || GET_MODE (SET_SRC (elt)) != V2DImode
2334 5168 : || XVECLEN (SET_SRC (elt), 0) != 1
2335 5168 : || !REG_P (XVECEXP (SET_SRC (elt), 0, 0))
2336 10304 : || REGNO (XVECEXP (SET_SRC (elt), 0, 0)) != GET_SSE_REGNO (i))
2337 : return false;
2338 : }
2339 : return true;
2340 : })
2341 :
2342 : ;; Return true if OP is a memory operand that can be also used in APX
2343 660 : ;; EVEX-encoded patterns (i.e. APX NDD/NF) with immediate operand. With
2344 : ;; non-default address space, segment register or address size prefix,
2345 1320 : ;; APX EVEX-encoded instruction length can exceed the 15 byte size limit.
2346 660 : (define_predicate "apx_evex_memory_operand"
2347 0 : (match_operand 0 "memory_operand")
2348 : {
2349 : /* OK if immediate operand size < 4 bytes. */
2350 1686 : if (GET_MODE_SIZE (mode) < 4)
2351 1686 : return true;
2352 :
2353 1527 : bool default_addr = ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (op));
2354 1695 : bool address_size_prefix = TARGET_X32 && Pmode == SImode;
2355 :
2356 1527 : struct ix86_address parts;
2357 1527 : int ok;
2358 :
2359 1527 : op = XEXP (op, 0);
2360 1527 : ok = ix86_decompose_address (op, &parts);
2361 1527 : gcc_assert (ok);
2362 :
2363 1527 : if (default_addr)
2364 : {
2365 : /* Default address space. */
2366 :
2367 : /* Not OK with address size prefix, index register and disp. */
2368 691 : if (address_size_prefix
2369 168 : && parts.index
2370 42 : && parts.disp
2371 42 : && parts.disp != const0_rtx)
2372 42 : return false;
2373 : }
2374 : else
2375 : {
2376 : /* Non-default address space. */
2377 :
2378 : /* Not OK without base register. */
2379 836 : if (!parts.base)
2380 : return false;
2381 :
2382 : /* Not OK with disp and address size prefix. */
2383 668 : if (address_size_prefix && parts.disp)
2384 0 : return false;
2385 : }
2386 :
2387 : return true;
2388 : })
2389 :
2390 : ;; Return true if OP is a memory operand which can be used in APX EVEX-encoded
2391 1806 : ;; ADD patterns (i.e. APX NDD/NF) for with register source operand.
2392 : ;; UNSPEC_GOTNTPOFF memory operand is allowed with APX EVEX-encoded ADD only if
2393 3492 : ;; R_X86_64_CODE_6_GOTTPOFF works.
2394 1686 : (define_predicate "apx_evex_add_memory_operand"
2395 : (match_operand 0 "memory_operand")
2396 : {
2397 : /* OK if "add %reg1, name@gottpoff(%rip), %reg2" or
2398 : "{nf} add name@gottpoff(%rip), %reg1" are supported. */
2399 : if (HAVE_AS_R_X86_64_CODE_6_GOTTPOFF)
2400 : return true;
2401 :
2402 : op = XEXP (op, 0);
2403 :
2404 : /* Disallow APX EVEX-encoded ADD with UNSPEC_GOTNTPOFF. */
2405 : if (GET_CODE (op) == CONST
2406 : && GET_CODE (XEXP (op, 0)) == UNSPEC
2407 : && XINT (XEXP (op, 0), 1) == UNSPEC_GOTNTPOFF)
2408 : return false;
2409 :
2410 : return true;
2411 : })
2412 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2413 : /* (content generated from coverage data) */
2414 848 : /* BEGIN: function "_Z27apx_evex_add_memory_operandP7rtx_def12machine_mode" */
2415 : /* ... */
2416 848 : /* ... */
2417 848 : /* ... */
2418 : /* END: function "_Z27apx_evex_add_memory_operandP7rtx_def12machine_mode" */
2419 : /* ... */
2420 : /* ... */
2421 1011280090 : /* BEGIN: function "_Z19lookup_constraint_1PKc" */
2422 : /* ... */
2423 1011280090 : /* ... */
2424 : /* ... */
2425 : /* ... */
2426 : /* ... */
2427 0 : /* ... */
2428 0 : /* ... */
2429 0 : /* ... */
2430 0 : /* ... */
2431 0 : /* ... */
2432 0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2433 597216877 : /* (content generated from coverage data) */
2434 597216877 : /* ... */
2435 : /* ... */
2436 : /* ... */
2437 8640824 : /* ... */
2438 : /* ... */
2439 136428649 : /* ... */
2440 : /* ... */
2441 137478 : /* ... */
2442 : /* ... */
2443 1721782 : /* ... */
2444 : /* ... */
2445 1402851 : /* ... */
2446 : /* ... */
2447 57184414 : /* ... */
2448 : /* ... */
2449 52147303 : /* ... */
2450 : /* ... */
2451 102017165 : /* ... */
2452 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2453 40203422 : /* (content generated from coverage data) */
2454 : /* ... */
2455 121183987 : /* ... */
2456 : /* ... */
2457 76148175 : /* ... */
2458 : /* ... */
2459 827 : /* ... */
2460 : /* ... */
2461 0 : /* ... */
2462 0 : /* ... */
2463 0 : /* ... */
2464 0 : /* ... */
2465 0 : /* ... */
2466 0 : /* ... */
2467 0 : /* ... */
2468 0 : /* ... */
2469 0 : /* ... */
2470 0 : /* ... */
2471 0 : /* ... */
2472 0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2473 0 : /* (content generated from coverage data) */
2474 0 : /* ... */
2475 0 : /* ... */
2476 0 : /* ... */
2477 0 : /* ... */
2478 0 : /* ... */
2479 0 : /* ... */
2480 0 : /* ... */
2481 0 : /* ... */
2482 0 : /* ... */
2483 0 : /* ... */
2484 0 : /* ... */
2485 0 : /* ... */
2486 0 : /* ... */
2487 0 : /* ... */
2488 0 : /* ... */
2489 0 : /* ... */
2490 0 : /* ... */
2491 40946102 : /* ... */
2492 40946102 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2493 : /* (content generated from coverage data) */
2494 23352 : /* ... */
2495 : /* ... */
2496 : /* ... */
2497 0 : /* ... */
2498 0 : /* ... */
2499 0 : /* ... */
2500 0 : /* ... */
2501 3388483 : /* ... */
2502 3388483 : /* ... */
2503 : /* ... */
2504 : /* ... */
2505 5554 : /* ... */
2506 : /* ... */
2507 342572 : /* ... */
2508 : /* ... */
2509 2655709 : /* ... */
2510 : /* ... */
2511 299802 : /* ... */
2512 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2513 1418 : /* (content generated from coverage data) */
2514 : /* ... */
2515 240 : /* ... */
2516 : /* ... */
2517 5121 : /* ... */
2518 : /* ... */
2519 0 : /* ... */
2520 0 : /* ... */
2521 360964246 : /* ... */
2522 360964246 : /* ... */
2523 : /* ... */
2524 : /* ... */
2525 5662139 : /* ... */
2526 : /* ... */
2527 4062141 : /* ... */
2528 : /* ... */
2529 1383959 : /* ... */
2530 : /* ... */
2531 1399200 : /* ... */
2532 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2533 19926 : /* (content generated from coverage data) */
2534 : /* ... */
2535 197521686 : /* ... */
2536 : /* ... */
2537 1190865 : /* ... */
2538 : /* ... */
2539 142827522 : /* ... */
2540 : /* ... */
2541 3184013 : /* ... */
2542 : /* ... */
2543 2457793 : /* ... */
2544 : /* ... */
2545 1226778 : /* ... */
2546 : /* ... */
2547 0 : /* ... */
2548 0 : /* ... */
2549 0 : /* ... */
2550 0 : /* ... */
2551 0 : /* ... */
2552 0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2553 0 : /* (content generated from coverage data) */
2554 0 : /* ... */
2555 0 : /* ... */
2556 0 : /* ... */
2557 0 : /* ... */
2558 0 : /* ... */
2559 0 : /* ... */
2560 0 : /* ... */
2561 0 : /* ... */
2562 0 : /* ... */
2563 8764382 : /* ... */
2564 8764382 : /* ... */
2565 : /* ... */
2566 : /* ... */
2567 0 : /* ... */
2568 : /* ... */
2569 0 : /* ... */
2570 : /* ... */
2571 0 : /* ... */
2572 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2573 0 : /* (content generated from coverage data) */
2574 : /* ... */
2575 0 : /* ... */
2576 : /* ... */
2577 223760 : /* ... */
2578 : /* ... */
2579 8292 : /* ... */
2580 : /* ... */
2581 6230605 : /* ... */
2582 : /* ... */
2583 159298 : /* ... */
2584 : /* ... */
2585 271942 : /* ... */
2586 : /* ... */
2587 3543 : /* ... */
2588 : /* ... */
2589 513357 : /* ... */
2590 : /* ... */
2591 0 : /* ... */
2592 0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2593 0 : /* (content generated from coverage data) */
2594 0 : /* ... */
2595 0 : /* ... */
2596 0 : /* ... */
2597 0 : /* ... */
2598 0 : /* ... */
2599 0 : /* ... */
2600 0 : /* ... */
2601 0 : /* ... */
2602 0 : /* ... */
2603 0 : /* ... */
2604 0 : /* ... */
2605 0 : /* ... */
2606 0 : /* ... */
2607 0 : /* ... */
2608 0 : /* ... */
2609 0 : /* ... */
2610 0 : /* ... */
2611 0 : /* ... */
2612 0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2613 0 : /* (content generated from coverage data) */
2614 0 : /* ... */
2615 0 : /* ... */
2616 0 : /* ... */
2617 0 : /* ... */
2618 0 : /* ... */
2619 : /* ... */
2620 : /* ... */
2621 1337 : /* ... */
2622 : /* END: function "_Z19lookup_constraint_1PKc" */
2623 : /* ... */
2624 : /* ... */
2625 : /* ... */
2626 : /* ... */
2627 : /* ... */
2628 : /* ... */
2629 : /* ... */
2630 : /* ... */
2631 : /* ... */
2632 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2633 : /* (content generated from coverage data) */
2634 : /* ... */
2635 : /* ... */
2636 : /* ... */
2637 : /* ... */
2638 : /* ... */
2639 : /* ... */
2640 : /* ... */
2641 : /* ... */
2642 : /* ... */
2643 : /* ... */
2644 : /* ... */
2645 : /* ... */
2646 : /* ... */
2647 : /* ... */
2648 : /* ... */
2649 : /* ... */
2650 : /* ... */
2651 : /* ... */
2652 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2653 : /* (content generated from coverage data) */
2654 : /* ... */
2655 : /* ... */
2656 : /* ... */
2657 : /* ... */
2658 : /* ... */
2659 : /* ... */
2660 : /* ... */
2661 : /* ... */
2662 : /* ... */
2663 : /* ... */
2664 : /* ... */
2665 : /* ... */
2666 : /* ... */
2667 : /* ... */
2668 : /* ... */
2669 : /* ... */
2670 : /* ... */
2671 : /* ... */
2672 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2673 : /* (content generated from coverage data) */
2674 : /* ... */
2675 : /* ... */
2676 : /* ... */
2677 : /* ... */
2678 : /* ... */
2679 : /* ... */
2680 : /* ... */
2681 : /* ... */
2682 : /* ... */
2683 : /* ... */
2684 : /* ... */
2685 : /* ... */
2686 : /* ... */
2687 : /* ... */
2688 : /* ... */
2689 : /* ... */
2690 : /* ... */
2691 : /* ... */
2692 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2693 : /* (content generated from coverage data) */
2694 : /* ... */
2695 : /* ... */
2696 : /* ... */
2697 : /* ... */
2698 : /* ... */
2699 : /* ... */
2700 : /* ... */
2701 : /* ... */
2702 : /* ... */
2703 : /* ... */
2704 : /* ... */
2705 : /* ... */
2706 : /* ... */
2707 : /* ... */
2708 : /* ... */
2709 : /* ... */
2710 : /* ... */
2711 : /* ... */
2712 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2713 : /* (content generated from coverage data) */
2714 : /* ... */
2715 : /* ... */
2716 : /* ... */
2717 : /* ... */
2718 : /* ... */
2719 : /* ... */
2720 : /* ... */
2721 : /* ... */
2722 : /* ... */
2723 : /* ... */
2724 : /* ... */
2725 : /* ... */
2726 : /* ... */
2727 : /* ... */
2728 : /* ... */
2729 : /* ... */
2730 : /* ... */
2731 : /* ... */
2732 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2733 : /* (content generated from coverage data) */
2734 : /* ... */
2735 : /* ... */
2736 : /* ... */
2737 : /* ... */
2738 : /* ... */
2739 : /* ... */
2740 : /* ... */
2741 : /* ... */
2742 : /* ... */
2743 : /* ... */
2744 : /* ... */
2745 : /* ... */
2746 : /* ... */
2747 : /* ... */
2748 : /* ... */
2749 : /* ... */
2750 : /* ... */
2751 : /* ... */
2752 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2753 : /* (content generated from coverage data) */
2754 : /* ... */
2755 : /* ... */
2756 : /* ... */
2757 : /* ... */
2758 : /* ... */
2759 : /* ... */
2760 : /* ... */
2761 : /* ... */
2762 : /* ... */
2763 : /* ... */
2764 : /* ... */
2765 : /* ... */
2766 : /* ... */
2767 : /* ... */
2768 : /* ... */
2769 : /* ... */
2770 : /* ... */
2771 : /* ... */
2772 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2773 : /* (content generated from coverage data) */
2774 : /* ... */
2775 : /* ... */
2776 : /* ... */
2777 : /* ... */
2778 : /* ... */
2779 : /* ... */
2780 : /* ... */
2781 : /* ... */
2782 : /* ... */
2783 : /* ... */
2784 : /* ... */
2785 : /* ... */
2786 : /* ... */
2787 : /* ... */
2788 : /* ... */
2789 : /* ... */
2790 : /* ... */
2791 : /* ... */
2792 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2793 : /* (content generated from coverage data) */
2794 : /* ... */
2795 : /* ... */
2796 : /* ... */
2797 : /* ... */
2798 : /* ... */
2799 : /* ... */
2800 : /* ... */
2801 : /* ... */
2802 : /* ... */
2803 : /* ... */
2804 : /* ... */
2805 : /* ... */
2806 : /* ... */
2807 : /* ... */
2808 : /* ... */
2809 : /* ... */
2810 : /* ... */
2811 : /* ... */
2812 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2813 : /* (content generated from coverage data) */
2814 : /* ... */
2815 : /* ... */
2816 : /* ... */
2817 : /* ... */
2818 : /* ... */
2819 : /* ... */
2820 : /* ... */
2821 : /* ... */
2822 : /* ... */
2823 : /* ... */
2824 : /* ... */
2825 : /* ... */
2826 : /* ... */
2827 : /* ... */
2828 : /* ... */
2829 : /* ... */
2830 : /* ... */
2831 : /* ... */
2832 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2833 : /* (content generated from coverage data) */
2834 : /* ... */
2835 : /* ... */
2836 : /* ... */
2837 : /* ... */
2838 : /* ... */
2839 : /* ... */
2840 : /* ... */
2841 : /* ... */
2842 : /* ... */
2843 : /* ... */
2844 : /* ... */
2845 : /* ... */
2846 : /* ... */
2847 : /* ... */
2848 : /* ... */
2849 : /* ... */
2850 : /* ... */
2851 : /* ... */
2852 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2853 : /* (content generated from coverage data) */
2854 : /* ... */
2855 : /* ... */
2856 : /* ... */
2857 : /* ... */
2858 : /* ... */
2859 : /* ... */
2860 : /* ... */
2861 : /* ... */
2862 : /* ... */
2863 : /* ... */
2864 : /* ... */
2865 : /* ... */
2866 : /* ... */
2867 : /* ... */
2868 : /* ... */
2869 : /* ... */
2870 : /* ... */
2871 : /* ... */
2872 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2873 : /* (content generated from coverage data) */
2874 : /* ... */
2875 : /* ... */
2876 : /* ... */
2877 : /* ... */
2878 : /* ... */
2879 : /* ... */
2880 : /* ... */
2881 : /* ... */
2882 : /* ... */
2883 : /* ... */
2884 7432392204 : /* BEGIN: function "_Z26reg_class_for_constraint_114constraint_num" */
2885 : /* ... */
2886 7432392204 : /* ... */
2887 : /* ... */
2888 : /* ... */
2889 : /* ... */
2890 138747013 : /* ... */
2891 : /* ... */
2892 54637075 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2893 23976153 : /* (content generated from coverage data) */
2894 : /* ... */
2895 25088101 : /* ... */
2896 10075775 : /* ... */
2897 776358 : /* ... */
2898 978567 : /* ... */
2899 821673 : /* ... */
2900 1418311 : /* ... */
2901 219051601 : /* ... */
2902 81699 : /* ... */
2903 8637 : /* ... */
2904 928688 : /* ... */
2905 45360487 : /* ... */
2906 673492642 : /* ... */
2907 243189555 : /* ... */
2908 1517617704 : /* ... */
2909 14330 : /* ... */
2910 5661690 : /* ... */
2911 4061709 : /* ... */
2912 1327476 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2913 0 : /* (content generated from coverage data) */
2914 1399196 : /* ... */
2915 14123 : /* ... */
2916 186842524 : /* ... */
2917 326374 : /* ... */
2918 142543808 : /* ... */
2919 2787091 : /* ... */
2920 2324941 : /* ... */
2921 138524 : /* ... */
2922 6229378 : /* ... */
2923 : /* ... */
2924 : /* ... */
2925 : /* ... */
2926 : /* END: function "_Z26reg_class_for_constraint_114constraint_num" */
2927 : /* ... */
2928 : /* ... */
2929 : /* ... */
2930 : /* ... */
2931 : /* ... */
2932 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2933 : /* (content generated from coverage data) */
2934 : /* ... */
2935 : /* ... */
2936 : /* ... */
2937 : /* ... */
2938 : /* ... */
2939 : /* ... */
2940 : /* ... */
2941 : /* ... */
2942 : /* ... */
2943 : /* ... */
2944 : /* ... */
2945 : /* ... */
2946 : /* ... */
2947 : /* ... */
2948 : /* ... */
2949 : /* ... */
2950 : /* ... */
2951 : /* ... */
2952 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2953 : /* (content generated from coverage data) */
2954 : /* ... */
2955 : /* ... */
2956 : /* ... */
2957 : /* ... */
2958 : /* ... */
2959 : /* ... */
2960 : /* ... */
2961 : /* ... */
2962 : /* ... */
2963 : /* ... */
2964 : /* ... */
2965 : /* ... */
2966 : /* ... */
2967 : /* ... */
2968 : /* ... */
2969 : /* ... */
2970 : /* ... */
2971 : /* ... */
2972 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2973 : /* (content generated from coverage data) */
2974 : /* ... */
2975 : /* ... */
2976 : /* ... */
2977 : /* ... */
2978 : /* ... */
2979 : /* ... */
2980 : /* ... */
2981 : /* ... */
2982 : /* ... */
2983 : /* ... */
2984 : /* ... */
2985 : /* ... */
2986 : /* ... */
2987 : /* ... */
2988 : /* ... */
2989 : /* ... */
2990 7361713 : /* END: function "_Z32insn_const_int_ok_for_constraintl14constraint_num" */
2991 : /* ... */
2992 7361713 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
2993 : /* (content generated from coverage data) */
2994 1384233 : /* ... */
2995 1384233 : /* ... */
|