1 ;; Predicate definitions for DEC Alpha.
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 1 if OP is the zero constant for MODE.
21 (define_predicate "const0_operand"
22 (and (match_code "const_int,const_wide_int,const_double,const_vector")
23 (match_test "op == CONST0_RTX (mode)")))
25 ;; Returns true if OP is either the constant zero or a register.
26 (define_predicate "reg_or_0_operand"
27 (ior (match_operand 0 "register_operand")
28 (match_operand 0 "const0_operand")))
30 ;; Return 1 if OP is a constant in the range of 0-63 (for a shift) or
32 (define_predicate "reg_or_6bit_operand"
33 (if_then_else (match_code "const_int")
34 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 64")
35 (match_operand 0 "register_operand")))
37 ;; Return 1 if OP is an 8-bit constant.
38 (define_predicate "cint8_operand"
39 (and (match_code "const_int")
40 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 256")))
42 ;; Return 1 if OP is an 8-bit constant or any register.
43 (define_predicate "reg_or_8bit_operand"
44 (if_then_else (match_code "const_int")
45 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 256")
46 (match_operand 0 "register_operand")))
48 ;; Return 1 if OP is a constant or any register.
49 (define_predicate "reg_or_cint_operand"
50 (ior (match_operand 0 "register_operand")
51 (match_operand 0 "const_int_operand")))
53 ;; Return 1 if the operand is a valid second operand to an add insn.
54 (define_predicate "add_operand"
55 (if_then_else (match_code "const_int")
56 (match_test "satisfies_constraint_K (op) || satisfies_constraint_L (op)")
57 (match_operand 0 "register_operand")))
59 ;; Return 1 if the operand is a valid second operand to a
60 ;; sign-extending add insn.
61 (define_predicate "sext_add_operand"
62 (if_then_else (match_code "const_int")
63 (match_test "satisfies_constraint_I (op) || satisfies_constraint_O (op)")
64 (match_operand 0 "register_operand")))
66 ;; Return 1 if the operand is a non-symbolic constant operand that
67 ;; does not satisfy add_operand.
68 (define_predicate "non_add_const_operand"
69 (and (match_code "const_int,const_wide_int,const_double,const_vector")
70 (not (match_operand 0 "add_operand"))))
72 ;; Return 1 if the operand is a non-symbolic, nonzero constant operand.
73 (define_predicate "non_zero_const_operand"
74 (and (match_code "const_int,const_wide_int,const_double,const_vector")
75 (not (match_test "op == CONST0_RTX (mode)"))))
77 ;; Return 1 if OP is the constant 2 or 3.
78 (define_predicate "const23_operand"
79 (and (match_code "const_int")
80 (match_test "INTVAL (op) == 2 || INTVAL (op) == 3")))
82 ;; Return 1 if OP is the constant 4 or 8.
83 (define_predicate "const48_operand"
84 (and (match_code "const_int")
85 (match_test "INTVAL (op) == 4 || INTVAL (op) == 8")))
87 ;; Return 1 if OP is a valid first operand to an AND insn.
88 (define_predicate "and_operand"
89 (if_then_else (match_code "const_int")
90 (match_test "(unsigned HOST_WIDE_INT) INTVAL (op) < 0x100
91 || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100
92 || zap_mask (INTVAL (op))")
93 (match_operand 0 "register_operand")))
95 ;; Return 1 if OP is a valid first operand to an IOR or XOR insn.
96 (define_predicate "or_operand"
97 (if_then_else (match_code "const_int")
98 (match_test "(unsigned HOST_WIDE_INT) INTVAL (op) < 0x100
99 || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100")
100 (match_operand 0 "register_operand")))
102 ;; Return 1 if OP is a constant that is the width, in bits, of an integral
103 ;; mode not larger than DImode.
104 (define_predicate "mode_width_operand"
105 (match_code "const_int")
107 HOST_WIDE_INT i = INTVAL (op);
108 return i == 8 || i == 16 || i == 32 || i == 64;
111 ;; Return 1 if OP is a constant that is a mask of ones of width of an
112 ;; integral machine mode not larger than DImode.
113 (define_predicate "mode_mask_operand"
114 (match_code "const_int")
116 HOST_WIDE_INT value = INTVAL (op);
122 if (value == 0xffffffff)
130 ;; Return 1 if OP is a multiple of 8 less than 64.
131 (define_predicate "mul8_operand"
132 (match_code "const_int")
134 unsigned HOST_WIDE_INT i = INTVAL (op);
135 return i < 64 && i % 8 == 0;
138 ;; Return 1 if OP is a hard floating-point register.
139 (define_predicate "hard_fp_register_operand"
140 (match_operand 0 "register_operand")
143 op = SUBREG_REG (op);
144 return REGNO_REG_CLASS (REGNO (op)) == FLOAT_REGS;
147 ;; Return 1 if OP is a hard general register.
148 (define_predicate "hard_int_register_operand"
149 (match_operand 0 "register_operand")
152 op = SUBREG_REG (op);
153 return REGNO_REG_CLASS (REGNO (op)) == GENERAL_REGS;
156 ;; Return 1 if OP is a valid operand for the source of a move insn.
157 (define_predicate "input_operand"
158 (match_operand 0 "general_operand")
160 switch (GET_CODE (op))
165 if (TARGET_EXPLICIT_RELOCS)
167 /* We don't split symbolic operands into something unintelligable
168 until after reload, but we do not wish non-small, non-global
169 symbolic operands to be reconstructed from their high/lo_sum
171 return (small_symbolic_operand (op, mode)
172 || global_symbolic_operand (op, mode)
173 || gotdtp_symbolic_operand (op, mode)
174 || gottp_symbolic_operand (op, mode));
176 /* VMS still has a 32-bit mode. */
177 return mode == ptr_mode || mode == Pmode;
180 return (TARGET_EXPLICIT_RELOCS
181 && local_symbolic_operand (XEXP (op, 0), mode));
187 if (register_operand (op, mode))
191 return ((TARGET_BWX || (mode != HImode && mode != QImode))
192 && general_operand (op, mode));
196 return op == CONST0_RTX (mode);
199 if (reload_in_progress || reload_completed)
200 return alpha_legitimate_constant_p (mode, op);
201 return op == CONST0_RTX (mode);
204 if (mode == QImode || mode == HImode)
206 if (reload_in_progress || reload_completed)
207 return alpha_legitimate_constant_p (mode, op);
208 return add_operand (op, mode);
216 ;; Return 1 if OP is a SYMBOL_REF for a function known to be in this
217 ;; file, and in the same section as the current function.
219 (define_predicate "samegp_function_operand"
220 (match_code "symbol_ref")
222 /* Easy test for recursion. */
223 if (op == XEXP (DECL_RTL (current_function_decl), 0))
226 /* Functions that are not local can be overridden, and thus may
227 not share the same gp. */
228 if (! SYMBOL_REF_LOCAL_P (op))
231 /* If -msmall-data is in effect, assume that there is only one GP
232 for the module, and so any local symbol has this property. We
233 need explicit relocations to be able to enforce this for symbols
234 not defined in this unit of translation, however. */
235 if (TARGET_EXPLICIT_RELOCS && TARGET_SMALL_DATA)
238 /* Functions that are not external are defined in this UoT,
239 and thus must share the same gp. */
240 return ! SYMBOL_REF_EXTERNAL_P (op);
243 ;; Return 1 if OP is a SYMBOL_REF for which we can make a call via bsr.
244 (define_predicate "direct_call_operand"
245 (match_operand 0 "samegp_function_operand")
247 /* If profiling is implemented via linker tricks, we can't jump
248 to the nogp alternate entry point. Note that crtl->profile
249 would not be correct, since that doesn't indicate if the target
250 function uses profiling. */
251 /* ??? TARGET_PROFILING_NEEDS_GP isn't really the right test,
252 but is approximately correct for the OSF ABIs. Don't know
253 what to do for VMS, NT, or UMK. */
254 if (!TARGET_PROFILING_NEEDS_GP && profile_flag)
257 /* Must be a function. In some cases folks create thunks in static
258 data structures and then make calls to them. If we allow the
259 direct call, we'll get an error from the linker about !samegp reloc
260 against a symbol without a .prologue directive. */
261 if (!SYMBOL_REF_FUNCTION_P (op))
264 /* Must be "near" so that the branch is assumed to reach. With
265 -msmall-text, this is assumed true of all local symbols. Since
266 we've already checked samegp, locality is already assured. */
267 if (TARGET_SMALL_TEXT)
273 ;; Return 1 if OP is a valid operand for the MEM of a CALL insn.
275 ;; For TARGET_ABI_OSF, we want to restrict to R27 or a pseudo.
277 (define_predicate "call_operand"
278 (ior (match_code "symbol_ref")
279 (and (match_code "reg")
280 (ior (not (match_test "TARGET_ABI_OSF"))
281 (not (match_test "HARD_REGISTER_P (op)"))
282 (match_test "REGNO (op) == R27_REG")))))
284 ;; Return true if OP is a LABEL_REF, or SYMBOL_REF or CONST referencing
285 ;; a (non-tls) variable known to be defined in this file.
286 (define_predicate "local_symbolic_operand"
287 (match_code "label_ref,const,symbol_ref")
289 if (GET_CODE (op) == CONST
290 && GET_CODE (XEXP (op, 0)) == PLUS
291 && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
292 op = XEXP (XEXP (op, 0), 0);
294 if (GET_CODE (op) == LABEL_REF)
297 if (GET_CODE (op) != SYMBOL_REF)
300 return (SYMBOL_REF_LOCAL_P (op)
301 && !SYMBOL_REF_WEAK (op)
302 && !SYMBOL_REF_TLS_MODEL (op));
305 ;; Return true if OP is a SYMBOL_REF or CONST referencing a variable
306 ;; known to be defined in this file in the small data area.
307 (define_predicate "small_symbolic_operand"
308 (match_code "const,symbol_ref")
310 HOST_WIDE_INT ofs = 0, max_ofs = 0;
312 if (! TARGET_SMALL_DATA)
315 if (GET_CODE (op) == CONST
316 && GET_CODE (XEXP (op, 0)) == PLUS
317 && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
319 ofs = INTVAL (XEXP (XEXP (op, 0), 1));
320 op = XEXP (XEXP (op, 0), 0);
323 if (GET_CODE (op) != SYMBOL_REF)
326 /* ??? There's no encode_section_info equivalent for the rtl
327 constant pool, so SYMBOL_FLAG_SMALL never gets set. */
328 if (CONSTANT_POOL_ADDRESS_P (op))
330 max_ofs = GET_MODE_SIZE (get_pool_mode (op));
331 if (max_ofs > g_switch_value)
334 else if (SYMBOL_REF_LOCAL_P (op)
335 && SYMBOL_REF_SMALL_P (op)
336 && !SYMBOL_REF_WEAK (op)
337 && !SYMBOL_REF_TLS_MODEL (op))
339 if (SYMBOL_REF_DECL (op))
340 max_ofs = tree_to_uhwi (DECL_SIZE_UNIT (SYMBOL_REF_DECL (op)));
345 /* Given that we know that the GP is always 8 byte aligned, we can
346 always adjust by 7 without overflowing. */
350 /* Since we know this is an object in a small data section, we know the
351 entire section is addressable via GP. We don't know where the section
352 boundaries are, but we know the entire object is within. */
353 return IN_RANGE (ofs, 0, max_ofs - 1);
356 ;; Return true if OP is a SYMBOL_REF or CONST referencing a variable
357 ;; not known (or known not) to be defined in this file.
358 (define_predicate "global_symbolic_operand"
359 (match_code "const,symbol_ref")
361 if (GET_CODE (op) == CONST
362 && GET_CODE (XEXP (op, 0)) == PLUS
363 && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
364 op = XEXP (XEXP (op, 0), 0);
366 if (GET_CODE (op) != SYMBOL_REF)
369 return ((!SYMBOL_REF_LOCAL_P (op) || SYMBOL_REF_WEAK (op))
370 && !SYMBOL_REF_TLS_MODEL (op));
373 ;; Returns 1 if OP is a symbolic operand, i.e. a symbol_ref or a label_ref,
374 ;; possibly with an offset.
375 (define_predicate "symbolic_operand"
376 (ior (match_code "symbol_ref,label_ref")
377 (and (match_code "const")
378 (match_code "plus" "0")
379 (match_code "symbol_ref,label_ref" "00")
380 (match_code "const_int" "01"))))
382 ;; Return true if OP is valid for 16-bit DTP relative relocations.
383 (define_predicate "dtp16_symbolic_operand"
384 (and (match_code "const")
385 (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_DTPREL)")))
387 ;; Return true if OP is valid for 32-bit DTP relative relocations.
388 (define_predicate "dtp32_symbolic_operand"
389 (and (match_code "const")
390 (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_DTPREL)")))
392 ;; Return true if OP is valid for 64-bit DTP relative relocations.
393 (define_predicate "gotdtp_symbolic_operand"
394 (and (match_code "const")
395 (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_DTPREL)")))
397 ;; Return true if OP is valid for 16-bit TP relative relocations.
398 (define_predicate "tp16_symbolic_operand"
399 (and (match_code "const")
400 (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_TPREL)")))
402 ;; Return true if OP is valid for 32-bit TP relative relocations.
403 (define_predicate "tp32_symbolic_operand"
404 (and (match_code "const")
405 (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_TPREL)")))
407 ;; Return true if OP is valid for 64-bit TP relative relocations.
408 (define_predicate "gottp_symbolic_operand"
409 (and (match_code "const")
410 (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_TPREL)")))
412 ;; Return 1 if this memory address is a known aligned register plus
413 ;; a constant. It must be a valid address. This means that we can do
414 ;; this as an aligned reference plus some offset.
416 ;; Take into account what reload will do. Oh god this is awful.
417 ;; The horrible comma-operator construct below is to prevent genrecog
418 ;; from thinking that this predicate accepts REG and SUBREG. We don't
419 ;; use recog during reload, so pretending these codes are accepted
420 ;; pessimizes things a tad.
422 (define_special_predicate "aligned_memory_operand"
423 (ior (match_test "op = resolve_reload_operand (op), 0")
429 if (MEM_ALIGN (op) >= 32)
434 /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
435 sorts of constructs. Dig for the real base register. */
436 if (reload_in_progress
437 && GET_CODE (op) == PLUS
438 && GET_CODE (XEXP (op, 0)) == PLUS)
440 base = XEXP (XEXP (op, 0), 0);
441 offset = INTVAL (XEXP (op, 1));
445 if (! memory_address_p (mode, op))
447 if (GET_CODE (op) == PLUS)
450 offset = INTVAL (XEXP (op, 1));
459 if (offset % GET_MODE_SIZE (mode))
462 return (REG_P (base) && REGNO_POINTER_ALIGN (REGNO (base)) >= 32);
465 ;; Similar, but return 1 if OP is a MEM which is not alignable.
467 (define_special_predicate "unaligned_memory_operand"
468 (ior (match_test "op = resolve_reload_operand (op), 0")
474 if (MEM_ALIGN (op) >= 32)
479 /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
480 sorts of constructs. Dig for the real base register. */
481 if (reload_in_progress
482 && GET_CODE (op) == PLUS
483 && GET_CODE (XEXP (op, 0)) == PLUS)
485 base = XEXP (XEXP (op, 0), 0);
486 offset = INTVAL (XEXP (op, 1));
490 if (! memory_address_p (mode, op))
492 if (GET_CODE (op) == PLUS)
495 offset = INTVAL (XEXP (op, 1));
504 if (offset % GET_MODE_SIZE (mode))
507 return (REG_P (base) && REGNO_POINTER_ALIGN (REGNO (base)) < 32);
510 ;; Return 1 if OP is any memory location. During reload a pseudo matches.
511 (define_special_predicate "any_memory_operand"
512 (match_code "mem,reg,subreg")
515 op = SUBREG_REG (op);
519 if (reload_in_progress && REG_P (op))
521 unsigned regno = REGNO (op);
522 if (HARD_REGISTER_NUM_P (regno))
525 return reg_renumber[regno] < 0;
531 ;; Returns 1 if OP is not an eliminable register.
533 ;; This exists to cure a pathological failure in the s8addq (et al) patterns,
535 ;; long foo () { long t; bar(); return (long) &t * 26107; }
537 ;; which run afoul of a hack in reload to cure a (presumably) similar
538 ;; problem with lea-type instructions on other targets. But there is
539 ;; one of us and many of them, so work around the problem by selectively
540 ;; preventing combine from making the optimization.
542 (define_predicate "reg_not_elim_operand"
543 (match_operand 0 "register_operand")
546 op = SUBREG_REG (op);
547 return op != frame_pointer_rtx && op != arg_pointer_rtx;
550 ;; Accept a register, but not a subreg of any kind. This allows us to
551 ;; avoid pathological cases in reload wrt data movement common in
552 ;; int->fp conversion. */
553 (define_predicate "reg_no_subreg_operand"
554 (and (match_code "reg")
555 (match_operand 0 "register_operand")))
557 ;; Return 1 if OP is a valid Alpha comparison operator for "cbranch"
559 (define_predicate "alpha_cbranch_operator"
560 (ior (match_operand 0 "ordered_comparison_operator")
561 (match_code "ordered,unordered")))
563 ;; Return 1 if OP is a valid Alpha comparison operator for "cmp" style
565 (define_predicate "alpha_comparison_operator"
566 (match_code "eq,le,lt,leu,ltu"))
568 ;; Similarly, but with swapped operands.
569 (define_predicate "alpha_swapped_comparison_operator"
570 (match_code "eq,ge,gt,gtu"))
572 ;; Return 1 if OP is a valid Alpha comparison operator against zero
573 ;; for "bcc" style instructions.
574 (define_predicate "alpha_zero_comparison_operator"
575 (match_code "eq,ne,le,lt,leu,ltu"))
577 ;; Return 1 if OP is a signed comparison operation.
578 (define_predicate "signed_comparison_operator"
579 (match_code "eq,ne,le,lt,ge,gt"))
581 ;; Return 1 if OP is a valid Alpha floating point comparison operator.
582 (define_predicate "alpha_fp_comparison_operator"
583 (match_code "eq,le,lt,unordered"))
585 ;; Return 1 if this is a divide or modulus operator.
586 (define_predicate "divmod_operator"
587 (match_code "div,mod,udiv,umod"))
589 ;; Return 1 if this is a float->int conversion operator.
590 (define_predicate "fix_operator"
591 (match_code "fix,unsigned_fix"))
593 ;; Recognize an addition operation that includes a constant. Used to
594 ;; convince reload to canonize (plus (plus reg c1) c2) during register
597 (define_predicate "addition_operation"
598 (and (match_code "plus")
599 (match_test "register_operand (XEXP (op, 0), mode)
600 && satisfies_constraint_K (XEXP (op, 1))")))
602 ;; For TARGET_EXPLICIT_RELOCS, we don't obfuscate a SYMBOL_REF to a
603 ;; small symbolic operand until after reload. At which point we need
604 ;; to replace (mem (symbol_ref)) with (mem (lo_sum $29 symbol_ref))
605 ;; so that sched2 has the proper dependency information. */
606 (define_predicate "some_small_symbolic_operand"
607 (match_code "set,parallel,prefetch,unspec,unspec_volatile")
609 /* Avoid search unless necessary. */
610 if (!TARGET_EXPLICIT_RELOCS || !reload_completed)
612 return some_small_symbolic_operand_int (op);
615 ;; Accept a register, or a memory if BWX is enabled.
616 (define_predicate "reg_or_bwx_memory_operand"
617 (ior (match_operand 0 "register_operand")
618 (and (match_test "TARGET_BWX")
619 (match_operand 0 "memory_operand"))))
621 ;; Accept a memory whose address is only a register.
622 (define_predicate "mem_noofs_operand"
623 (and (match_code "mem")
624 (match_code "reg" "0")))