gcc/config/alpha/predicates.md

   1 ;; Predicate definitions for DEC Alpha.
   2 ;; Copyright (C) 2004, 2005 Free Software Foundation, Inc.
   3 ;;
   4 ;; This file is part of GCC.
   5 ;;
   6 ;; GCC is free software; you can redistribute it and/or modify
   7 ;; it under the terms of the GNU General Public License as published by
   8 ;; the Free Software Foundation; either version 2, or (at your option)
   9 ;; any later version.
  10 ;;
  11 ;; GCC is distributed in the hope that it will be useful,
  12 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ;; GNU General Public License for more details.
  15 ;;
  16 ;; You should have received a copy of the GNU General Public License
  17 ;; along with GCC; see the file COPYING.  If not, write to
  18 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
  19 ;; Boston, MA 02111-1307, USA.
  20
  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)")))
  25
  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")))
  30
  31 ;; Return 1 if OP is a constant in the range of 0-63 (for a shift) or
  32 ;; any register.
  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")))
  37
  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")))
  42
  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")))
  48
  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")))
  53
  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 "CONST_OK_FOR_LETTER_P (INTVAL (op), 'K')
  58                  || CONST_OK_FOR_LETTER_P (INTVAL (op), 'L')")
  59     (match_operand 0 "register_operand")))
  60
  61 ;; Return 1 if the operand is a valid second operand to a
  62 ;; sign-extending add insn.
  63 (define_predicate "sext_add_operand"
  64   (if_then_else (match_code "const_int")
  65     (match_test "CONST_OK_FOR_LETTER_P (INTVAL (op), 'I')
  66                  || CONST_OK_FOR_LETTER_P (INTVAL (op), 'O')")
  67     (match_operand 0 "register_operand")))
  68
  69 ;; Return 1 if the operand is a non-symbolic constant operand that
  70 ;; does not satisfy add_operand.
  71 (define_predicate "non_add_const_operand"
  72   (and (match_code "const_int,const_double,const_vector")
  73        (not (match_operand 0 "add_operand"))))
  74
  75 ;; Return 1 if the operand is a non-symbolic, non-zero constant operand.
  76 (define_predicate "non_zero_const_operand"
  77   (and (match_code "const_int,const_double,const_vector")
  78        (match_test "op != CONST0_RTX (mode)")))
  79
  80 ;; Return 1 if OP is the constant 4 or 8.
  81 (define_predicate "const48_operand"
  82   (and (match_code "const_int")
  83        (match_test "INTVAL (op) == 4 || INTVAL (op) == 8")))
  84
  85 ;; Return 1 if OP is a valid first operand to an AND insn.
  86 (define_predicate "and_operand"
  87   (if_then_else (match_code "const_int")
  88     (match_test "(unsigned HOST_WIDE_INT) INTVAL (op) < 0x100
  89                  || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100
  90                  || zap_mask (INTVAL (op))")
  91     (if_then_else (match_code "const_double")
  92       (match_test "zap_mask (CONST_DOUBLE_LOW (op))
  93                    && zap_mask (CONST_DOUBLE_HIGH (op))")
  94       (match_operand 0 "register_operand"))))
  95
  96 ;; Return 1 if OP is a valid first operand to an IOR or XOR insn.
  97 (define_predicate "or_operand"
  98   (if_then_else (match_code "const_int")
  99     (match_test "(unsigned HOST_WIDE_INT) INTVAL (op) < 0x100
 100                  || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100")
 101     (match_operand 0 "register_operand")))
 102
 103 ;; Return 1 if OP is a constant that is the width, in bits, of an integral
 104 ;; mode not larger than DImode.
 105 (define_predicate "mode_width_operand"
 106   (match_code "const_int")
 107 {
 108   HOST_WIDE_INT i = INTVAL (op);
 109   return i == 8 || i == 16 || i == 32 || i == 64;
 110 })
 111
 112 ;; Return 1 if OP is a constant that is a mask of ones of width of an
 113 ;; integral machine mode not larger than DImode.
 114 (define_predicate "mode_mask_operand"
 115   (match_code "const_int,const_double")
 116 {
 117   if (GET_CODE (op) == CONST_INT)
 118     {
 119       HOST_WIDE_INT value = INTVAL (op);
 120
 121       if (value == 0xff)
 122         return 1;
 123       if (value == 0xffff)
 124         return 1;
 125       if (value == 0xffffffff)
 126         return 1;
 127       if (value == -1)
 128         return 1;
 129     }
 130   else if (HOST_BITS_PER_WIDE_INT == 32 && GET_CODE (op) == CONST_DOUBLE)
 131     {
 132       if (CONST_DOUBLE_LOW (op) == 0xffffffff && CONST_DOUBLE_HIGH (op) == 0)
 133         return 1;
 134     }
 135   return 0;
 136 })
 137
 138 ;; Return 1 if OP is a multiple of 8 less than 64.
 139 (define_predicate "mul8_operand"
 140   (match_code "const_int")
 141 {
 142   unsigned HOST_WIDE_INT i = INTVAL (op);
 143   return i < 64 && i % 8 == 0;
 144 })
 145
 146 ;; Return 1 if OP is a hard floating-point register.
 147 (define_predicate "hard_fp_register_operand"
 148   (match_operand 0 "register_operand")
 149 {
 150   if (GET_CODE (op) == SUBREG)
 151     op = SUBREG_REG (op);
 152   return REGNO_REG_CLASS (REGNO (op)) == FLOAT_REGS;
 153 })
 154
 155 ;; Return 1 if OP is a hard general register.
 156 (define_predicate "hard_int_register_operand"
 157   (match_operand 0 "register_operand")
 158 {
 159   if (GET_CODE (op) == SUBREG)
 160     op = SUBREG_REG (op);
 161   return REGNO_REG_CLASS (REGNO (op)) == GENERAL_REGS;
 162 })
 163
 164 ;; Return 1 if OP is something that can be reloaded into a register;
 165 ;; if it is a MEM, it need not be valid.
 166 (define_predicate "some_operand"
 167   (ior (match_code "reg,mem,const_int,const_double,const_vector,
 168                     label_ref,symbol_ref,const,high")
 169        (and (match_code "subreg")
 170             (match_test "some_operand (SUBREG_REG (op), VOIDmode)"))))
 171
 172 ;; Likewise, but don't accept constants.
 173 (define_predicate "some_ni_operand"
 174   (ior (match_code "reg,mem")
 175        (and (match_code "subreg")
 176             (match_test "some_ni_operand (SUBREG_REG (op), VOIDmode)"))))
 177
 178 ;; Return 1 if OP is a valid operand for the source of a move insn.
 179 (define_predicate "input_operand"
 180   (match_code "label_ref,symbol_ref,const,high,reg,subreg,mem,
 181                const_double,const_vector,const_int")
 182 {
 183   switch (GET_CODE (op))
 184     {
 185     case LABEL_REF:
 186     case SYMBOL_REF:
 187     case CONST:
 188       if (TARGET_EXPLICIT_RELOCS)
 189         {
 190           /* We don't split symbolic operands into something unintelligable
 191              until after reload, but we do not wish non-small, non-global
 192              symbolic operands to be reconstructed from their high/lo_sum
 193              form.  */
 194           return (small_symbolic_operand (op, mode)
 195                   || global_symbolic_operand (op, mode)
 196                   || gotdtp_symbolic_operand (op, mode)
 197                   || gottp_symbolic_operand (op, mode));
 198         }
 199
 200       /* This handles both the Windows/NT and OSF cases.  */
 201       return mode == ptr_mode || mode == DImode;
 202
 203     case HIGH:
 204       return (TARGET_EXPLICIT_RELOCS
 205               && local_symbolic_operand (XEXP (op, 0), mode));
 206
 207     case REG:
 208       return 1;
 209
 210     case SUBREG:
 211       if (register_operand (op, mode))
 212         return 1;
 213       /* ... fall through ...  */
 214     case MEM:
 215       return ((TARGET_BWX || (mode != HImode && mode != QImode))
 216               && general_operand (op, mode));
 217
 218     case CONST_DOUBLE:
 219       return op == CONST0_RTX (mode);
 220
 221     case CONST_VECTOR:
 222       if (reload_in_progress || reload_completed)
 223         return alpha_legitimate_constant_p (op);
 224       return op == CONST0_RTX (mode);
 225
 226     case CONST_INT:
 227       if (mode == QImode || mode == HImode)
 228         return true;
 229       if (reload_in_progress || reload_completed)
 230         return alpha_legitimate_constant_p (op);
 231       return add_operand (op, mode);
 232
 233     default:
 234       gcc_unreachable ();
 235     }
 236   return 0;
 237 })
 238
 239 ;; Return 1 if OP is a SYMBOL_REF for a function known to be in this
 240 ;; file, and in the same section as the current function.
 241
 242 (define_predicate "samegp_function_operand"
 243   (match_code "symbol_ref")
 244 {
 245   /* Easy test for recursion.  */
 246   if (op == XEXP (DECL_RTL (current_function_decl), 0))
 247     return true;
 248
 249   /* Functions that are not local can be overridden, and thus may
 250      not share the same gp.  */
 251   if (! SYMBOL_REF_LOCAL_P (op))
 252     return false;
 253
 254   /* If -msmall-data is in effect, assume that there is only one GP
 255      for the module, and so any local symbol has this property.  We
 256      need explicit relocations to be able to enforce this for symbols
 257      not defined in this unit of translation, however.  */
 258   if (TARGET_EXPLICIT_RELOCS && TARGET_SMALL_DATA)
 259     return true;
 260
 261   /* Functions that are not external are defined in this UoT,
 262      and thus must share the same gp.  */
 263   return ! SYMBOL_REF_EXTERNAL_P (op);
 264 })
 265
 266 ;; Return 1 if OP is a SYMBOL_REF for which we can make a call via bsr.
 267 (define_predicate "direct_call_operand"
 268   (match_operand 0 "samegp_function_operand")
 269 {
 270   tree op_decl, cfun_sec, op_sec;
 271
 272   /* If profiling is implemented via linker tricks, we can't jump
 273      to the nogp alternate entry point.  Note that current_function_profile
 274      would not be correct, since that doesn't indicate if the target
 275      function uses profiling.  */
 276   /* ??? TARGET_PROFILING_NEEDS_GP isn't really the right test,
 277      but is approximately correct for the OSF ABIs.  Don't know
 278      what to do for VMS, NT, or UMK.  */
 279   if (!TARGET_PROFILING_NEEDS_GP && profile_flag)
 280     return false;
 281
 282   /* Must be a function.  In some cases folks create thunks in static
 283      data structures and then make calls to them.  If we allow the
 284      direct call, we'll get an error from the linker about !samegp reloc
 285      against a symbol without a .prologue directive.  */
 286   if (!SYMBOL_REF_FUNCTION_P (op))
 287     return false;
 288
 289   /* Must be "near" so that the branch is assumed to reach.  With
 290      -msmall-text, this is assumed true of all local symbols.  Since
 291      we've already checked samegp, locality is already assured.  */
 292   if (TARGET_SMALL_TEXT)
 293     return true;
 294
 295   /* Otherwise, a decl is "near" if it is defined in the same section.  */
 296   if (flag_function_sections)
 297     return false;
 298
 299   op_decl = SYMBOL_REF_DECL (op);
 300   if (DECL_ONE_ONLY (current_function_decl)
 301       || (op_decl && DECL_ONE_ONLY (op_decl)))
 302     return false;
 303
 304   cfun_sec = DECL_SECTION_NAME (current_function_decl);
 305   op_sec = op_decl ? DECL_SECTION_NAME (op_decl) : NULL;
 306   return ((!cfun_sec && !op_sec)
 307           || (cfun_sec && op_sec
 308               && strcmp (TREE_STRING_POINTER (cfun_sec),
 309                          TREE_STRING_POINTER (op_sec)) == 0));
 310 })
 311
 312 ;; Return 1 if OP is a valid operand for the MEM of a CALL insn.
 313 ;;
 314 ;; For TARGET_ABI_OSF, we want to restrict to R27 or a pseudo.
 315 ;; For TARGET_ABI_UNICOSMK, we want to restrict to registers.
 316
 317 (define_predicate "call_operand"
 318   (if_then_else (match_code "reg")
 319     (match_test "!TARGET_ABI_OSF
 320                  || REGNO (op) == 27 || REGNO (op) > LAST_VIRTUAL_REGISTER")
 321     (and (match_test "!TARGET_ABI_UNICOSMK")
 322          (match_code "symbol_ref"))))
 323
 324 ;; Return true if OP is a LABEL_REF, or SYMBOL_REF or CONST referencing
 325 ;; a (non-tls) variable known to be defined in this file.
 326 (define_predicate "local_symbolic_operand"
 327   (match_code "label_ref,const,symbol_ref")
 328 {
 329   if (GET_CODE (op) == LABEL_REF)
 330     return 1;
 331
 332   if (GET_CODE (op) == CONST
 333       && GET_CODE (XEXP (op, 0)) == PLUS
 334       && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT)
 335     op = XEXP (XEXP (op, 0), 0);
 336
 337   if (GET_CODE (op) != SYMBOL_REF)
 338     return 0;
 339
 340   return SYMBOL_REF_LOCAL_P (op) && !SYMBOL_REF_TLS_MODEL (op);
 341 })
 342
 343 ;; Return true if OP is a SYMBOL_REF or CONST referencing a variable
 344 ;; known to be defined in this file in the small data area.
 345 (define_predicate "small_symbolic_operand"
 346   (match_code "const,symbol_ref")
 347 {
 348   if (! TARGET_SMALL_DATA)
 349     return 0;
 350
 351   if (GET_CODE (op) == CONST
 352       && GET_CODE (XEXP (op, 0)) == PLUS
 353       && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT)
 354     op = XEXP (XEXP (op, 0), 0);
 355
 356   if (GET_CODE (op) != SYMBOL_REF)
 357     return 0;
 358
 359   /* ??? There's no encode_section_info equivalent for the rtl
 360      constant pool, so SYMBOL_FLAG_SMALL never gets set.  */
 361   if (CONSTANT_POOL_ADDRESS_P (op))
 362     return GET_MODE_SIZE (get_pool_mode (op)) <= g_switch_value;
 363
 364   return (SYMBOL_REF_LOCAL_P (op)
 365           && SYMBOL_REF_SMALL_P (op)
 366           && SYMBOL_REF_TLS_MODEL (op) == 0);
 367 })
 368
 369 ;; Return true if OP is a SYMBOL_REF or CONST referencing a variable
 370 ;; not known (or known not) to be defined in this file.
 371 (define_predicate "global_symbolic_operand"
 372   (match_code "const,symbol_ref")
 373 {
 374   if (GET_CODE (op) == CONST
 375       && GET_CODE (XEXP (op, 0)) == PLUS
 376       && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT)
 377     op = XEXP (XEXP (op, 0), 0);
 378
 379   if (GET_CODE (op) != SYMBOL_REF)
 380     return 0;
 381
 382   return !SYMBOL_REF_LOCAL_P (op) && !SYMBOL_REF_TLS_MODEL (op);
 383 })
 384
 385 ;; Returns 1 if OP is a symbolic operand, i.e. a symbol_ref or a label_ref,
 386 ;; possibly with an offset.
 387 (define_predicate "symbolic_operand"
 388   (ior (match_code "symbol_ref,label_ref")
 389        (and (match_code "const")
 390             (match_test "GET_CODE (XEXP (op,0)) == PLUS
 391                          && GET_CODE (XEXP (XEXP (op,0), 0)) == SYMBOL_REF
 392                          && GET_CODE (XEXP (XEXP (op,0), 1)) == CONST_INT"))))
 393
 394 ;; Return true if OP is valid for 16-bit DTP relative relocations.
 395 (define_predicate "dtp16_symbolic_operand"
 396   (and (match_code "const")
 397        (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_DTPREL)")))
 398
 399 ;; Return true if OP is valid for 32-bit DTP relative relocations.
 400 (define_predicate "dtp32_symbolic_operand"
 401   (and (match_code "const")
 402        (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_DTPREL)")))
 403
 404 ;; Return true if OP is valid for 64-bit DTP relative relocations.
 405 (define_predicate "gotdtp_symbolic_operand"
 406   (and (match_code "const")
 407        (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_DTPREL)")))
 408
 409 ;; Return true if OP is valid for 16-bit TP relative relocations.
 410 (define_predicate "tp16_symbolic_operand"
 411   (and (match_code "const")
 412        (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_TPREL)")))
 413
 414 ;; Return true if OP is valid for 32-bit TP relative relocations.
 415 (define_predicate "tp32_symbolic_operand"
 416   (and (match_code "const")
 417        (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_TPREL)")))
 418
 419 ;; Return true if OP is valid for 64-bit TP relative relocations.
 420 (define_predicate "gottp_symbolic_operand"
 421   (and (match_code "const")
 422        (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_TPREL)")))
 423
 424 ;; Return 1 if this memory address is a known aligned register plus
 425 ;; a constant.  It must be a valid address.  This means that we can do
 426 ;; this as an aligned reference plus some offset.
 427 ;;
 428 ;; Take into account what reload will do.  Oh god this is awful.
 429 ;; The horrible comma-operator construct below is to prevent genrecog
 430 ;; from thinking that this predicate accepts REG and SUBREG.  We don't
 431 ;; use recog during reload, so pretending these codes are accepted
 432 ;; pessimizes things a tad.
 433
 434 (define_predicate "aligned_memory_operand"
 435   (ior (match_test "op = resolve_reload_operand (op), 0")
 436        (match_code "mem"))
 437 {
 438   rtx base;
 439
 440   if (MEM_ALIGN (op) >= 32)
 441     return 1;
 442   op = XEXP (op, 0);
 443
 444   /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
 445      sorts of constructs.  Dig for the real base register.  */
 446   if (reload_in_progress
 447       && GET_CODE (op) == PLUS
 448       && GET_CODE (XEXP (op, 0)) == PLUS)
 449     base = XEXP (XEXP (op, 0), 0);
 450   else
 451     {
 452       if (! memory_address_p (mode, op))
 453         return 0;
 454       base = (GET_CODE (op) == PLUS ? XEXP (op, 0) : op);
 455     }
 456
 457   return (GET_CODE (base) == REG && REGNO_POINTER_ALIGN (REGNO (base)) >= 32);
 458 })
 459
 460 ;; Similar, but return 1 if OP is a MEM which is not alignable.
 461
 462 (define_predicate "unaligned_memory_operand"
 463   (ior (match_test "op = resolve_reload_operand (op), 0")
 464        (match_code "mem"))
 465 {
 466   rtx base;
 467
 468   if (MEM_ALIGN (op) >= 32)
 469     return 0;
 470   op = XEXP (op, 0);
 471
 472   /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
 473      sorts of constructs.  Dig for the real base register.  */
 474   if (reload_in_progress
 475       && GET_CODE (op) == PLUS
 476       && GET_CODE (XEXP (op, 0)) == PLUS)
 477     base = XEXP (XEXP (op, 0), 0);
 478   else
 479     {
 480       if (! memory_address_p (mode, op))
 481         return 0;
 482       base = (GET_CODE (op) == PLUS ? XEXP (op, 0) : op);
 483     }
 484
 485   return (GET_CODE (base) == REG && REGNO_POINTER_ALIGN (REGNO (base)) < 32);
 486 })
 487
 488 ;; Return 1 if OP is any memory location.  During reload a pseudo matches.
 489 (define_predicate "any_memory_operand"
 490   (ior (match_code "mem,reg")
 491        (and (match_code "subreg")
 492             (match_test "GET_CODE (SUBREG_REG (op)) == REG"))))
 493
 494 ;; Return 1 if OP is either a register or an unaligned memory location.
 495 (define_predicate "reg_or_unaligned_mem_operand"
 496   (ior (match_operand 0 "register_operand")
 497        (match_operand 0 "unaligned_memory_operand")))
 498
 499 ;; Return 1 is OP is a memory location that is not a reference
 500 ;; (using an AND) to an unaligned location.  Take into account
 501 ;; what reload will do.
 502 (define_predicate "normal_memory_operand"
 503   (ior (match_test "op = resolve_reload_operand (op), 0")
 504        (and (match_code "mem")
 505             (match_test "GET_CODE (XEXP (op, 0)) != AND"))))
 506
 507 ;; Returns 1 if OP is not an eliminable register.
 508 ;;
 509 ;; This exists to cure a pathological failure in the s8addq (et al) patterns,
 510 ;;
 511 ;;      long foo () { long t; bar(); return (long) &t * 26107; }
 512 ;;
 513 ;; which run afoul of a hack in reload to cure a (presumably) similar
 514 ;; problem with lea-type instructions on other targets.  But there is
 515 ;; one of us and many of them, so work around the problem by selectively
 516 ;; preventing combine from making the optimization.
 517
 518 (define_predicate "reg_not_elim_operand"
 519   (match_operand 0 "register_operand")
 520 {
 521   if (GET_CODE (op) == SUBREG)
 522     op = SUBREG_REG (op);
 523   return op != frame_pointer_rtx && op != arg_pointer_rtx;
 524 })
 525
 526 ;; Accept a register, but not a subreg of any kind.  This allows us to
 527 ;; avoid pathological cases in reload wrt data movement common in
 528 ;; int->fp conversion.  */
 529 (define_predicate "reg_no_subreg_operand"
 530   (and (match_code "reg")
 531        (match_operand 0 "register_operand")))
 532
 533 ;; Return 1 if OP is a valid Alpha comparison operator for "cmp" style
 534 ;; instructions.
 535 (define_predicate "alpha_comparison_operator"
 536   (match_code "eq,le,lt,leu,ltu"))
 537
 538 ;; Similarly, but with swapped operands.
 539 (define_predicate "alpha_swapped_comparison_operator"
 540   (match_code "eq,ge,gt,gtu,gtu"))
 541
 542 ;; Return 1 if OP is a valid Alpha comparison operator against zero
 543 ;; for "bcc" style instructions.
 544 (define_predicate "alpha_zero_comparison_operator"
 545   (match_code "eq,ne,le,lt,leu,ltu"))
 546
 547 ;; Return 1 if OP is a signed comparison operation.
 548 (define_predicate "signed_comparison_operator"
 549   (match_code "eq,ne,le,lt,ge,gt"))
 550
 551 ;; Return 1 if OP is a valid Alpha floating point comparison operator.
 552 (define_predicate "alpha_fp_comparison_operator"
 553   (match_code "eq,le,lt,unordered"))
 554
 555 ;; Return 1 if this is a divide or modulus operator.
 556 (define_predicate "divmod_operator"
 557   (match_code "div,mod,udiv,umod"))
 558
 559 ;; Return 1 if this is a float->int conversion operator.
 560 (define_predicate "fix_operator"
 561   (match_code "fix,unsigned_fix"))
 562
 563 ;; Recognize an addition operation that includes a constant.  Used to
 564 ;; convince reload to canonize (plus (plus reg c1) c2) during register
 565 ;; elimination.
 566
 567 (define_predicate "addition_operation"
 568   (and (match_code "plus")
 569        (match_test "register_operand (XEXP (op, 0), mode)
 570                     && GET_CODE (XEXP (op, 1)) == CONST_INT
 571                     && CONST_OK_FOR_LETTER_P (INTVAL (XEXP (op, 1)), 'K')")))
 572
 573 ;; For TARGET_EXPLICIT_RELOCS, we don't obfuscate a SYMBOL_REF to a
 574 ;; small symbolic operand until after reload.  At which point we need
 575 ;; to replace (mem (symbol_ref)) with (mem (lo_sum $29 symbol_ref))
 576 ;; so that sched2 has the proper dependency information.  */
 577 (define_predicate "some_small_symbolic_operand"
 578   (match_code "set,parallel,prefetch,unspec,unspec_volatile")
 579 {
 580   /* Avoid search unless necessary.  */
 581   if (!TARGET_EXPLICIT_RELOCS || !reload_completed)
 582     return false;
 583   return for_each_rtx (&op, some_small_symbolic_operand_int, NULL);
 584 })