gcc/config/alpha/predicates.md

   1 ;; Predicate definitions for DEC Alpha.
   2 ;; Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012
   3 ;; Free Software Foundation, Inc.
   4 ;;
   5 ;; This file is part of GCC.
   6 ;;
   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)
  10 ;; any later version.
  11 ;;
  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.
  16 ;;
  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/>.
  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 "satisfies_constraint_K (op) || satisfies_constraint_L (op)")
  58     (match_operand 0 "register_operand")))
  59
  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")))
  66
  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"))))
  72
  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)")))
  77
  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")))
  82
  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"))))
  94
  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")))
 101
 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")
 106 {
 107   HOST_WIDE_INT i = INTVAL (op);
 108   return i == 8 || i == 16 || i == 32 || i == 64;
 109 })
 110
 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")
 115 {
 116   if (CONST_INT_P (op))
 117     {
 118       HOST_WIDE_INT value = INTVAL (op);
 119
 120       if (value == 0xff)
 121         return 1;
 122       if (value == 0xffff)
 123         return 1;
 124       if (value == 0xffffffff)
 125         return 1;
 126       if (value == -1)
 127         return 1;
 128     }
 129   else if (HOST_BITS_PER_WIDE_INT == 32 && GET_CODE (op) == CONST_DOUBLE)
 130     {
 131       if (CONST_DOUBLE_LOW (op) == 0xffffffff && CONST_DOUBLE_HIGH (op) == 0)
 132         return 1;
 133     }
 134   return 0;
 135 })
 136
 137 ;; Return 1 if OP is a multiple of 8 less than 64.
 138 (define_predicate "mul8_operand"
 139   (match_code "const_int")
 140 {
 141   unsigned HOST_WIDE_INT i = INTVAL (op);
 142   return i < 64 && i % 8 == 0;
 143 })
 144
 145 ;; Return 1 if OP is a hard floating-point register.
 146 (define_predicate "hard_fp_register_operand"
 147   (match_operand 0 "register_operand")
 148 {
 149   if (GET_CODE (op) == SUBREG)
 150     op = SUBREG_REG (op);
 151   return REGNO_REG_CLASS (REGNO (op)) == FLOAT_REGS;
 152 })
 153
 154 ;; Return 1 if OP is a hard general register.
 155 (define_predicate "hard_int_register_operand"
 156   (match_operand 0 "register_operand")
 157 {
 158   if (GET_CODE (op) == SUBREG)
 159     op = SUBREG_REG (op);
 160   return REGNO_REG_CLASS (REGNO (op)) == GENERAL_REGS;
 161 })
 162
 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)"))))
 170
 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)"))))
 176
 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")
 181 {
 182   switch (GET_CODE (op))
 183     {
 184     case LABEL_REF:
 185     case SYMBOL_REF:
 186     case CONST:
 187       if (TARGET_EXPLICIT_RELOCS)
 188         {
 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
 192              form.  */
 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));
 197         }
 198       /* VMS still has a 32-bit mode.  */
 199       return mode == ptr_mode || mode == Pmode;
 200
 201     case HIGH:
 202       return (TARGET_EXPLICIT_RELOCS
 203               && local_symbolic_operand (XEXP (op, 0), mode));
 204
 205     case REG:
 206       return 1;
 207
 208     case SUBREG:
 209       if (register_operand (op, mode))
 210         return 1;
 211       /* ... fall through ...  */
 212     case MEM:
 213       return ((TARGET_BWX || (mode != HImode && mode != QImode))
 214               && general_operand (op, mode));
 215
 216     case CONST_DOUBLE:
 217       return op == CONST0_RTX (mode);
 218
 219     case CONST_VECTOR:
 220       if (reload_in_progress || reload_completed)
 221         return alpha_legitimate_constant_p (mode, op);
 222       return op == CONST0_RTX (mode);
 223
 224     case CONST_INT:
 225       if (mode == QImode || mode == HImode)
 226         return true;
 227       if (reload_in_progress || reload_completed)
 228         return alpha_legitimate_constant_p (mode, op);
 229       return add_operand (op, mode);
 230
 231     default:
 232       gcc_unreachable ();
 233     }
 234   return 0;
 235 })
 236
 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.
 239
 240 (define_predicate "samegp_function_operand"
 241   (match_code "symbol_ref")
 242 {
 243   /* Easy test for recursion.  */
 244   if (op == XEXP (DECL_RTL (current_function_decl), 0))
 245     return true;
 246
 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))
 250     return false;
 251
 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)
 257     return true;
 258
 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);
 262 })
 263
 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")
 267 {
 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)
 276     return false;
 277
 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))
 283     return false;
 284
 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)
 289     return true;
 290
 291   return false;
 292 })
 293
 294 ;; Return 1 if OP is a valid operand for the MEM of a CALL insn.
 295 ;;
 296 ;; For TARGET_ABI_OSF, we want to restrict to R27 or a pseudo.
 297
 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")))))
 304
 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")
 309 {
 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);
 314
 315   if (GET_CODE (op) == LABEL_REF)
 316     return 1;
 317
 318   if (GET_CODE (op) != SYMBOL_REF)
 319     return 0;
 320
 321   return (SYMBOL_REF_LOCAL_P (op)
 322           && !SYMBOL_REF_WEAK (op)
 323           && !SYMBOL_REF_TLS_MODEL (op));
 324 })
 325
 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")
 330 {
 331   HOST_WIDE_INT ofs = 0, max_ofs = 0;
 332
 333   if (! TARGET_SMALL_DATA)
 334     return false;
 335
 336   if (GET_CODE (op) == CONST
 337       && GET_CODE (XEXP (op, 0)) == PLUS
 338       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
 339     {
 340       ofs = INTVAL (XEXP (XEXP (op, 0), 1));
 341       op = XEXP (XEXP (op, 0), 0);
 342     }
 343
 344   if (GET_CODE (op) != SYMBOL_REF)
 345     return false;
 346
 347   /* ??? There's no encode_section_info equivalent for the rtl
 348      constant pool, so SYMBOL_FLAG_SMALL never gets set.  */
 349   if (CONSTANT_POOL_ADDRESS_P (op))
 350     {
 351       max_ofs = GET_MODE_SIZE (get_pool_mode (op));
 352       if (max_ofs > g_switch_value)
 353         return false;
 354     }
 355   else if (SYMBOL_REF_LOCAL_P (op)
 356             && SYMBOL_REF_SMALL_P (op)
 357             && !SYMBOL_REF_WEAK (op)
 358             && !SYMBOL_REF_TLS_MODEL (op))
 359     {
 360       if (SYMBOL_REF_DECL (op))
 361         max_ofs = tree_low_cst (DECL_SIZE_UNIT (SYMBOL_REF_DECL (op)), 1);
 362     }
 363   else
 364     return false;
 365
 366   /* Given that we know that the GP is always 8 byte aligned, we can
 367      always adjust by 7 without overflowing.  */
 368   if (max_ofs < 8)
 369     max_ofs = 8;
 370
 371   /* Since we know this is an object in a small data section, we know the
 372      entire section is addressable via GP.  We don't know where the section
 373      boundaries are, but we know the entire object is within.  */
 374   return IN_RANGE (ofs, 0, max_ofs - 1);
 375 })
 376
 377 ;; Return true if OP is a SYMBOL_REF or CONST referencing a variable
 378 ;; not known (or known not) to be defined in this file.
 379 (define_predicate "global_symbolic_operand"
 380   (match_code "const,symbol_ref")
 381 {
 382   if (GET_CODE (op) == CONST
 383       && GET_CODE (XEXP (op, 0)) == PLUS
 384       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
 385     op = XEXP (XEXP (op, 0), 0);
 386
 387   if (GET_CODE (op) != SYMBOL_REF)
 388     return 0;
 389
 390   return ((!SYMBOL_REF_LOCAL_P (op) || SYMBOL_REF_WEAK (op))
 391           && !SYMBOL_REF_TLS_MODEL (op));
 392 })
 393
 394 ;; Returns 1 if OP is a symbolic operand, i.e. a symbol_ref or a label_ref,
 395 ;; possibly with an offset.
 396 (define_predicate "symbolic_operand"
 397   (ior (match_code "symbol_ref,label_ref")
 398        (and (match_code "const")
 399             (match_test "GET_CODE (XEXP (op,0)) == PLUS
 400                          && (GET_CODE (XEXP (XEXP (op,0), 0)) == SYMBOL_REF
 401                              || GET_CODE (XEXP (XEXP (op,0), 0)) == LABEL_REF)
 402                          && CONST_INT_P (XEXP (XEXP (op,0), 1))"))))
 403
 404 ;; Return true if OP is valid for 16-bit DTP relative relocations.
 405 (define_predicate "dtp16_symbolic_operand"
 406   (and (match_code "const")
 407        (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_DTPREL)")))
 408
 409 ;; Return true if OP is valid for 32-bit DTP relative relocations.
 410 (define_predicate "dtp32_symbolic_operand"
 411   (and (match_code "const")
 412        (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_DTPREL)")))
 413
 414 ;; Return true if OP is valid for 64-bit DTP relative relocations.
 415 (define_predicate "gotdtp_symbolic_operand"
 416   (and (match_code "const")
 417        (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_DTPREL)")))
 418
 419 ;; Return true if OP is valid for 16-bit TP relative relocations.
 420 (define_predicate "tp16_symbolic_operand"
 421   (and (match_code "const")
 422        (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_TPREL)")))
 423
 424 ;; Return true if OP is valid for 32-bit TP relative relocations.
 425 (define_predicate "tp32_symbolic_operand"
 426   (and (match_code "const")
 427        (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_TPREL)")))
 428
 429 ;; Return true if OP is valid for 64-bit TP relative relocations.
 430 (define_predicate "gottp_symbolic_operand"
 431   (and (match_code "const")
 432        (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_TPREL)")))
 433
 434 ;; Return 1 if this memory address is a known aligned register plus
 435 ;; a constant.  It must be a valid address.  This means that we can do
 436 ;; this as an aligned reference plus some offset.
 437 ;;
 438 ;; Take into account what reload will do.  Oh god this is awful.
 439 ;; The horrible comma-operator construct below is to prevent genrecog
 440 ;; from thinking that this predicate accepts REG and SUBREG.  We don't
 441 ;; use recog during reload, so pretending these codes are accepted
 442 ;; pessimizes things a tad.
 443
 444 (define_special_predicate "aligned_memory_operand"
 445   (ior (match_test "op = resolve_reload_operand (op), 0")
 446        (match_code "mem"))
 447 {
 448   rtx base;
 449   int offset;
 450
 451   if (MEM_ALIGN (op) >= 32)
 452     return 1;
 453
 454   op = XEXP (op, 0);
 455
 456   /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
 457      sorts of constructs.  Dig for the real base register.  */
 458   if (reload_in_progress
 459       && GET_CODE (op) == PLUS
 460       && GET_CODE (XEXP (op, 0)) == PLUS)
 461     {
 462       base = XEXP (XEXP (op, 0), 0);
 463       offset = INTVAL (XEXP (op, 1));
 464     }
 465   else
 466     {
 467       if (! memory_address_p (mode, op))
 468         return 0;
 469       if (GET_CODE (op) == PLUS)
 470         {
 471           base = XEXP (op, 0);
 472           offset = INTVAL (XEXP (op, 1));
 473         }
 474       else
 475         {
 476           base = op;
 477           offset = 0;
 478         }
 479     }
 480
 481   if (offset % GET_MODE_SIZE (mode))
 482     return 0;
 483
 484   return (REG_P (base) && REGNO_POINTER_ALIGN (REGNO (base)) >= 32);
 485 })
 486
 487 ;; Similar, but return 1 if OP is a MEM which is not alignable.
 488
 489 (define_special_predicate "unaligned_memory_operand"
 490   (ior (match_test "op = resolve_reload_operand (op), 0")
 491        (match_code "mem"))
 492 {
 493   rtx base;
 494   int offset;
 495
 496   if (MEM_ALIGN (op) >= 32)
 497     return 0;
 498
 499   op = XEXP (op, 0);
 500
 501   /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
 502      sorts of constructs.  Dig for the real base register.  */
 503   if (reload_in_progress
 504       && GET_CODE (op) == PLUS
 505       && GET_CODE (XEXP (op, 0)) == PLUS)
 506     {
 507       base = XEXP (XEXP (op, 0), 0);
 508       offset = INTVAL (XEXP (op, 1));
 509     }
 510   else
 511     {
 512       if (! memory_address_p (mode, op))
 513         return 0;
 514       if (GET_CODE (op) == PLUS)
 515         {
 516           base = XEXP (op, 0);
 517           offset = INTVAL (XEXP (op, 1));
 518         }
 519       else
 520         {
 521           base = op;
 522           offset = 0;
 523         }
 524     }
 525
 526   if (offset % GET_MODE_SIZE (mode))
 527     return 1;
 528
 529   return (REG_P (base) && REGNO_POINTER_ALIGN (REGNO (base)) < 32);
 530 })
 531
 532 ;; Return 1 if OP is any memory location.  During reload a pseudo matches.
 533 (define_special_predicate "any_memory_operand"
 534   (match_code "mem,reg,subreg")
 535 {
 536   if (GET_CODE (op) == SUBREG)
 537     op = SUBREG_REG (op);
 538
 539   if (MEM_P (op))
 540     return true;
 541   if (reload_in_progress && REG_P (op))
 542     {
 543       unsigned regno = REGNO (op);
 544       if (HARD_REGISTER_NUM_P (regno))
 545         return false;
 546       else
 547         return reg_renumber[regno] < 0;
 548     }
 549
 550   return false;
 551 })
 552
 553 ;; Return 1 is OP is a memory location that is not a reference
 554 ;; (using an AND) to an unaligned location.  Take into account
 555 ;; what reload will do.
 556 (define_special_predicate "normal_memory_operand"
 557   (ior (match_test "op = resolve_reload_operand (op), 0")
 558        (and (match_code "mem")
 559             (match_test "GET_CODE (XEXP (op, 0)) != AND"))))
 560
 561 ;; Returns 1 if OP is not an eliminable register.
 562 ;;
 563 ;; This exists to cure a pathological failure in the s8addq (et al) patterns,
 564 ;;
 565 ;;      long foo () { long t; bar(); return (long) &t * 26107; }
 566 ;;
 567 ;; which run afoul of a hack in reload to cure a (presumably) similar
 568 ;; problem with lea-type instructions on other targets.  But there is
 569 ;; one of us and many of them, so work around the problem by selectively
 570 ;; preventing combine from making the optimization.
 571
 572 (define_predicate "reg_not_elim_operand"
 573   (match_operand 0 "register_operand")
 574 {
 575   if (GET_CODE (op) == SUBREG)
 576     op = SUBREG_REG (op);
 577   return op != frame_pointer_rtx && op != arg_pointer_rtx;
 578 })
 579
 580 ;; Accept a register, but not a subreg of any kind.  This allows us to
 581 ;; avoid pathological cases in reload wrt data movement common in
 582 ;; int->fp conversion.  */
 583 (define_predicate "reg_no_subreg_operand"
 584   (and (match_code "reg")
 585        (match_operand 0 "register_operand")))
 586
 587 ;; Return 1 if OP is a valid Alpha comparison operator for "cbranch"
 588 ;; instructions.
 589 (define_predicate "alpha_cbranch_operator"
 590   (ior (match_operand 0 "ordered_comparison_operator")
 591        (match_code "ordered,unordered")))
 592
 593 ;; Return 1 if OP is a valid Alpha comparison operator for "cmp" style
 594 ;; instructions.
 595 (define_predicate "alpha_comparison_operator"
 596   (match_code "eq,le,lt,leu,ltu"))
 597
 598 ;; Similarly, but with swapped operands.
 599 (define_predicate "alpha_swapped_comparison_operator"
 600   (match_code "eq,ge,gt,gtu"))
 601
 602 ;; Return 1 if OP is a valid Alpha comparison operator against zero
 603 ;; for "bcc" style instructions.
 604 (define_predicate "alpha_zero_comparison_operator"
 605   (match_code "eq,ne,le,lt,leu,ltu"))
 606
 607 ;; Return 1 if OP is a signed comparison operation.
 608 (define_predicate "signed_comparison_operator"
 609   (match_code "eq,ne,le,lt,ge,gt"))
 610
 611 ;; Return 1 if OP is a valid Alpha floating point comparison operator.
 612 (define_predicate "alpha_fp_comparison_operator"
 613   (match_code "eq,le,lt,unordered"))
 614
 615 ;; Return 1 if this is a divide or modulus operator.
 616 (define_predicate "divmod_operator"
 617   (match_code "div,mod,udiv,umod"))
 618
 619 ;; Return 1 if this is a float->int conversion operator.
 620 (define_predicate "fix_operator"
 621   (match_code "fix,unsigned_fix"))
 622
 623 ;; Recognize an addition operation that includes a constant.  Used to
 624 ;; convince reload to canonize (plus (plus reg c1) c2) during register
 625 ;; elimination.
 626
 627 (define_predicate "addition_operation"
 628   (and (match_code "plus")
 629        (match_test "register_operand (XEXP (op, 0), mode)
 630                     && satisfies_constraint_K (XEXP (op, 1))")))
 631
 632 ;; For TARGET_EXPLICIT_RELOCS, we don't obfuscate a SYMBOL_REF to a
 633 ;; small symbolic operand until after reload.  At which point we need
 634 ;; to replace (mem (symbol_ref)) with (mem (lo_sum $29 symbol_ref))
 635 ;; so that sched2 has the proper dependency information.  */
 636 (define_predicate "some_small_symbolic_operand"
 637   (match_code "set,parallel,prefetch,unspec,unspec_volatile")
 638 {
 639   /* Avoid search unless necessary.  */
 640   if (!TARGET_EXPLICIT_RELOCS || !reload_completed)
 641     return false;
 642   return for_each_rtx (&op, some_small_symbolic_operand_int, NULL);
 643 })
 644
 645 ;; Accept a register, or a memory if BWX is enabled.
 646 (define_predicate "reg_or_bwx_memory_operand"
 647   (ior (match_operand 0 "register_operand")
 648        (and (match_test "TARGET_BWX")
 649             (match_operand 0 "memory_operand"))))
 650
 651 ;; Accept a memory whose address is only a register.
 652 (define_predicate "mem_noofs_operand"
 653   (and (match_code "mem")
 654        (match_code "reg" "0")))