1 ;; Predicate definitions for IA-32 and x86-64.
2 ;; Copyright (C) 2004-2018 Free Software Foundation, Inc.
4 ;; This file is part of GCC.
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)
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.
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/>.
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 (match_test "ANY_FP_REGNO_P (REGNO (op))")))
25 ;; Return true if OP is an i387 fp register.
26 (define_predicate "fp_register_operand"
27 (and (match_code "reg")
28 (match_test "STACK_REGNO_P (REGNO (op))")))
30 ;; True if the operand is a GENERAL class register.
31 (define_predicate "general_reg_operand"
32 (and (match_code "reg")
33 (match_test "GENERAL_REGNO_P (REGNO (op))")))
35 ;; True if the operand is a nonimmediate operand with GENERAL class register.
36 (define_predicate "nonimmediate_gr_operand"
37 (if_then_else (match_code "reg")
38 (match_test "GENERAL_REGNO_P (REGNO (op))")
39 (match_operand 0 "nonimmediate_operand")))
41 ;; True if the operand is a general operand with GENERAL class register.
42 (define_predicate "general_gr_operand"
43 (if_then_else (match_code "reg")
44 (match_test "GENERAL_REGNO_P (REGNO (op))")
45 (match_operand 0 "general_operand")))
47 ;; True if the operand is an MMX register.
48 (define_predicate "mmx_reg_operand"
49 (and (match_code "reg")
50 (match_test "MMX_REGNO_P (REGNO (op))")))
52 ;; True if the operand is an SSE register.
53 (define_predicate "sse_reg_operand"
54 (and (match_code "reg")
55 (match_test "SSE_REGNO_P (REGNO (op))")))
57 ;; True if the operand is an AVX-512 new register.
58 (define_predicate "ext_sse_reg_operand"
59 (and (match_code "reg")
60 (match_test "EXT_REX_SSE_REGNO_P (REGNO (op))")))
62 ;; Return true if op is a QImode register.
63 (define_predicate "any_QIreg_operand"
64 (and (match_code "reg")
65 (match_test "ANY_QI_REGNO_P (REGNO (op))")))
67 ;; Return true if op is one of QImode registers: %[abcd][hl].
68 (define_predicate "QIreg_operand"
69 (and (match_code "reg")
70 (match_test "QI_REGNO_P (REGNO (op))")))
72 ;; Return true if op is a QImode register operand other than %[abcd][hl].
73 (define_predicate "ext_QIreg_operand"
74 (and (match_test "TARGET_64BIT")
76 (not (match_test "QI_REGNO_P (REGNO (op))"))))
78 ;; Return true if op is the AX register.
79 (define_predicate "ax_reg_operand"
80 (and (match_code "reg")
81 (match_test "REGNO (op) == AX_REG")))
83 ;; Return true if op is the flags register.
84 (define_predicate "flags_reg_operand"
85 (and (match_code "reg")
86 (match_test "REGNO (op) == FLAGS_REG")))
88 ;; Match a DI, SI or HImode register for a zero_extract.
89 (define_special_predicate "ext_register_operand"
90 (and (match_operand 0 "register_operand")
91 (ior (and (match_test "TARGET_64BIT")
92 (match_test "GET_MODE (op) == DImode"))
93 (match_test "GET_MODE (op) == SImode")
94 (match_test "GET_MODE (op) == HImode"))))
96 ;; Match register operands, but include memory operands for TARGET_SSE_MATH.
97 (define_predicate "register_ssemem_operand"
99 (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
100 (match_operand 0 "nonimmediate_operand")
101 (match_operand 0 "register_operand")))
103 ;; Match nonimmediate operands, but exclude memory operands
104 ;; for TARGET_SSE_MATH if TARGET_MIX_SSE_I387 is not enabled.
105 (define_predicate "nonimm_ssenomem_operand"
107 (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
108 (not (match_test "TARGET_MIX_SSE_I387")))
109 (match_operand 0 "register_operand")
110 (match_operand 0 "nonimmediate_operand")))
112 ;; The above predicate, suitable for x87 arithmetic operators.
113 (define_predicate "x87nonimm_ssenomem_operand"
115 (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
116 (not (match_test "TARGET_MIX_SSE_I387 && X87_ENABLE_ARITH (mode)")))
117 (match_operand 0 "register_operand")
118 (match_operand 0 "nonimmediate_operand")))
120 ;; Match register operands, include memory operand for TARGET_SSE4_1.
121 (define_predicate "register_sse4nonimm_operand"
122 (if_then_else (match_test "TARGET_SSE4_1")
123 (match_operand 0 "nonimmediate_operand")
124 (match_operand 0 "register_operand")))
126 ;; Return true if VALUE is symbol reference
127 (define_predicate "symbol_operand"
128 (match_code "symbol_ref"))
130 ;; Return true if VALUE can be stored in a sign extended immediate field.
131 (define_predicate "x86_64_immediate_operand"
132 (match_code "const_int,symbol_ref,label_ref,const")
135 return immediate_operand (op, mode);
137 switch (GET_CODE (op))
141 HOST_WIDE_INT val = INTVAL (op);
142 return trunc_int_for_mode (val, SImode) == val;
145 /* TLS symbols are not constant. */
146 if (SYMBOL_REF_TLS_MODEL (op))
149 /* Load the external function address via the GOT slot. */
150 if (ix86_force_load_from_GOT_p (op))
153 /* For certain code models, the symbolic references are known to fit.
154 in CM_SMALL_PIC model we know it fits if it is local to the shared
155 library. Don't count TLS SYMBOL_REFs here, since they should fit
156 only if inside of UNSPEC handled below. */
157 return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
158 || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
161 /* For certain code models, the code is near as well. */
162 return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
163 || ix86_cmodel == CM_KERNEL);
166 /* We also may accept the offsetted memory references in certain
168 if (GET_CODE (XEXP (op, 0)) == UNSPEC)
169 switch (XINT (XEXP (op, 0), 1))
171 case UNSPEC_GOTPCREL:
173 case UNSPEC_GOTNTPOFF:
180 if (GET_CODE (XEXP (op, 0)) == PLUS)
182 rtx op1 = XEXP (XEXP (op, 0), 0);
183 rtx op2 = XEXP (XEXP (op, 0), 1);
185 if (ix86_cmodel == CM_LARGE)
187 if (!CONST_INT_P (op2))
190 HOST_WIDE_INT offset = INTVAL (op2);
191 if (trunc_int_for_mode (offset, SImode) != offset)
194 switch (GET_CODE (op1))
197 /* TLS symbols are not constant. */
198 if (SYMBOL_REF_TLS_MODEL (op1))
201 /* Load the external function address via the GOT slot. */
202 if (ix86_force_load_from_GOT_p (op1))
205 /* For CM_SMALL assume that latest object is 16MB before
206 end of 31bits boundary. We may also accept pretty
207 large negative constants knowing that all objects are
208 in the positive half of address space. */
209 if ((ix86_cmodel == CM_SMALL
210 || (ix86_cmodel == CM_MEDIUM
211 && !SYMBOL_REF_FAR_ADDR_P (op1)))
212 && offset < 16*1024*1024)
214 /* For CM_KERNEL we know that all object resist in the
215 negative half of 32bits address space. We may not
216 accept negative offsets, since they may be just off
217 and we may accept pretty large positive ones. */
218 if (ix86_cmodel == CM_KERNEL
224 /* These conditions are similar to SYMBOL_REF ones, just the
225 constraints for code models differ. */
226 if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
227 && offset < 16*1024*1024)
229 if (ix86_cmodel == CM_KERNEL
235 switch (XINT (op1, 1))
256 ;; Return true if VALUE can be stored in the zero extended immediate field.
257 (define_predicate "x86_64_zext_immediate_operand"
258 (match_code "const_int,symbol_ref,label_ref,const")
260 switch (GET_CODE (op))
263 return !(INTVAL (op) & ~(HOST_WIDE_INT) 0xffffffff);
266 /* TLS symbols are not constant. */
267 if (SYMBOL_REF_TLS_MODEL (op))
270 /* Load the external function address via the GOT slot. */
271 if (ix86_force_load_from_GOT_p (op))
274 /* For certain code models, the symbolic references are known to fit. */
275 return (ix86_cmodel == CM_SMALL
276 || (ix86_cmodel == CM_MEDIUM
277 && !SYMBOL_REF_FAR_ADDR_P (op)));
280 /* For certain code models, the code is near as well. */
281 return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
284 /* We also may accept the offsetted memory references in certain
286 if (GET_CODE (XEXP (op, 0)) == PLUS)
288 rtx op1 = XEXP (XEXP (op, 0), 0);
289 rtx op2 = XEXP (XEXP (op, 0), 1);
291 if (ix86_cmodel == CM_LARGE)
293 if (!CONST_INT_P (op2))
296 HOST_WIDE_INT offset = INTVAL (op2);
297 if (trunc_int_for_mode (offset, SImode) != offset)
300 switch (GET_CODE (op1))
303 /* TLS symbols are not constant. */
304 if (SYMBOL_REF_TLS_MODEL (op1))
307 /* Load the external function address via the GOT slot. */
308 if (ix86_force_load_from_GOT_p (op1))
311 /* For small code model we may accept pretty large positive
312 offsets, since one bit is available for free. Negative
313 offsets are limited by the size of NULL pointer area
314 specified by the ABI. */
315 if ((ix86_cmodel == CM_SMALL
316 || (ix86_cmodel == CM_MEDIUM
317 && !SYMBOL_REF_FAR_ADDR_P (op1)))
318 && offset > -0x10000)
320 /* ??? For the kernel, we may accept adjustment of
321 -0x10000000, since we know that it will just convert
322 negative address space to positive, but perhaps this
323 is not worthwhile. */
327 /* These conditions are similar to SYMBOL_REF ones, just the
328 constraints for code models differ. */
329 if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
330 && offset > -0x10000)
346 ;; Return true if VALUE is a constant integer whose low and high words satisfy
347 ;; x86_64_immediate_operand.
348 (define_predicate "x86_64_hilo_int_operand"
349 (match_code "const_int,const_wide_int")
351 switch (GET_CODE (op))
354 return x86_64_immediate_operand (op, mode);
357 gcc_assert (CONST_WIDE_INT_NUNITS (op) == 2);
358 return (x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op, 0)),
360 && x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op,
369 ;; Return true if VALUE is a constant integer whose value is
370 ;; x86_64_immediate_operand value zero extended from word mode to mode.
371 (define_predicate "x86_64_dwzext_immediate_operand"
372 (match_code "const_int,const_wide_int")
374 switch (GET_CODE (op))
378 return UINTVAL (op) <= HOST_WIDE_INT_UC (0xffffffff);
379 return UINTVAL (op) <= HOST_WIDE_INT_UC (0x7fffffff);
384 return (CONST_WIDE_INT_NUNITS (op) == 2
385 && CONST_WIDE_INT_ELT (op, 1) == 0
386 && (trunc_int_for_mode (CONST_WIDE_INT_ELT (op, 0), SImode)
387 == (HOST_WIDE_INT) CONST_WIDE_INT_ELT (op, 0)));
394 ;; Return true if size of VALUE can be stored in a sign
395 ;; extended immediate field.
396 (define_predicate "x86_64_immediate_size_operand"
397 (and (match_code "symbol_ref")
398 (ior (not (match_test "TARGET_64BIT"))
399 (match_test "ix86_cmodel == CM_SMALL")
400 (match_test "ix86_cmodel == CM_KERNEL"))))
402 ;; Return true if OP is general operand representable on x86_64.
403 (define_predicate "x86_64_general_operand"
404 (if_then_else (match_test "TARGET_64BIT")
405 (ior (match_operand 0 "nonimmediate_operand")
406 (match_operand 0 "x86_64_immediate_operand"))
407 (match_operand 0 "general_operand")))
409 ;; Return true if OP's both words are general operands representable
411 (define_predicate "x86_64_hilo_general_operand"
412 (if_then_else (match_test "TARGET_64BIT")
413 (ior (match_operand 0 "nonimmediate_operand")
414 (match_operand 0 "x86_64_hilo_int_operand"))
415 (match_operand 0 "general_operand")))
417 ;; Return true if OP is non-VOIDmode general operand representable
418 ;; on x86_64. This predicate is used in sign-extending conversion
419 ;; operations that require non-VOIDmode immediate operands.
420 (define_predicate "x86_64_sext_operand"
421 (and (match_test "GET_MODE (op) != VOIDmode")
422 (match_operand 0 "x86_64_general_operand")))
424 ;; Return true if OP is non-VOIDmode general operand. This predicate
425 ;; is used in sign-extending conversion operations that require
426 ;; non-VOIDmode immediate operands.
427 (define_predicate "sext_operand"
428 (and (match_test "GET_MODE (op) != VOIDmode")
429 (match_operand 0 "general_operand")))
431 ;; Return true if OP is representable on x86_64 as zero-extended operand.
432 ;; This predicate is used in zero-extending conversion operations that
433 ;; require non-VOIDmode immediate operands.
434 (define_predicate "x86_64_zext_operand"
435 (if_then_else (match_test "TARGET_64BIT")
436 (ior (match_operand 0 "nonimmediate_operand")
437 (and (match_operand 0 "x86_64_zext_immediate_operand")
438 (match_test "GET_MODE (op) != VOIDmode")))
439 (match_operand 0 "nonimmediate_operand")))
441 ;; Return true if OP is general operand representable on x86_64
442 ;; as either sign extended or zero extended constant.
443 (define_predicate "x86_64_szext_general_operand"
444 (if_then_else (match_test "TARGET_64BIT")
445 (ior (match_operand 0 "nonimmediate_operand")
446 (match_operand 0 "x86_64_immediate_operand")
447 (match_operand 0 "x86_64_zext_immediate_operand"))
448 (match_operand 0 "general_operand")))
450 ;; Return true if OP is nonmemory operand representable on x86_64.
451 (define_predicate "x86_64_nonmemory_operand"
452 (if_then_else (match_test "TARGET_64BIT")
453 (ior (match_operand 0 "register_operand")
454 (match_operand 0 "x86_64_immediate_operand"))
455 (match_operand 0 "nonmemory_operand")))
457 ;; Return true if OP is nonmemory operand representable on x86_64.
458 (define_predicate "x86_64_szext_nonmemory_operand"
459 (if_then_else (match_test "TARGET_64BIT")
460 (ior (match_operand 0 "register_operand")
461 (match_operand 0 "x86_64_immediate_operand")
462 (match_operand 0 "x86_64_zext_immediate_operand"))
463 (match_operand 0 "nonmemory_operand")))
465 ;; Return true when operand is PIC expression that can be computed by lea
467 (define_predicate "pic_32bit_operand"
468 (match_code "const,symbol_ref,label_ref")
473 /* Rule out relocations that translate into 64bit constants. */
474 if (TARGET_64BIT && GET_CODE (op) == CONST)
477 if (GET_CODE (op) == PLUS && CONST_INT_P (XEXP (op, 1)))
479 if (GET_CODE (op) == UNSPEC
480 && (XINT (op, 1) == UNSPEC_GOTOFF
481 || XINT (op, 1) == UNSPEC_GOT))
485 return symbolic_operand (op, mode);
488 ;; Return true if OP is nonmemory operand acceptable by movabs patterns.
489 (define_predicate "x86_64_movabs_operand"
490 (and (match_operand 0 "nonmemory_operand")
491 (not (match_operand 0 "pic_32bit_operand"))))
493 ;; Return true if OP is either a symbol reference or a sum of a symbol
494 ;; reference and a constant.
495 (define_predicate "symbolic_operand"
496 (match_code "symbol_ref,label_ref,const")
498 switch (GET_CODE (op))
506 if (GET_CODE (op) == SYMBOL_REF
507 || GET_CODE (op) == LABEL_REF
508 || (GET_CODE (op) == UNSPEC
509 && (XINT (op, 1) == UNSPEC_GOT
510 || XINT (op, 1) == UNSPEC_GOTOFF
511 || XINT (op, 1) == UNSPEC_PCREL
512 || XINT (op, 1) == UNSPEC_GOTPCREL)))
514 if (GET_CODE (op) != PLUS
515 || !CONST_INT_P (XEXP (op, 1)))
519 if (GET_CODE (op) == SYMBOL_REF
520 || GET_CODE (op) == LABEL_REF)
522 /* Only @GOTOFF gets offsets. */
523 if (GET_CODE (op) != UNSPEC
524 || XINT (op, 1) != UNSPEC_GOTOFF)
527 op = XVECEXP (op, 0, 0);
528 if (GET_CODE (op) == SYMBOL_REF
529 || GET_CODE (op) == LABEL_REF)
538 ;; Return true if OP is a symbolic operand that resolves locally.
539 (define_predicate "local_symbolic_operand"
540 (match_code "const,label_ref,symbol_ref")
542 if (GET_CODE (op) == CONST
543 && GET_CODE (XEXP (op, 0)) == PLUS
544 && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
545 op = XEXP (XEXP (op, 0), 0);
547 if (GET_CODE (op) == LABEL_REF)
550 if (GET_CODE (op) != SYMBOL_REF)
553 if (SYMBOL_REF_TLS_MODEL (op))
556 /* Dll-imported symbols are always external. */
557 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
559 if (SYMBOL_REF_LOCAL_P (op))
562 /* There is, however, a not insubstantial body of code in the rest of
563 the compiler that assumes it can just stick the results of
564 ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done. */
565 /* ??? This is a hack. Should update the body of the compiler to
566 always create a DECL an invoke targetm.encode_section_info. */
567 if (strncmp (XSTR (op, 0), internal_label_prefix,
568 internal_label_prefix_len) == 0)
574 ;; Test for a legitimate @GOTOFF operand.
576 ;; VxWorks does not impose a fixed gap between segments; the run-time
577 ;; gap can be different from the object-file gap. We therefore can't
578 ;; use @GOTOFF unless we are absolutely sure that the symbol is in the
579 ;; same segment as the GOT. Unfortunately, the flexibility of linker
580 ;; scripts means that we can't be sure of that in general, so assume
581 ;; that @GOTOFF is never valid on VxWorks.
582 (define_predicate "gotoff_operand"
583 (and (not (match_test "TARGET_VXWORKS_RTP"))
584 (match_operand 0 "local_symbolic_operand")))
586 ;; Test for various thread-local symbols.
587 (define_special_predicate "tls_symbolic_operand"
588 (and (match_code "symbol_ref")
589 (match_test "SYMBOL_REF_TLS_MODEL (op)")))
591 (define_special_predicate "tls_modbase_operand"
592 (and (match_code "symbol_ref")
593 (match_test "op == ix86_tls_module_base ()")))
595 (define_predicate "tls_address_pattern"
596 (and (match_code "set,parallel,unspec,unspec_volatile")
597 (match_test "ix86_tls_address_pattern_p (op)")))
599 ;; Test for a pc-relative call operand
600 (define_predicate "constant_call_address_operand"
601 (match_code "symbol_ref")
603 if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC
604 || flag_force_indirect_call)
606 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
611 ;; P6 processors will jump to the address after the decrement when %esp
612 ;; is used as a call operand, so they will execute return address as a code.
613 ;; See Pentium Pro errata 70, Pentium 2 errata A33 and Pentium 3 errata E17.
615 (define_predicate "call_register_no_elim_operand"
616 (match_operand 0 "register_operand")
619 op = SUBREG_REG (op);
621 if (!TARGET_64BIT && op == stack_pointer_rtx)
624 return register_no_elim_operand (op, mode);
627 ;; True for any non-virtual or eliminable register. Used in places where
628 ;; instantiation of such a register may cause the pattern to not be recognized.
629 (define_predicate "register_no_elim_operand"
630 (match_operand 0 "register_operand")
633 op = SUBREG_REG (op);
634 return !(op == arg_pointer_rtx
635 || op == frame_pointer_rtx
636 || IN_RANGE (REGNO (op),
637 FIRST_PSEUDO_REGISTER, LAST_VIRTUAL_REGISTER));
640 ;; Similarly, but include the stack pointer. This is used to prevent esp
641 ;; from being used as an index reg.
642 (define_predicate "index_register_operand"
643 (match_operand 0 "register_operand")
646 op = SUBREG_REG (op);
647 if (reload_completed)
648 return REG_OK_FOR_INDEX_STRICT_P (op);
650 return REG_OK_FOR_INDEX_NONSTRICT_P (op);
653 ;; Return false if this is any eliminable register. Otherwise general_operand.
654 (define_predicate "general_no_elim_operand"
655 (if_then_else (match_code "reg,subreg")
656 (match_operand 0 "register_no_elim_operand")
657 (match_operand 0 "general_operand")))
659 ;; Return false if this is any eliminable register. Otherwise
660 ;; register_operand or a constant.
661 (define_predicate "nonmemory_no_elim_operand"
662 (ior (match_operand 0 "register_no_elim_operand")
663 (match_operand 0 "immediate_operand")))
665 ;; Test for a valid operand for indirect branch.
666 (define_predicate "indirect_branch_operand"
667 (ior (match_operand 0 "register_operand")
668 (and (not (match_test "TARGET_X32
669 || ix86_indirect_branch_thunk_register"))
670 (match_operand 0 "memory_operand"))))
672 ;; Return true if OP is a memory operands that can be used in sibcalls.
673 ;; Since sibcall never returns, we can only use call-clobbered register
674 ;; as GOT base. Allow GOT slot here only with pseudo register as GOT
675 ;; base. Properly handle sibcall over GOT slot with *sibcall_GOT_32
676 ;; and *sibcall_value_GOT_32 patterns.
677 (define_predicate "sibcall_memory_operand"
678 (match_operand 0 "memory_operand")
683 if (GET_CODE (op) == PLUS && REG_P (XEXP (op, 0)))
685 int regno = REGNO (XEXP (op, 0));
686 if (!HARD_REGISTER_NUM_P (regno) || call_used_regs[regno])
689 if (GOT32_symbol_operand (op, VOIDmode))
696 ;; Return true if OP is a GOT memory operand.
697 (define_predicate "GOT_memory_operand"
698 (and (match_test "!ix86_indirect_branch_thunk_register")
699 (match_operand 0 "memory_operand"))
702 return (GET_CODE (op) == CONST
703 && GET_CODE (XEXP (op, 0)) == UNSPEC
704 && XINT (XEXP (op, 0), 1) == UNSPEC_GOTPCREL);
707 ;; Test for a valid operand for a call instruction.
708 ;; Allow constant call address operands in Pmode only.
709 (define_special_predicate "call_insn_operand"
710 (ior (match_test "constant_call_address_operand
711 (op, mode == VOIDmode ? mode : Pmode)")
712 (match_operand 0 "call_register_no_elim_operand")
713 (ior (and (not (match_test "TARGET_X32
714 || ix86_indirect_branch_thunk_register"))
715 (match_operand 0 "memory_operand"))
716 (and (match_test "TARGET_X32 && Pmode == DImode
717 && !ix86_indirect_branch_thunk_register")
718 (match_operand 0 "GOT_memory_operand")))))
720 ;; Similarly, but for tail calls, in which we cannot allow memory references.
721 (define_special_predicate "sibcall_insn_operand"
722 (ior (match_test "constant_call_address_operand
723 (op, mode == VOIDmode ? mode : Pmode)")
724 (match_operand 0 "register_no_elim_operand")
725 (ior (and (not (match_test "TARGET_X32
726 || ix86_indirect_branch_thunk_register"))
727 (match_operand 0 "sibcall_memory_operand"))
728 (and (match_test "TARGET_X32 && Pmode == DImode
729 && !ix86_indirect_branch_thunk_register")
730 (match_operand 0 "GOT_memory_operand")))))
732 ;; Return true if OP is a 32-bit GOT symbol operand.
733 (define_predicate "GOT32_symbol_operand"
734 (match_test "!ix86_indirect_branch_thunk_register
735 && GET_CODE (op) == CONST
736 && GET_CODE (XEXP (op, 0)) == UNSPEC
737 && XINT (XEXP (op, 0), 1) == UNSPEC_GOT"))
739 ;; Match exactly zero.
740 (define_predicate "const0_operand"
741 (match_code "const_int,const_double,const_vector")
743 if (mode == VOIDmode)
744 mode = GET_MODE (op);
745 return op == CONST0_RTX (mode);
748 ;; Match one or a vector with all elements equal to one.
749 (define_predicate "const1_operand"
750 (match_code "const_int,const_double,const_vector")
752 if (mode == VOIDmode)
753 mode = GET_MODE (op);
754 return op == CONST1_RTX (mode);
758 (define_predicate "constm1_operand"
759 (and (match_code "const_int")
760 (match_test "op == constm1_rtx")))
762 ;; Match exactly eight.
763 (define_predicate "const8_operand"
764 (and (match_code "const_int")
765 (match_test "INTVAL (op) == 8")))
767 ;; Match exactly 128.
768 (define_predicate "const128_operand"
769 (and (match_code "const_int")
770 (match_test "INTVAL (op) == 128")))
772 ;; Match exactly 0x0FFFFFFFF in anddi as a zero-extension operation
773 (define_predicate "const_32bit_mask"
774 (and (match_code "const_int")
775 (match_test "trunc_int_for_mode (INTVAL (op), DImode)
776 == (HOST_WIDE_INT) 0xffffffff")))
778 ;; Match 2, 4, or 8. Used for leal multiplicands.
779 (define_predicate "const248_operand"
780 (match_code "const_int")
782 HOST_WIDE_INT i = INTVAL (op);
783 return i == 2 || i == 4 || i == 8;
786 ;; Match 1, 2, or 3. Used for lea shift amounts.
787 (define_predicate "const123_operand"
788 (match_code "const_int")
790 HOST_WIDE_INT i = INTVAL (op);
791 return i == 1 || i == 2 || i == 3;
794 ;; Match 2, 3, 6, or 7
795 (define_predicate "const2367_operand"
796 (match_code "const_int")
798 HOST_WIDE_INT i = INTVAL (op);
799 return i == 2 || i == 3 || i == 6 || i == 7;
802 ;; Match 1, 2, 4, or 8
803 (define_predicate "const1248_operand"
804 (match_code "const_int")
806 HOST_WIDE_INT i = INTVAL (op);
807 return i == 1 || i == 2 || i == 4 || i == 8;
810 ;; Match 3, 5, or 9. Used for leal multiplicands.
811 (define_predicate "const359_operand"
812 (match_code "const_int")
814 HOST_WIDE_INT i = INTVAL (op);
815 return i == 3 || i == 5 || i == 9;
818 ;; Match 4 or 8 to 11. Used for embeded rounding.
819 (define_predicate "const_4_or_8_to_11_operand"
820 (match_code "const_int")
822 HOST_WIDE_INT i = INTVAL (op);
823 return i == 4 || (i >= 8 && i <= 11);
826 ;; Match 4 or 8. Used for SAE.
827 (define_predicate "const48_operand"
828 (match_code "const_int")
830 HOST_WIDE_INT i = INTVAL (op);
831 return i == 4 || i == 8;
835 (define_predicate "const_0_to_1_operand"
836 (and (match_code "const_int")
837 (ior (match_test "op == const0_rtx")
838 (match_test "op == const1_rtx"))))
841 (define_predicate "const_0_to_3_operand"
842 (and (match_code "const_int")
843 (match_test "IN_RANGE (INTVAL (op), 0, 3)")))
846 (define_predicate "const_0_to_4_operand"
847 (and (match_code "const_int")
848 (match_test "IN_RANGE (INTVAL (op), 0, 4)")))
851 (define_predicate "const_0_to_5_operand"
852 (and (match_code "const_int")
853 (match_test "IN_RANGE (INTVAL (op), 0, 5)")))
856 (define_predicate "const_0_to_7_operand"
857 (and (match_code "const_int")
858 (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
861 (define_predicate "const_0_to_15_operand"
862 (and (match_code "const_int")
863 (match_test "IN_RANGE (INTVAL (op), 0, 15)")))
866 (define_predicate "const_0_to_31_operand"
867 (and (match_code "const_int")
868 (match_test "IN_RANGE (INTVAL (op), 0, 31)")))
871 (define_predicate "const_0_to_63_operand"
872 (and (match_code "const_int")
873 (match_test "IN_RANGE (INTVAL (op), 0, 63)")))
876 (define_predicate "const_0_to_255_operand"
877 (and (match_code "const_int")
878 (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
880 ;; Match (0 to 255) * 8
881 (define_predicate "const_0_to_255_mul_8_operand"
882 (match_code "const_int")
884 unsigned HOST_WIDE_INT val = INTVAL (op);
885 return val <= 255*8 && val % 8 == 0;
888 ;; Return true if OP is CONST_INT >= 1 and <= 31 (a valid operand
889 ;; for shift & compare patterns, as shifting by 0 does not change flags).
890 (define_predicate "const_1_to_31_operand"
891 (and (match_code "const_int")
892 (match_test "IN_RANGE (INTVAL (op), 1, 31)")))
894 ;; Return true if OP is CONST_INT >= 1 and <= 63 (a valid operand
895 ;; for 64bit shift & compare patterns, as shifting by 0 does not change flags).
896 (define_predicate "const_1_to_63_operand"
897 (and (match_code "const_int")
898 (match_test "IN_RANGE (INTVAL (op), 1, 63)")))
901 (define_predicate "const_2_to_3_operand"
902 (and (match_code "const_int")
903 (match_test "IN_RANGE (INTVAL (op), 2, 3)")))
906 (define_predicate "const_4_to_5_operand"
907 (and (match_code "const_int")
908 (match_test "IN_RANGE (INTVAL (op), 4, 5)")))
911 (define_predicate "const_4_to_7_operand"
912 (and (match_code "const_int")
913 (match_test "IN_RANGE (INTVAL (op), 4, 7)")))
916 (define_predicate "const_6_to_7_operand"
917 (and (match_code "const_int")
918 (match_test "IN_RANGE (INTVAL (op), 6, 7)")))
921 (define_predicate "const_8_to_9_operand"
922 (and (match_code "const_int")
923 (match_test "IN_RANGE (INTVAL (op), 8, 9)")))
926 (define_predicate "const_8_to_11_operand"
927 (and (match_code "const_int")
928 (match_test "IN_RANGE (INTVAL (op), 8, 11)")))
931 (define_predicate "const_8_to_15_operand"
932 (and (match_code "const_int")
933 (match_test "IN_RANGE (INTVAL (op), 8, 15)")))
936 (define_predicate "const_10_to_11_operand"
937 (and (match_code "const_int")
938 (match_test "IN_RANGE (INTVAL (op), 10, 11)")))
941 (define_predicate "const_12_to_13_operand"
942 (and (match_code "const_int")
943 (match_test "IN_RANGE (INTVAL (op), 12, 13)")))
946 (define_predicate "const_12_to_15_operand"
947 (and (match_code "const_int")
948 (match_test "IN_RANGE (INTVAL (op), 12, 15)")))
951 (define_predicate "const_14_to_15_operand"
952 (and (match_code "const_int")
953 (match_test "IN_RANGE (INTVAL (op), 14, 15)")))
956 (define_predicate "const_16_to_19_operand"
957 (and (match_code "const_int")
958 (match_test "IN_RANGE (INTVAL (op), 16, 19)")))
961 (define_predicate "const_16_to_31_operand"
962 (and (match_code "const_int")
963 (match_test "IN_RANGE (INTVAL (op), 16, 31)")))
966 (define_predicate "const_20_to_23_operand"
967 (and (match_code "const_int")
968 (match_test "IN_RANGE (INTVAL (op), 20, 23)")))
971 (define_predicate "const_24_to_27_operand"
972 (and (match_code "const_int")
973 (match_test "IN_RANGE (INTVAL (op), 24, 27)")))
976 (define_predicate "const_28_to_31_operand"
977 (and (match_code "const_int")
978 (match_test "IN_RANGE (INTVAL (op), 28, 31)")))
980 ;; True if this is a constant appropriate for an increment or decrement.
981 (define_predicate "incdec_operand"
982 (match_code "const_int")
984 /* On Pentium4, the inc and dec operations causes extra dependency on flag
985 registers, since carry flag is not set. */
986 if (!TARGET_USE_INCDEC && !optimize_insn_for_size_p ())
988 return op == const1_rtx || op == constm1_rtx;
991 ;; True for registers, or 1 or -1. Used to optimize double-word shifts.
992 (define_predicate "reg_or_pm1_operand"
993 (ior (match_operand 0 "register_operand")
994 (and (match_code "const_int")
995 (ior (match_test "op == const1_rtx")
996 (match_test "op == constm1_rtx")))))
998 ;; True if OP is acceptable as operand of DImode shift expander.
999 (define_predicate "shiftdi_operand"
1000 (if_then_else (match_test "TARGET_64BIT")
1001 (match_operand 0 "nonimmediate_operand")
1002 (match_operand 0 "register_operand")))
1004 (define_predicate "ashldi_input_operand"
1005 (if_then_else (match_test "TARGET_64BIT")
1006 (match_operand 0 "nonimmediate_operand")
1007 (match_operand 0 "reg_or_pm1_operand")))
1009 ;; Return true if OP is a vector load from the constant pool with just
1010 ;; the first element nonzero.
1011 (define_predicate "zero_extended_scalar_load_operand"
1015 op = avoid_constant_pool_reference (op);
1017 if (GET_CODE (op) != CONST_VECTOR)
1020 n_elts = CONST_VECTOR_NUNITS (op);
1022 for (n_elts--; n_elts > 0; n_elts--)
1024 rtx elt = CONST_VECTOR_ELT (op, n_elts);
1025 if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
1031 /* Return true if operand is a vector constant that is all ones. */
1032 (define_predicate "vector_all_ones_operand"
1033 (and (match_code "const_vector")
1034 (match_test "INTEGRAL_MODE_P (GET_MODE (op))")
1035 (match_test "op == CONSTM1_RTX (GET_MODE (op))")))
1037 ; Return true when OP is operand acceptable for vector memory operand.
1038 ; Only AVX can have misaligned memory operand.
1039 (define_predicate "vector_memory_operand"
1040 (and (match_operand 0 "memory_operand")
1041 (ior (match_test "TARGET_AVX")
1042 (match_test "MEM_ALIGN (op) >= GET_MODE_ALIGNMENT (mode)"))))
1044 ; Return true when OP is register_operand or vector_memory_operand.
1045 (define_predicate "vector_operand"
1046 (ior (match_operand 0 "register_operand")
1047 (match_operand 0 "vector_memory_operand")))
1049 ; Return true when OP is operand acceptable for standard SSE move.
1050 (define_predicate "vector_move_operand"
1051 (ior (match_operand 0 "nonimmediate_operand")
1052 (match_operand 0 "const0_operand")))
1054 ;; Return true when OP is either nonimmediate operand, or any
1056 (define_predicate "nonimmediate_or_const_vector_operand"
1057 (ior (match_operand 0 "nonimmediate_operand")
1058 (match_code "const_vector")))
1060 ;; Return true when OP is nonimmediate or standard SSE constant.
1061 (define_predicate "nonimmediate_or_sse_const_operand"
1062 (ior (match_operand 0 "nonimmediate_operand")
1063 (match_test "standard_sse_constant_p (op, mode)")))
1065 ;; Return true if OP is a register or a zero.
1066 (define_predicate "reg_or_0_operand"
1067 (ior (match_operand 0 "register_operand")
1068 (match_operand 0 "const0_operand")))
1070 (define_predicate "norex_memory_operand"
1071 (and (match_operand 0 "memory_operand")
1072 (not (match_test "x86_extended_reg_mentioned_p (op)"))))
1074 ;; Return true for RTX codes that force SImode address.
1075 (define_predicate "SImode_address_operand"
1076 (match_code "subreg,zero_extend,and"))
1078 ;; Return true if op is a valid address for LEA, and does not contain
1079 ;; a segment override. Defined as a special predicate to allow
1080 ;; mode-less const_int operands pass to address_operand.
1081 (define_special_predicate "address_no_seg_operand"
1082 (match_test "address_operand (op, VOIDmode)")
1084 struct ix86_address parts;
1087 if (!CONST_INT_P (op)
1089 && GET_MODE (op) != mode)
1092 ok = ix86_decompose_address (op, &parts);
1094 return parts.seg == ADDR_SPACE_GENERIC;
1097 ;; Return true if op if a valid base register, displacement or
1098 ;; sum of base register and displacement for VSIB addressing.
1099 (define_predicate "vsib_address_operand"
1100 (match_test "address_operand (op, VOIDmode)")
1102 struct ix86_address parts;
1106 ok = ix86_decompose_address (op, &parts);
1108 if (parts.index || parts.seg != ADDR_SPACE_GENERIC)
1111 /* VSIB addressing doesn't support (%rip). */
1115 if (GET_CODE (disp) == CONST)
1117 disp = XEXP (disp, 0);
1118 if (GET_CODE (disp) == PLUS)
1119 disp = XEXP (disp, 0);
1120 if (GET_CODE (disp) == UNSPEC)
1121 switch (XINT (disp, 1))
1123 case UNSPEC_GOTPCREL:
1125 case UNSPEC_GOTNTPOFF:
1131 && (GET_CODE (disp) == SYMBOL_REF
1132 || GET_CODE (disp) == LABEL_REF))
1139 ;; Return true if op is valid MPX address operand without base
1140 (define_predicate "address_mpx_no_base_operand"
1141 (match_test "address_operand (op, VOIDmode)")
1143 struct ix86_address parts;
1146 ok = ix86_decompose_address (op, &parts);
1149 if (parts.index && parts.base)
1152 if (parts.seg != ADDR_SPACE_GENERIC)
1155 /* Do not support (%rip). */
1156 if (parts.disp && flag_pic && TARGET_64BIT
1157 && SYMBOLIC_CONST (parts.disp))
1159 if (GET_CODE (parts.disp) != CONST
1160 || GET_CODE (XEXP (parts.disp, 0)) != PLUS
1161 || GET_CODE (XEXP (XEXP (parts.disp, 0), 0)) != UNSPEC
1162 || !CONST_INT_P (XEXP (XEXP (parts.disp, 0), 1))
1163 || (XINT (XEXP (XEXP (parts.disp, 0), 0), 1) != UNSPEC_DTPOFF
1164 && XINT (XEXP (XEXP (parts.disp, 0), 0), 1) != UNSPEC_NTPOFF))
1171 ;; Return true if op is valid MPX address operand without index
1172 (define_predicate "address_mpx_no_index_operand"
1173 (match_test "address_operand (op, VOIDmode)")
1175 struct ix86_address parts;
1178 ok = ix86_decompose_address (op, &parts);
1184 if (parts.seg != ADDR_SPACE_GENERIC)
1187 /* Do not support (%rip). */
1188 if (parts.disp && flag_pic && TARGET_64BIT
1189 && SYMBOLIC_CONST (parts.disp)
1190 && (GET_CODE (parts.disp) != CONST
1191 || GET_CODE (XEXP (parts.disp, 0)) != PLUS
1192 || GET_CODE (XEXP (XEXP (parts.disp, 0), 0)) != UNSPEC
1193 || !CONST_INT_P (XEXP (XEXP (parts.disp, 0), 1))
1194 || (XINT (XEXP (XEXP (parts.disp, 0), 0), 1) != UNSPEC_DTPOFF
1195 && XINT (XEXP (XEXP (parts.disp, 0), 0), 1) != UNSPEC_NTPOFF)))
1201 (define_predicate "vsib_mem_operator"
1204 (define_predicate "bnd_mem_operator"
1207 ;; Return true if the rtx is known to be at least 32 bits aligned.
1208 (define_predicate "aligned_operand"
1209 (match_operand 0 "general_operand")
1211 struct ix86_address parts;
1214 /* Registers and immediate operands are always "aligned". */
1218 /* All patterns using aligned_operand on memory operands ends up
1219 in promoting memory operand to 64bit and thus causing memory mismatch. */
1220 if (TARGET_MEMORY_MISMATCH_STALL && !optimize_insn_for_size_p ())
1223 /* Don't even try to do any aligned optimizations with volatiles. */
1224 if (MEM_VOLATILE_P (op))
1227 if (MEM_ALIGN (op) >= 32)
1232 /* Pushes and pops are only valid on the stack pointer. */
1233 if (GET_CODE (op) == PRE_DEC
1234 || GET_CODE (op) == POST_INC)
1237 /* Decode the address. */
1238 ok = ix86_decompose_address (op, &parts);
1241 if (parts.base && SUBREG_P (parts.base))
1242 parts.base = SUBREG_REG (parts.base);
1243 if (parts.index && SUBREG_P (parts.index))
1244 parts.index = SUBREG_REG (parts.index);
1246 /* Look for some component that isn't known to be aligned. */
1249 if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
1254 if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
1259 if (!CONST_INT_P (parts.disp)
1260 || (INTVAL (parts.disp) & 3))
1264 /* Didn't find one -- this must be an aligned address. */
1268 ;; Return true if OP is memory operand with a displacement.
1269 (define_predicate "memory_displacement_operand"
1270 (match_operand 0 "memory_operand")
1272 struct ix86_address parts;
1275 ok = ix86_decompose_address (XEXP (op, 0), &parts);
1277 return parts.disp != NULL_RTX;
1280 ;; Return true if OP is memory operand with a displacement only.
1281 (define_predicate "memory_displacement_only_operand"
1282 (match_operand 0 "memory_operand")
1284 struct ix86_address parts;
1290 ok = ix86_decompose_address (XEXP (op, 0), &parts);
1293 if (parts.base || parts.index)
1296 return parts.disp != NULL_RTX;
1299 ;; Return true if OP is memory operand that cannot be represented
1300 ;; by the modRM array.
1301 (define_predicate "long_memory_operand"
1302 (and (match_operand 0 "memory_operand")
1303 (match_test "memory_address_length (op, false)")))
1305 ;; Return true if OP is a comparison operator that can be issued by fcmov.
1306 (define_predicate "fcmov_comparison_operator"
1307 (match_operand 0 "comparison_operator")
1309 machine_mode inmode = GET_MODE (XEXP (op, 0));
1310 enum rtx_code code = GET_CODE (op);
1312 if (inmode == CCFPmode)
1314 if (!ix86_trivial_fp_comparison_operator (op, mode))
1316 code = ix86_fp_compare_code_to_integer (code);
1318 /* i387 supports just limited amount of conditional codes. */
1321 case LTU: case GTU: case LEU: case GEU:
1322 if (inmode == CCmode || inmode == CCFPmode || inmode == CCCmode)
1325 case ORDERED: case UNORDERED:
1333 ;; Return true if OP is a comparison that can be used in the CMPSS/CMPPS insns.
1334 ;; The first set are supported directly; the second set can't be done with
1335 ;; full IEEE support, i.e. NaNs.
1337 (define_predicate "sse_comparison_operator"
1338 (ior (match_code "eq,ne,lt,le,unordered,unge,ungt,ordered")
1339 (and (match_test "TARGET_AVX")
1340 (match_code "ge,gt,uneq,unle,unlt,ltgt"))))
1342 (define_predicate "ix86_comparison_int_operator"
1343 (match_code "ne,eq,ge,gt,le,lt"))
1345 (define_predicate "ix86_comparison_uns_operator"
1346 (match_code "ne,eq,geu,gtu,leu,ltu"))
1348 (define_predicate "bt_comparison_operator"
1349 (match_code "ne,eq"))
1351 ;; Return true if OP is a valid comparison operator in valid mode.
1352 (define_predicate "ix86_comparison_operator"
1353 (match_operand 0 "comparison_operator")
1355 machine_mode inmode = GET_MODE (XEXP (op, 0));
1356 enum rtx_code code = GET_CODE (op);
1358 if (inmode == CCFPmode)
1359 return ix86_trivial_fp_comparison_operator (op, mode);
1364 if (inmode == CCGZmode)
1368 if (inmode == CCmode || inmode == CCGCmode
1369 || inmode == CCGOCmode || inmode == CCNOmode || inmode == CCGZmode)
1373 if (inmode == CCGZmode)
1377 if (inmode == CCmode || inmode == CCCmode || inmode == CCGZmode)
1380 case ORDERED: case UNORDERED:
1381 if (inmode == CCmode)
1385 if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
1393 ;; Return true if OP is a valid comparison operator
1394 ;; testing carry flag to be set.
1395 (define_predicate "ix86_carry_flag_operator"
1396 (match_code "ltu,lt,unlt,gtu,gt,ungt,le,unle,ge,unge,ltgt,uneq")
1398 machine_mode inmode = GET_MODE (XEXP (op, 0));
1399 enum rtx_code code = GET_CODE (op);
1401 if (inmode == CCFPmode)
1403 if (!ix86_trivial_fp_comparison_operator (op, mode))
1405 code = ix86_fp_compare_code_to_integer (code);
1407 else if (inmode == CCCmode)
1408 return code == LTU || code == GTU;
1409 else if (inmode != CCmode)
1415 ;; Return true if this comparison only requires testing one flag bit.
1416 (define_predicate "ix86_trivial_fp_comparison_operator"
1417 (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered"))
1419 ;; Return true if we know how to do this comparison. Others require
1420 ;; testing more than one flag bit, and we let the generic middle-end
1422 (define_predicate "ix86_fp_comparison_operator"
1423 (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
1424 == IX86_FPCMP_ARITH")
1425 (match_operand 0 "comparison_operator")
1426 (match_operand 0 "ix86_trivial_fp_comparison_operator")))
1428 ;; Nearly general operand, but accept any const_double, since we wish
1429 ;; to be able to drop them into memory rather than have them get pulled
1431 (define_predicate "cmp_fp_expander_operand"
1432 (ior (match_code "const_double")
1433 (match_operand 0 "general_operand")))
1435 ;; Return true if this is a valid binary floating-point operation.
1436 (define_predicate "binary_fp_operator"
1437 (match_code "plus,minus,mult,div"))
1439 ;; Return true if this is a multiply operation.
1440 (define_predicate "mult_operator"
1441 (match_code "mult"))
1443 ;; Return true if this is a division operation.
1444 (define_predicate "div_operator"
1447 ;; Return true if this is a plus, minus, and, ior or xor operation.
1448 (define_predicate "plusminuslogic_operator"
1449 (match_code "plus,minus,and,ior,xor"))
1451 ;; Return true for ARITHMETIC_P.
1452 (define_predicate "arith_or_logical_operator"
1453 (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div,
1454 mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert"))
1456 ;; Return true for COMMUTATIVE_P.
1457 (define_predicate "commutative_operator"
1458 (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax"))
1460 ;; Return true if OP is a binary operator that can be promoted to wider mode.
1461 (define_predicate "promotable_binary_operator"
1462 (ior (match_code "plus,minus,and,ior,xor,ashift")
1463 (and (match_code "mult")
1464 (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL"))))
1466 (define_predicate "compare_operator"
1467 (match_code "compare"))
1469 (define_predicate "absneg_operator"
1470 (match_code "abs,neg"))
1472 ;; Return true if OP is a memory operand, aligned to
1473 ;; less than its natural alignment.
1474 (define_predicate "misaligned_operand"
1475 (and (match_code "mem")
1476 (match_test "MEM_ALIGN (op) < GET_MODE_BITSIZE (mode)")))
1478 ;; Return true if OP is a emms operation, known to be a PARALLEL.
1479 (define_predicate "emms_operation"
1480 (match_code "parallel")
1484 if (XVECLEN (op, 0) != 17)
1487 for (i = 0; i < 8; i++)
1489 rtx elt = XVECEXP (op, 0, i+1);
1491 if (GET_CODE (elt) != CLOBBER
1492 || GET_CODE (SET_DEST (elt)) != REG
1493 || GET_MODE (SET_DEST (elt)) != XFmode
1494 || REGNO (SET_DEST (elt)) != FIRST_STACK_REG + i)
1497 elt = XVECEXP (op, 0, i+9);
1499 if (GET_CODE (elt) != CLOBBER
1500 || GET_CODE (SET_DEST (elt)) != REG
1501 || GET_MODE (SET_DEST (elt)) != DImode
1502 || REGNO (SET_DEST (elt)) != FIRST_MMX_REG + i)
1508 ;; Return true if OP is a vzeroall operation, known to be a PARALLEL.
1509 (define_predicate "vzeroall_operation"
1510 (match_code "parallel")
1512 unsigned i, nregs = TARGET_64BIT ? 16 : 8;
1514 if ((unsigned) XVECLEN (op, 0) != 1 + nregs)
1517 for (i = 0; i < nregs; i++)
1519 rtx elt = XVECEXP (op, 0, i+1);
1521 if (GET_CODE (elt) != SET
1522 || GET_CODE (SET_DEST (elt)) != REG
1523 || GET_MODE (SET_DEST (elt)) != V8SImode
1524 || REGNO (SET_DEST (elt)) != SSE_REGNO (i)
1525 || SET_SRC (elt) != CONST0_RTX (V8SImode))
1531 ;; return true if OP is a vzeroupper operation.
1532 (define_predicate "vzeroupper_operation"
1533 (and (match_code "unspec_volatile")
1534 (match_test "XINT (op, 1) == UNSPECV_VZEROUPPER")))
1536 ;; Return true if OP is an addsub vec_merge operation
1537 (define_predicate "addsub_vm_operator"
1538 (match_code "vec_merge")
1549 if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
1551 else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
1556 mask = INTVAL (XEXP (op, 2));
1557 nunits = GET_MODE_NUNITS (mode);
1559 for (elt = 0; elt < nunits; elt++)
1561 /* bit clear: take from op0, set: take from op1 */
1562 int bit = !(mask & (HOST_WIDE_INT_1U << elt));
1564 if (bit != ((elt & 1) ^ swapped))
1571 ;; Return true if OP is an addsub vec_select/vec_concat operation
1572 (define_predicate "addsub_vs_operator"
1573 (and (match_code "vec_select")
1574 (match_code "vec_concat" "0"))
1580 op0 = XEXP (XEXP (op, 0), 0);
1581 op1 = XEXP (XEXP (op, 0), 1);
1584 if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
1586 else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
1591 nunits = GET_MODE_NUNITS (mode);
1592 if (XVECLEN (XEXP (op, 1), 0) != nunits)
1595 /* We already checked that permutation is suitable for addsub,
1596 so only look at the first element of the parallel. */
1597 elt = INTVAL (XVECEXP (XEXP (op, 1), 0, 0));
1599 return elt == (swapped ? nunits : 0);
1602 ;; Return true if OP is a parallel for an addsub vec_select.
1603 (define_predicate "addsub_vs_parallel"
1604 (and (match_code "parallel")
1605 (match_code "const_int" "a"))
1607 int nelt = XVECLEN (op, 0);
1613 /* Check that the permutation is suitable for addsub.
1614 For example, { 0 9 2 11 4 13 6 15 } or { 8 1 10 3 12 5 14 7 }. */
1615 elt = INTVAL (XVECEXP (op, 0, 0));
1618 for (i = 1; i < nelt; ++i)
1619 if (INTVAL (XVECEXP (op, 0, i)) != (i + (i & 1) * nelt))
1622 else if (elt == nelt)
1624 for (i = 1; i < nelt; ++i)
1625 if (INTVAL (XVECEXP (op, 0, i)) != (elt + i - (i & 1) * nelt))
1634 ;; Return true if OP is a parallel for a vbroadcast permute.
1635 (define_predicate "avx_vbroadcast_operand"
1636 (and (match_code "parallel")
1637 (match_code "const_int" "a"))
1639 rtx elt = XVECEXP (op, 0, 0);
1640 int i, nelt = XVECLEN (op, 0);
1642 /* Don't bother checking there are the right number of operands,
1643 merely that they're all identical. */
1644 for (i = 1; i < nelt; ++i)
1645 if (XVECEXP (op, 0, i) != elt)
1650 ;; Return true if OP is a parallel for a palignr permute.
1651 (define_predicate "palignr_operand"
1652 (and (match_code "parallel")
1653 (match_code "const_int" "a"))
1655 int elt = INTVAL (XVECEXP (op, 0, 0));
1656 int i, nelt = XVECLEN (op, 0);
1658 /* Check that an order in the permutation is suitable for palignr.
1659 For example, {5 6 7 0 1 2 3 4} is "palignr 5, xmm, xmm". */
1660 for (i = 1; i < nelt; ++i)
1661 if (INTVAL (XVECEXP (op, 0, i)) != ((elt + i) % nelt))
1666 ;; Return true if OP is a proper third operand to vpblendw256.
1667 (define_predicate "avx2_pblendw_operand"
1668 (match_code "const_int")
1670 HOST_WIDE_INT val = INTVAL (op);
1671 HOST_WIDE_INT low = val & 0xff;
1672 return val == ((low << 8) | low);
1675 ;; Return true if OP is vector_operand or CONST_VECTOR.
1676 (define_predicate "general_vector_operand"
1677 (ior (match_operand 0 "vector_operand")
1678 (match_code "const_vector")))
1680 ;; Return true if OP is either -1 constant or stored in register.
1681 (define_predicate "register_or_constm1_operand"
1682 (ior (match_operand 0 "register_operand")
1683 (and (match_code "const_int")
1684 (match_test "op == constm1_rtx"))))
1686 ;; Return true if the vector ends with between 12 and 18 register saves using
1687 ;; RAX as the base address.
1688 (define_predicate "save_multiple"
1689 (match_code "parallel")
1691 const unsigned len = XVECLEN (op, 0);
1694 /* Starting from end of vector, count register saves. */
1695 for (i = 0; i < len; ++i)
1697 rtx src, dest, addr;
1698 rtx e = XVECEXP (op, 0, len - 1 - i);
1700 if (GET_CODE (e) != SET)
1704 dest = SET_DEST (e);
1706 if (!REG_P (src) || !MEM_P (dest))
1709 addr = XEXP (dest, 0);
1711 /* Good if dest address is in RAX. */
1712 if (REG_P (addr) && REGNO (addr) == AX_REG)
1715 /* Good if dest address is offset of RAX. */
1716 if (GET_CODE (addr) == PLUS
1717 && REG_P (XEXP (addr, 0))
1718 && REGNO (XEXP (addr, 0)) == AX_REG)
1723 return (i >= 12 && i <= 18);
1727 ;; Return true if the vector ends with between 12 and 18 register loads using
1728 ;; RSI as the base address.
1729 (define_predicate "restore_multiple"
1730 (match_code "parallel")
1732 const unsigned len = XVECLEN (op, 0);
1735 /* Starting from end of vector, count register restores. */
1736 for (i = 0; i < len; ++i)
1738 rtx src, dest, addr;
1739 rtx e = XVECEXP (op, 0, len - 1 - i);
1741 if (GET_CODE (e) != SET)
1745 dest = SET_DEST (e);
1747 if (!MEM_P (src) || !REG_P (dest))
1750 addr = XEXP (src, 0);
1752 /* Good if src address is in RSI. */
1753 if (REG_P (addr) && REGNO (addr) == SI_REG)
1756 /* Good if src address is offset of RSI. */
1757 if (GET_CODE (addr) == PLUS
1758 && REG_P (XEXP (addr, 0))
1759 && REGNO (XEXP (addr, 0)) == SI_REG)
1764 return (i >= 12 && i <= 18);