1 ;; Predicate definitions for IA-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 ;; True if OP is a valid operand for the MEM of a CALL insn.
21 (define_predicate "call_operand"
22 (ior (match_code "symbol_ref")
23 (match_operand 0 "register_operand")))
25 ;; True if OP refers to any kind of symbol.
26 ;; For roughly the same reasons that pmode_register_operand exists, this
27 ;; predicate ignores its mode argument.
28 (define_special_predicate "symbolic_operand"
29 (match_code "symbol_ref,const,label_ref"))
31 ;; True if OP is a SYMBOL_REF which refers to a function.
32 (define_predicate "function_operand"
33 (and (match_code "symbol_ref")
34 (match_test "SYMBOL_REF_FUNCTION_P (op)")))
36 ;; True if OP refers to a symbol in the sdata section.
37 (define_predicate "sdata_symbolic_operand"
38 (match_code "symbol_ref,const")
40 HOST_WIDE_INT offset = 0, size = 0;
42 switch (GET_CODE (op))
46 if (GET_CODE (op) != PLUS
47 || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
48 || GET_CODE (XEXP (op, 1)) != CONST_INT)
50 offset = INTVAL (XEXP (op, 1));
55 if (CONSTANT_POOL_ADDRESS_P (op))
57 size = GET_MODE_SIZE (get_pool_mode (op));
58 if (size > ia64_section_threshold)
65 if (!SYMBOL_REF_LOCAL_P (op) || !SYMBOL_REF_SMALL_P (op))
68 /* Note that in addition to DECLs, we can get various forms
70 t = SYMBOL_REF_DECL (op);
73 /* Common symbol isn't placed in small data section. */
76 t = DECL_SIZE_UNIT (t);
79 t = TYPE_SIZE_UNIT (TREE_TYPE (t));
80 if (t && tree_fits_shwi_p (t))
82 size = tree_to_shwi (t);
88 /* Deny the stupid user trick of addressing outside the object. Such
89 things quickly result in GPREL22 relocation overflows. Of course,
90 they're also highly undefined. From a pure pedant's point of view
91 they deserve a slap on the wrist (such as provided by a relocation
92 overflow), but that just leads to bugzilla noise. */
93 return (offset >= 0 && offset <= size);
100 ;; True if OP refers to a local symbol [+any offset].
102 ;; movl % = @gprel(symbol+offset)
104 (define_predicate "local_symbolic_operand64"
105 (match_code "symbol_ref,const")
107 switch (GET_CODE (op))
111 if (GET_CODE (op) != PLUS
112 || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
113 || GET_CODE (XEXP (op, 1)) != CONST_INT)
119 return SYMBOL_REF_LOCAL_P (op);
126 ;; True if OP refers to a symbol in the small address area.
127 (define_predicate "small_addr_symbolic_operand"
128 (match_code "symbol_ref,const")
130 switch (GET_CODE (op))
134 if (GET_CODE (op) != PLUS
135 || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
136 || GET_CODE (XEXP (op, 1)) != CONST_INT)
142 return SYMBOL_REF_SMALL_ADDR_P (op);
149 ;; True if OP refers to a symbol with which we may use any offset.
150 (define_predicate "any_offset_symbol_operand"
151 (match_code "symbol_ref")
153 if (TARGET_NO_PIC || TARGET_AUTO_PIC)
155 if (SYMBOL_REF_SMALL_ADDR_P (op))
157 if (SYMBOL_REF_FUNCTION_P (op))
159 if (sdata_symbolic_operand (op, mode))
164 ;; True if OP refers to a symbol with which we may use 14-bit aligned offsets.
165 ;; False if OP refers to a symbol with which we may not use any offset at any
167 (define_predicate "aligned_offset_symbol_operand"
168 (and (match_code "symbol_ref")
169 (match_test "! SYMBOL_REF_FUNCTION_P (op)")))
171 ;; True if OP refers to a symbol, and is appropriate for a GOT load.
172 (define_predicate "got_symbolic_operand"
173 (match_operand 0 "symbolic_operand" "")
175 HOST_WIDE_INT addend = 0;
177 switch (GET_CODE (op))
183 /* Accept only (plus (symbol_ref) (const_int)). */
185 if (GET_CODE (op) != PLUS
186 || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
187 || GET_CODE (XEXP (op, 1)) != CONST_INT)
190 addend = INTVAL (XEXP (op, 1));
195 /* These symbols shouldn't be used with got loads. */
196 if (SYMBOL_REF_SMALL_ADDR_P (op))
198 if (SYMBOL_REF_TLS_MODEL (op) != 0)
201 if (any_offset_symbol_operand (op, mode))
204 /* The low 14 bits of the constant have been forced to zero
205 so that we do not use up so many GOT entries. Prevent cse
206 from undoing this. */
207 if (aligned_offset_symbol_operand (op, mode))
208 return (addend & 0x3fff) == 0;
217 ;; Return true if OP is a valid thread local storage symbolic operand.
218 (define_predicate "tls_symbolic_operand"
219 (match_code "symbol_ref,const")
221 switch (GET_CODE (op))
224 return SYMBOL_REF_TLS_MODEL (op) != 0;
228 if (GET_CODE (op) != PLUS
229 || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
230 || GET_CODE (XEXP (op, 1)) != CONST_INT)
233 /* We only allow certain offsets for certain tls models. */
234 switch (SYMBOL_REF_TLS_MODEL (XEXP (op, 0)))
236 case TLS_MODEL_GLOBAL_DYNAMIC:
237 case TLS_MODEL_LOCAL_DYNAMIC:
240 case TLS_MODEL_INITIAL_EXEC:
241 return (INTVAL (XEXP (op, 1)) & 0x3fff) == 0;
243 case TLS_MODEL_LOCAL_EXEC:
255 ;; Return true if OP is a local-dynamic thread local storage symbolic operand.
256 (define_predicate "ld_tls_symbolic_operand"
257 (and (match_code "symbol_ref")
258 (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_DYNAMIC")))
260 ;; Return true if OP is an initial-exec thread local storage symbolic operand.
261 (define_predicate "ie_tls_symbolic_operand"
262 (match_code "symbol_ref,const")
264 switch (GET_CODE (op))
268 if (GET_CODE (op) != PLUS
269 || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
270 || GET_CODE (XEXP (op, 1)) != CONST_INT
271 || (INTVAL (XEXP (op, 1)) & 0x3fff) != 0)
277 return SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_INITIAL_EXEC;
284 ;; Return true if OP is a local-exec thread local storage symbolic operand.
285 (define_predicate "le_tls_symbolic_operand"
286 (match_code "symbol_ref,const")
288 switch (GET_CODE (op))
292 if (GET_CODE (op) != PLUS
293 || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
294 || GET_CODE (XEXP (op, 1)) != CONST_INT)
300 return SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_EXEC;
307 ;; Like nonimmediate_operand, but don't allow MEMs that try to use a
308 ;; POST_MODIFY with a REG as displacement.
309 (define_predicate "destination_operand"
310 (and (match_operand 0 "nonimmediate_operand")
311 (match_test "GET_CODE (op) != MEM
312 || GET_CODE (XEXP (op, 0)) != POST_MODIFY
313 || GET_CODE (XEXP (XEXP (XEXP (op, 0), 1), 1)) != REG")))
315 ;; Like destination_operand, but don't allow any post-increments.
316 (define_predicate "not_postinc_destination_operand"
317 (and (match_operand 0 "nonimmediate_operand")
318 (match_test "GET_CODE (op) != MEM
319 || GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC")))
321 ;; Like memory_operand, but don't allow post-increments.
322 (define_predicate "not_postinc_memory_operand"
323 (and (match_operand 0 "memory_operand")
324 (match_test "GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC")))
326 ;; True if OP is a general operand, with some restrictions on symbols.
327 (define_predicate "move_operand"
328 (match_operand 0 "general_operand")
330 switch (GET_CODE (op))
334 HOST_WIDE_INT addend;
336 /* Accept only (plus (symbol_ref) (const_int)). */
338 if (GET_CODE (op) != PLUS
339 || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
340 || GET_CODE (XEXP (op, 1)) != CONST_INT)
343 addend = INTVAL (XEXP (op, 1));
346 /* After reload, we want to allow any offset whatsoever. This
347 allows reload the opportunity to avoid spilling addresses to
348 the stack, and instead simply substitute in the value from a
349 REG_EQUIV. We'll split this up again when splitting the insn. */
350 if (reload_in_progress || reload_completed)
353 /* Some symbol types we allow to use with any offset. */
354 if (any_offset_symbol_operand (op, mode))
357 /* Some symbol types we allow offsets with the low 14 bits of the
358 constant forced to zero so that we do not use up so many GOT
359 entries. We want to prevent cse from undoing this. */
360 if (aligned_offset_symbol_operand (op, mode))
361 return (addend & 0x3fff) == 0;
363 /* The remaining symbol types may never be used with an offset. */
372 ;; Like move_operand but don't allow post-increments.
373 (define_predicate "not_postinc_move_operand"
374 (and (match_operand 0 "move_operand")
375 (match_test "GET_CODE (op) != MEM
376 || GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC")))
378 ;; True if OP is a register operand that is (or could be) a GR reg.
379 (define_predicate "gr_register_operand"
380 (match_operand 0 "register_operand")
383 if (GET_CODE (op) == SUBREG)
384 op = SUBREG_REG (op);
387 return (regno >= FIRST_PSEUDO_REGISTER || GENERAL_REGNO_P (regno));
390 ;; True if OP is a register operand that is (or could be) an FR reg.
391 (define_predicate "fr_register_operand"
392 (match_operand 0 "register_operand")
395 if (GET_CODE (op) == SUBREG)
396 op = SUBREG_REG (op);
399 return (regno >= FIRST_PSEUDO_REGISTER || FR_REGNO_P (regno));
402 ;; True if OP is a register operand that is (or could be) a GR/FR reg.
403 (define_predicate "grfr_register_operand"
404 (match_operand 0 "register_operand")
407 if (GET_CODE (op) == SUBREG)
408 op = SUBREG_REG (op);
411 return (regno >= FIRST_PSEUDO_REGISTER
412 || GENERAL_REGNO_P (regno)
413 || FR_REGNO_P (regno));
416 ;; True if OP is a nonimmediate operand that is (or could be) a GR reg.
417 (define_predicate "gr_nonimmediate_operand"
418 (match_operand 0 "nonimmediate_operand")
422 if (GET_CODE (op) == MEM)
424 if (GET_CODE (op) == SUBREG)
425 op = SUBREG_REG (op);
428 return (regno >= FIRST_PSEUDO_REGISTER || GENERAL_REGNO_P (regno));
431 ;; True if OP is a nonimmediate operand that is (or could be) a FR reg.
432 (define_predicate "fr_nonimmediate_operand"
433 (match_operand 0 "nonimmediate_operand")
437 if (GET_CODE (op) == MEM)
439 if (GET_CODE (op) == SUBREG)
440 op = SUBREG_REG (op);
443 return (regno >= FIRST_PSEUDO_REGISTER || FR_REGNO_P (regno));
446 ;; True if OP is a nonimmediate operand that is (or could be) a GR/FR reg.
447 (define_predicate "grfr_nonimmediate_operand"
448 (match_operand 0 "nonimmediate_operand")
452 if (GET_CODE (op) == MEM)
454 if (GET_CODE (op) == SUBREG)
455 op = SUBREG_REG (op);
458 return (regno >= FIRST_PSEUDO_REGISTER
459 || GENERAL_REGNO_P (regno)
460 || FR_REGNO_P (regno));
463 ;; True if OP is a GR register operand, or zero.
464 (define_predicate "gr_reg_or_0_operand"
465 (ior (match_operand 0 "gr_register_operand")
466 (and (match_code "const_int,const_double,const_vector")
467 (match_test "op == CONST0_RTX (GET_MODE (op))"))))
469 ;; True if OP is a GR register operand, or a 5-bit immediate operand.
470 (define_predicate "gr_reg_or_5bit_operand"
471 (ior (match_operand 0 "gr_register_operand")
472 (and (match_code "const_int")
473 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 32"))))
475 ;; True if OP is a GR register operand, or a 6-bit immediate operand.
476 (define_predicate "gr_reg_or_6bit_operand"
477 (ior (match_operand 0 "gr_register_operand")
478 (and (match_code "const_int")
479 (match_test "satisfies_constraint_M (op)"))))
481 ;; True if OP is a GR register operand, or an 8-bit immediate operand.
482 (define_predicate "gr_reg_or_8bit_operand"
483 (ior (match_operand 0 "gr_register_operand")
484 (and (match_code "const_int")
485 (match_test "satisfies_constraint_K (op)"))))
487 ;; True if OP is a GR/FR register operand, or an 8-bit immediate operand.
488 (define_predicate "grfr_reg_or_8bit_operand"
489 (ior (match_operand 0 "grfr_register_operand")
490 (and (match_code "const_int")
491 (match_test "satisfies_constraint_K (op)"))))
493 ;; True if OP is a register operand, or an 8-bit adjusted immediate operand.
494 (define_predicate "gr_reg_or_8bit_adjusted_operand"
495 (ior (match_operand 0 "gr_register_operand")
496 (and (match_code "const_int")
497 (match_test "satisfies_constraint_L (op)"))))
499 ;; True if OP is a register operand, or is valid for both an 8-bit
500 ;; immediate and an 8-bit adjusted immediate operand. This is necessary
501 ;; because when we emit a compare, we don't know what the condition will be,
502 ;; so we need the union of the immediates accepted by GT and LT.
503 (define_predicate "gr_reg_or_8bit_and_adjusted_operand"
504 (ior (match_operand 0 "gr_register_operand")
505 (and (match_code "const_int")
506 (match_test "satisfies_constraint_K (op)
507 && satisfies_constraint_L (op)"))))
509 ;; True if OP is a register operand, or a 14-bit immediate operand.
510 (define_predicate "gr_reg_or_14bit_operand"
511 (ior (match_operand 0 "gr_register_operand")
512 (and (match_code "const_int")
513 (match_test "satisfies_constraint_I (op)"))))
515 ;; True if OP is a register operand, or a 22-bit immediate operand.
516 (define_predicate "gr_reg_or_22bit_operand"
517 (ior (match_operand 0 "gr_register_operand")
518 (and (match_code "const_int")
519 (match_test "satisfies_constraint_J (op)"))))
521 ;; True if OP is a 7-bit immediate operand.
522 (define_predicate "dshift_count_operand"
523 (and (match_code "const_int")
524 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 128")))
526 ;; True if OP is a 6-bit immediate operand.
527 (define_predicate "shift_count_operand"
528 (and (match_code "const_int")
529 (match_test "satisfies_constraint_M (op)")))
531 ;; True if OP-1 is a 6-bit immediate operand, used in extr instruction.
532 (define_predicate "extr_len_operand"
533 (and (match_code "const_int")
534 (match_test "satisfies_constraint_M (GEN_INT (INTVAL (op) - 1))")))
536 ;; True if OP is a 5-bit immediate operand.
537 (define_predicate "shift_32bit_count_operand"
538 (and (match_code "const_int")
539 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 32")))
541 ;; True if OP is one of the immediate values 2, 4, 8, or 16.
542 (define_predicate "shladd_operand"
543 (and (match_code "const_int")
544 (match_test "INTVAL (op) == 2 || INTVAL (op) == 4 ||
545 INTVAL (op) == 8 || INTVAL (op) == 16")))
547 ;; True if OP is one of the immediate values 1, 2, 3, or 4.
548 (define_predicate "shladd_log2_operand"
549 (and (match_code "const_int")
550 (match_test "INTVAL (op) >= 1 && INTVAL (op) <= 4")))
552 ;; True if OP is one of the immediate values -16, -8, -4, -1, 1, 4, 8, 16.
553 (define_predicate "fetchadd_operand"
554 (and (match_code "const_int")
555 (match_test "INTVAL (op) == -16 || INTVAL (op) == -8 ||
556 INTVAL (op) == -4 || INTVAL (op) == -1 ||
557 INTVAL (op) == 1 || INTVAL (op) == 4 ||
558 INTVAL (op) == 8 || INTVAL (op) == 16")))
560 ;; True if OP is one of the immediate values 0, 7, 15, 16
561 (define_predicate "pmpyshr_operand"
562 (and (match_code "const_int")
563 (match_test "INTVAL (op) == 0 || INTVAL (op) == 7
564 || INTVAL (op) == 15 || INTVAL (op) == 16")))
566 ;; True if OP is 0..3.
567 (define_predicate "const_int_2bit_operand"
568 (and (match_code "const_int")
569 (match_test "INTVAL (op) >= 0 && INTVAL (op) <= 3")))
571 ;; True if OP is a floating-point constant zero, one, or a register.
572 (define_predicate "fr_reg_or_fp01_operand"
573 (ior (match_operand 0 "fr_register_operand")
574 (and (match_code "const_double")
575 (match_test "satisfies_constraint_G (op)"))))
577 ;; Like fr_reg_or_fp01_operand, but don't allow any SUBREGs.
578 (define_predicate "xfreg_or_fp01_operand"
579 (and (match_operand 0 "fr_reg_or_fp01_operand")
580 (not (match_code "subreg"))))
582 ;; Like fr_reg_or_fp01_operand, but don't allow 0 if flag_signed_zero is set.
583 ;; Using f0 as the second arg to fadd or fsub, or as the third arg to fma or
584 ;; fms can cause a zero result to have the wrong sign.
585 (define_predicate "fr_reg_or_signed_fp01_operand"
586 (ior (match_operand 0 "fr_register_operand")
587 (and (match_code "const_double")
588 (match_test "satisfies_constraint_Z (op)"))))
590 ;; Like fr_reg_or_signed_fp01_operand, but don't allow any SUBREGs.
591 (define_predicate "xfreg_or_signed_fp01_operand"
592 (and (match_operand 0 "fr_reg_or_signed_fp01_operand")
593 (not (match_code "subreg"))))
595 ;; True if OP is a constant zero, or a register.
596 (define_predicate "fr_reg_or_0_operand"
597 (ior (match_operand 0 "fr_register_operand")
598 (and (match_code "const_double,const_vector")
599 (match_test "op == CONST0_RTX (GET_MODE (op))"))))
601 ;; Return 1 if OP is a valid comparison operator for "cbranch" instructions.
602 ;; If we're assuming that FP operations cannot generate user-visible traps,
603 ;; then we can use the FP unordered-signaling instructions to implement the
604 ;; FP unordered-quiet comparison predicates.
605 (define_predicate "ia64_cbranch_operator"
606 (if_then_else (match_test "flag_trapping_math")
607 (ior (match_operand 0 "ordered_comparison_operator")
608 (match_code "ordered,unordered"))
609 (and (match_operand 0 "comparison_operator")
610 (not (match_code "uneq,ltgt")))))
612 ;; True if this is a comparison operator, which accepts a normal 8-bit
613 ;; signed immediate operand.
614 (define_predicate "normal_comparison_operator"
615 (match_code "eq,ne,gt,le,gtu,leu"))
617 ;; True if this is a comparison operator, which accepts an adjusted 8-bit
618 ;; signed immediate operand.
619 (define_predicate "adjusted_comparison_operator"
620 (match_code "lt,ge,ltu,geu"))
622 ;; True if this is a signed inequality operator.
623 (define_predicate "signed_inequality_operator"
624 (match_code "ge,gt,le,lt"))
626 ;; True if this operator is valid for predication.
627 (define_predicate "predicate_operator"
628 (match_code "eq,ne"))
630 ;; True if this operator can be used in a conditional operation.
631 (define_predicate "condop_operator"
632 (match_code "plus,minus,ior,xor,and"))
634 ;; These three are hardware registers that can only be addressed in
635 ;; DImode. It's not strictly necessary to test mode == DImode here,
636 ;; but it makes decent insurance against someone writing a
637 ;; match_operand wrong.
639 ;; True if this is the ar.lc register.
640 (define_predicate "ar_lc_reg_operand"
641 (and (match_code "reg")
642 (match_test "mode == DImode && REGNO (op) == AR_LC_REGNUM")))
644 ;; True if this is the ar.ccv register.
645 (define_predicate "ar_ccv_reg_operand"
646 (and (match_code "reg")
647 (match_test "mode == DImode && REGNO (op) == AR_CCV_REGNUM")))
649 ;; True if this is the ar.pfs register.
650 (define_predicate "ar_pfs_reg_operand"
651 (and (match_code "reg")
652 (match_test "mode == DImode && REGNO (op) == AR_PFS_REGNUM")))
654 ;; True if OP is valid as a base register in a reg + offset address.
655 ;; ??? Should I copy the flag_omit_frame_pointer and cse_not_expected
656 ;; checks from pa.c basereg_operand as well? Seems to be OK without them
658 (define_predicate "basereg_operand"
659 (match_operand 0 "register_operand")
661 return REG_P (op) && REG_POINTER (op);
664 ;; True if this is the right-most vector element; for mux1 @brcst.
665 (define_predicate "mux1_brcst_element"
666 (and (match_code "const_int")
667 (match_test "INTVAL (op) == (TARGET_BIG_ENDIAN ? 7 : 0)")))