1 ;; Predicate definitions for DEC Alpha.
2 ;; Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010
3 ;; Free Software Foundation, Inc.
5 ;; This file is part of GCC.
7 ;; GCC is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation; either version 3, or (at your option)
12 ;; GCC is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 ;; GNU General Public License for more details.
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with GCC; see the file COPYING3. If not see
19 ;; <http://www.gnu.org/licenses/>.
21 ;; Return 1 if OP is the zero constant for MODE.
22 (define_predicate "const0_operand"
23 (and (match_code "const_int,const_double,const_vector")
24 (match_test "op == CONST0_RTX (mode)")))
26 ;; Returns true if OP is either the constant zero or a register.
27 (define_predicate "reg_or_0_operand"
28 (ior (match_operand 0 "register_operand")
29 (match_operand 0 "const0_operand")))
31 ;; Return 1 if OP is a constant in the range of 0-63 (for a shift) or
33 (define_predicate "reg_or_6bit_operand"
34 (if_then_else (match_code "const_int")
35 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 64")
36 (match_operand 0 "register_operand")))
38 ;; Return 1 if OP is an 8-bit constant.
39 (define_predicate "cint8_operand"
40 (and (match_code "const_int")
41 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 256")))
43 ;; Return 1 if OP is an 8-bit constant or any register.
44 (define_predicate "reg_or_8bit_operand"
45 (if_then_else (match_code "const_int")
46 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 256")
47 (match_operand 0 "register_operand")))
49 ;; Return 1 if OP is a constant or any register.
50 (define_predicate "reg_or_cint_operand"
51 (ior (match_operand 0 "register_operand")
52 (match_operand 0 "const_int_operand")))
54 ;; Return 1 if the operand is a valid second operand to an add insn.
55 (define_predicate "add_operand"
56 (if_then_else (match_code "const_int")
57 (match_test "satisfies_constraint_K (op) || satisfies_constraint_L (op)")
58 (match_operand 0 "register_operand")))
60 ;; Return 1 if the operand is a valid second operand to a
61 ;; sign-extending add insn.
62 (define_predicate "sext_add_operand"
63 (if_then_else (match_code "const_int")
64 (match_test "satisfies_constraint_I (op) || satisfies_constraint_O (op)")
65 (match_operand 0 "register_operand")))
67 ;; Return 1 if the operand is a non-symbolic constant operand that
68 ;; does not satisfy add_operand.
69 (define_predicate "non_add_const_operand"
70 (and (match_code "const_int,const_double,const_vector")
71 (not (match_operand 0 "add_operand"))))
73 ;; Return 1 if the operand is a non-symbolic, nonzero constant operand.
74 (define_predicate "non_zero_const_operand"
75 (and (match_code "const_int,const_double,const_vector")
76 (match_test "op != CONST0_RTX (mode)")))
78 ;; Return 1 if OP is the constant 4 or 8.
79 (define_predicate "const48_operand"
80 (and (match_code "const_int")
81 (match_test "INTVAL (op) == 4 || INTVAL (op) == 8")))
83 ;; Return 1 if OP is a valid first operand to an AND insn.
84 (define_predicate "and_operand"
85 (if_then_else (match_code "const_int")
86 (match_test "(unsigned HOST_WIDE_INT) INTVAL (op) < 0x100
87 || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100
88 || zap_mask (INTVAL (op))")
89 (if_then_else (match_code "const_double")
90 (match_test "GET_MODE (op) == VOIDmode
91 && zap_mask (CONST_DOUBLE_LOW (op))
92 && zap_mask (CONST_DOUBLE_HIGH (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,const_double")
116 if (CONST_INT_P (op))
118 HOST_WIDE_INT value = INTVAL (op);
124 if (value == 0xffffffff)
129 else if (HOST_BITS_PER_WIDE_INT == 32 && GET_CODE (op) == CONST_DOUBLE)
131 if (CONST_DOUBLE_LOW (op) == 0xffffffff && CONST_DOUBLE_HIGH (op) == 0)
137 ;; Return 1 if OP is a multiple of 8 less than 64.
138 (define_predicate "mul8_operand"
139 (match_code "const_int")
141 unsigned HOST_WIDE_INT i = INTVAL (op);
142 return i < 64 && i % 8 == 0;
145 ;; Return 1 if OP is a hard floating-point register.
146 (define_predicate "hard_fp_register_operand"
147 (match_operand 0 "register_operand")
149 if (GET_CODE (op) == SUBREG)
150 op = SUBREG_REG (op);
151 return REGNO_REG_CLASS (REGNO (op)) == FLOAT_REGS;
154 ;; Return 1 if OP is a hard general register.
155 (define_predicate "hard_int_register_operand"
156 (match_operand 0 "register_operand")
158 if (GET_CODE (op) == SUBREG)
159 op = SUBREG_REG (op);
160 return REGNO_REG_CLASS (REGNO (op)) == GENERAL_REGS;
163 ;; Return 1 if OP is something that can be reloaded into a register;
164 ;; if it is a MEM, it need not be valid.
165 (define_predicate "some_operand"
166 (ior (match_code "reg,mem,const_int,const_double,const_vector,
167 label_ref,symbol_ref,const,high")
168 (and (match_code "subreg")
169 (match_test "some_operand (SUBREG_REG (op), VOIDmode)"))))
171 ;; Likewise, but don't accept constants.
172 (define_predicate "some_ni_operand"
173 (ior (match_code "reg,mem")
174 (and (match_code "subreg")
175 (match_test "some_ni_operand (SUBREG_REG (op), VOIDmode)"))))
177 ;; Return 1 if OP is a valid operand for the source of a move insn.
178 (define_predicate "input_operand"
179 (match_code "label_ref,symbol_ref,const,high,reg,subreg,mem,
180 const_double,const_vector,const_int")
182 switch (GET_CODE (op))
187 if (TARGET_EXPLICIT_RELOCS)
189 /* We don't split symbolic operands into something unintelligable
190 until after reload, but we do not wish non-small, non-global
191 symbolic operands to be reconstructed from their high/lo_sum
193 return (small_symbolic_operand (op, mode)
194 || global_symbolic_operand (op, mode)
195 || gotdtp_symbolic_operand (op, mode)
196 || gottp_symbolic_operand (op, mode));
198 /* VMS still has a 32-bit mode. */
199 return mode == ptr_mode || mode == Pmode;
202 return (TARGET_EXPLICIT_RELOCS
203 && local_symbolic_operand (XEXP (op, 0), mode));
209 if (register_operand (op, mode))
211 /* ... fall through ... */
213 return ((TARGET_BWX || (mode != HImode && mode != QImode))
214 && general_operand (op, mode));
217 return op == CONST0_RTX (mode);
220 if (reload_in_progress || reload_completed)
221 return alpha_legitimate_constant_p (mode, op);
222 return op == CONST0_RTX (mode);
225 if (mode == QImode || mode == HImode)
227 if (reload_in_progress || reload_completed)
228 return alpha_legitimate_constant_p (mode, op);
229 return add_operand (op, mode);
237 ;; Return 1 if OP is a SYMBOL_REF for a function known to be in this
238 ;; file, and in the same section as the current function.
240 (define_predicate "samegp_function_operand"
241 (match_code "symbol_ref")
243 /* Easy test for recursion. */
244 if (op == XEXP (DECL_RTL (current_function_decl), 0))
247 /* Functions that are not local can be overridden, and thus may
248 not share the same gp. */
249 if (! SYMBOL_REF_LOCAL_P (op))
252 /* If -msmall-data is in effect, assume that there is only one GP
253 for the module, and so any local symbol has this property. We
254 need explicit relocations to be able to enforce this for symbols
255 not defined in this unit of translation, however. */
256 if (TARGET_EXPLICIT_RELOCS && TARGET_SMALL_DATA)
259 /* Functions that are not external are defined in this UoT,
260 and thus must share the same gp. */
261 return ! SYMBOL_REF_EXTERNAL_P (op);
264 ;; Return 1 if OP is a SYMBOL_REF for which we can make a call via bsr.
265 (define_predicate "direct_call_operand"
266 (match_operand 0 "samegp_function_operand")
268 /* If profiling is implemented via linker tricks, we can't jump
269 to the nogp alternate entry point. Note that crtl->profile
270 would not be correct, since that doesn't indicate if the target
271 function uses profiling. */
272 /* ??? TARGET_PROFILING_NEEDS_GP isn't really the right test,
273 but is approximately correct for the OSF ABIs. Don't know
274 what to do for VMS, NT, or UMK. */
275 if (!TARGET_PROFILING_NEEDS_GP && profile_flag)
278 /* Must be a function. In some cases folks create thunks in static
279 data structures and then make calls to them. If we allow the
280 direct call, we'll get an error from the linker about !samegp reloc
281 against a symbol without a .prologue directive. */
282 if (!SYMBOL_REF_FUNCTION_P (op))
285 /* Must be "near" so that the branch is assumed to reach. With
286 -msmall-text, this is assumed true of all local symbols. Since
287 we've already checked samegp, locality is already assured. */
288 if (TARGET_SMALL_TEXT)
294 ;; Return 1 if OP is a valid operand for the MEM of a CALL insn.
296 ;; For TARGET_ABI_OSF, we want to restrict to R27 or a pseudo.
298 (define_predicate "call_operand"
299 (ior (match_code "symbol_ref")
300 (and (match_code "reg")
301 (ior (match_test "!TARGET_ABI_OSF")
302 (match_test "!HARD_REGISTER_P (op)")
303 (match_test "REGNO (op) == R27_REG")))))
305 ;; Return true if OP is a LABEL_REF, or SYMBOL_REF or CONST referencing
306 ;; a (non-tls) variable known to be defined in this file.
307 (define_predicate "local_symbolic_operand"
308 (match_code "label_ref,const,symbol_ref")
310 if (GET_CODE (op) == CONST
311 && GET_CODE (XEXP (op, 0)) == PLUS
312 && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
313 op = XEXP (XEXP (op, 0), 0);
315 if (GET_CODE (op) == LABEL_REF)
318 if (GET_CODE (op) != SYMBOL_REF)
321 return (SYMBOL_REF_LOCAL_P (op)
322 && !SYMBOL_REF_WEAK (op)
323 && !SYMBOL_REF_TLS_MODEL (op));
326 ;; Return true if OP is a SYMBOL_REF or CONST referencing a variable
327 ;; known to be defined in this file in the small data area.
328 (define_predicate "small_symbolic_operand"
329 (match_code "const,symbol_ref")
331 if (! TARGET_SMALL_DATA)
334 if (GET_CODE (op) == CONST
335 && GET_CODE (XEXP (op, 0)) == PLUS
336 && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
337 op = XEXP (XEXP (op, 0), 0);
339 if (GET_CODE (op) != SYMBOL_REF)
342 /* ??? There's no encode_section_info equivalent for the rtl
343 constant pool, so SYMBOL_FLAG_SMALL never gets set. */
344 if (CONSTANT_POOL_ADDRESS_P (op))
345 return GET_MODE_SIZE (get_pool_mode (op)) <= g_switch_value;
347 return (SYMBOL_REF_LOCAL_P (op)
348 && SYMBOL_REF_SMALL_P (op)
349 && !SYMBOL_REF_WEAK (op)
350 && !SYMBOL_REF_TLS_MODEL (op));
353 ;; Return true if OP is a SYMBOL_REF or CONST referencing a variable
354 ;; not known (or known not) to be defined in this file.
355 (define_predicate "global_symbolic_operand"
356 (match_code "const,symbol_ref")
358 if (GET_CODE (op) == CONST
359 && GET_CODE (XEXP (op, 0)) == PLUS
360 && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
361 op = XEXP (XEXP (op, 0), 0);
363 if (GET_CODE (op) != SYMBOL_REF)
366 return ((!SYMBOL_REF_LOCAL_P (op) || SYMBOL_REF_WEAK (op))
367 && !SYMBOL_REF_TLS_MODEL (op));
370 ;; Returns 1 if OP is a symbolic operand, i.e. a symbol_ref or a label_ref,
371 ;; possibly with an offset.
372 (define_predicate "symbolic_operand"
373 (ior (match_code "symbol_ref,label_ref")
374 (and (match_code "const")
375 (match_test "GET_CODE (XEXP (op,0)) == PLUS
376 && (GET_CODE (XEXP (XEXP (op,0), 0)) == SYMBOL_REF
377 || GET_CODE (XEXP (XEXP (op,0), 0)) == LABEL_REF)
378 && CONST_INT_P (XEXP (XEXP (op,0), 1))"))))
380 ;; Return true if OP is valid for 16-bit DTP relative relocations.
381 (define_predicate "dtp16_symbolic_operand"
382 (and (match_code "const")
383 (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_DTPREL)")))
385 ;; Return true if OP is valid for 32-bit DTP relative relocations.
386 (define_predicate "dtp32_symbolic_operand"
387 (and (match_code "const")
388 (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_DTPREL)")))
390 ;; Return true if OP is valid for 64-bit DTP relative relocations.
391 (define_predicate "gotdtp_symbolic_operand"
392 (and (match_code "const")
393 (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_DTPREL)")))
395 ;; Return true if OP is valid for 16-bit TP relative relocations.
396 (define_predicate "tp16_symbolic_operand"
397 (and (match_code "const")
398 (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_TPREL)")))
400 ;; Return true if OP is valid for 32-bit TP relative relocations.
401 (define_predicate "tp32_symbolic_operand"
402 (and (match_code "const")
403 (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_TPREL)")))
405 ;; Return true if OP is valid for 64-bit TP relative relocations.
406 (define_predicate "gottp_symbolic_operand"
407 (and (match_code "const")
408 (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_TPREL)")))
410 ;; Return 1 if this memory address is a known aligned register plus
411 ;; a constant. It must be a valid address. This means that we can do
412 ;; this as an aligned reference plus some offset.
414 ;; Take into account what reload will do. Oh god this is awful.
415 ;; The horrible comma-operator construct below is to prevent genrecog
416 ;; from thinking that this predicate accepts REG and SUBREG. We don't
417 ;; use recog during reload, so pretending these codes are accepted
418 ;; pessimizes things a tad.
420 (define_special_predicate "aligned_memory_operand"
421 (ior (match_test "op = resolve_reload_operand (op), 0")
427 if (MEM_ALIGN (op) >= 32)
432 /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
433 sorts of constructs. Dig for the real base register. */
434 if (reload_in_progress
435 && GET_CODE (op) == PLUS
436 && GET_CODE (XEXP (op, 0)) == PLUS)
438 base = XEXP (XEXP (op, 0), 0);
439 offset = INTVAL (XEXP (op, 1));
443 if (! memory_address_p (mode, op))
445 if (GET_CODE (op) == PLUS)
448 offset = INTVAL (XEXP (op, 1));
457 if (offset % GET_MODE_SIZE (mode))
460 return (REG_P (base) && REGNO_POINTER_ALIGN (REGNO (base)) >= 32);
463 ;; Similar, but return 1 if OP is a MEM which is not alignable.
465 (define_special_predicate "unaligned_memory_operand"
466 (ior (match_test "op = resolve_reload_operand (op), 0")
472 if (MEM_ALIGN (op) >= 32)
477 /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
478 sorts of constructs. Dig for the real base register. */
479 if (reload_in_progress
480 && GET_CODE (op) == PLUS
481 && GET_CODE (XEXP (op, 0)) == PLUS)
483 base = XEXP (XEXP (op, 0), 0);
484 offset = INTVAL (XEXP (op, 1));
488 if (! memory_address_p (mode, op))
490 if (GET_CODE (op) == PLUS)
493 offset = INTVAL (XEXP (op, 1));
502 if (offset % GET_MODE_SIZE (mode))
505 return (REG_P (base) && REGNO_POINTER_ALIGN (REGNO (base)) < 32);
508 ;; Return 1 if OP is any memory location. During reload a pseudo matches.
509 (define_special_predicate "any_memory_operand"
510 (match_code "mem,reg,subreg")
512 if (GET_CODE (op) == SUBREG)
513 op = SUBREG_REG (op);
517 if (reload_in_progress && REG_P (op))
519 unsigned regno = REGNO (op);
520 if (HARD_REGISTER_NUM_P (regno))
523 return reg_renumber[regno] < 0;
529 ;; Return 1 is OP is a memory location that is not a reference
530 ;; (using an AND) to an unaligned location. Take into account
531 ;; what reload will do.
532 (define_special_predicate "normal_memory_operand"
533 (ior (match_test "op = resolve_reload_operand (op), 0")
534 (and (match_code "mem")
535 (match_test "GET_CODE (XEXP (op, 0)) != AND"))))
537 ;; Returns 1 if OP is not an eliminable register.
539 ;; This exists to cure a pathological failure in the s8addq (et al) patterns,
541 ;; long foo () { long t; bar(); return (long) &t * 26107; }
543 ;; which run afoul of a hack in reload to cure a (presumably) similar
544 ;; problem with lea-type instructions on other targets. But there is
545 ;; one of us and many of them, so work around the problem by selectively
546 ;; preventing combine from making the optimization.
548 (define_predicate "reg_not_elim_operand"
549 (match_operand 0 "register_operand")
551 if (GET_CODE (op) == SUBREG)
552 op = SUBREG_REG (op);
553 return op != frame_pointer_rtx && op != arg_pointer_rtx;
556 ;; Accept a register, but not a subreg of any kind. This allows us to
557 ;; avoid pathological cases in reload wrt data movement common in
558 ;; int->fp conversion. */
559 (define_predicate "reg_no_subreg_operand"
560 (and (match_code "reg")
561 (match_operand 0 "register_operand")))
563 ;; Return 1 if OP is a valid Alpha comparison operator for "cbranch"
565 (define_predicate "alpha_cbranch_operator"
566 (ior (match_operand 0 "ordered_comparison_operator")
567 (match_code "ordered,unordered")))
569 ;; Return 1 if OP is a valid Alpha comparison operator for "cmp" style
571 (define_predicate "alpha_comparison_operator"
572 (match_code "eq,le,lt,leu,ltu"))
574 ;; Similarly, but with swapped operands.
575 (define_predicate "alpha_swapped_comparison_operator"
576 (match_code "eq,ge,gt,gtu"))
578 ;; Return 1 if OP is a valid Alpha comparison operator against zero
579 ;; for "bcc" style instructions.
580 (define_predicate "alpha_zero_comparison_operator"
581 (match_code "eq,ne,le,lt,leu,ltu"))
583 ;; Return 1 if OP is a signed comparison operation.
584 (define_predicate "signed_comparison_operator"
585 (match_code "eq,ne,le,lt,ge,gt"))
587 ;; Return 1 if OP is a valid Alpha floating point comparison operator.
588 (define_predicate "alpha_fp_comparison_operator"
589 (match_code "eq,le,lt,unordered"))
591 ;; Return 1 if this is a divide or modulus operator.
592 (define_predicate "divmod_operator"
593 (match_code "div,mod,udiv,umod"))
595 ;; Return 1 if this is a float->int conversion operator.
596 (define_predicate "fix_operator"
597 (match_code "fix,unsigned_fix"))
599 ;; Recognize an addition operation that includes a constant. Used to
600 ;; convince reload to canonize (plus (plus reg c1) c2) during register
603 (define_predicate "addition_operation"
604 (and (match_code "plus")
605 (match_test "register_operand (XEXP (op, 0), mode)
606 && satisfies_constraint_K (XEXP (op, 1))")))
608 ;; For TARGET_EXPLICIT_RELOCS, we don't obfuscate a SYMBOL_REF to a
609 ;; small symbolic operand until after reload. At which point we need
610 ;; to replace (mem (symbol_ref)) with (mem (lo_sum $29 symbol_ref))
611 ;; so that sched2 has the proper dependency information. */
612 (define_predicate "some_small_symbolic_operand"
613 (match_code "set,parallel,prefetch,unspec,unspec_volatile")
615 /* Avoid search unless necessary. */
616 if (!TARGET_EXPLICIT_RELOCS || !reload_completed)
618 return for_each_rtx (&op, some_small_symbolic_operand_int, NULL);
621 ;; Accept a register, or a memory if BWX is enabled.
622 (define_predicate "reg_or_bwx_memory_operand"
623 (ior (match_operand 0 "register_operand")
624 (and (match_test "TARGET_BWX")
625 (match_operand 0 "memory_operand"))))
627 ;; Accept a memory whose address is only a register.
628 (define_predicate "mem_noofs_operand"
629 (and (match_code "mem")
630 (match_code "reg" "0")))