gcc/config/ia64/predicates.md

   1 ;; Predicate definitions for IA-64.
   2 ;; Copyright (C) 2004, 2005, 2007 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 3, 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 COPYING3.  If not see
  18 ;; <http://www.gnu.org/licenses/>.
  19
  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")))
  24
  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"))
  30
  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)")))
  35
  36 ;; True if OP refers to a symbol in the sdata section.
  37 (define_predicate "sdata_symbolic_operand"
  38   (match_code "symbol_ref,const")
  39 {
  40   HOST_WIDE_INT offset = 0, size = 0;
  41
  42   switch (GET_CODE (op))
  43     {
  44     case CONST:
  45       op = XEXP (op, 0);
  46       if (GET_CODE (op) != PLUS
  47           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
  48           || GET_CODE (XEXP (op, 1)) != CONST_INT)
  49         return false;
  50       offset = INTVAL (XEXP (op, 1));
  51       op = XEXP (op, 0);
  52       /* FALLTHRU */
  53
  54     case SYMBOL_REF:
  55       if (CONSTANT_POOL_ADDRESS_P (op))
  56         {
  57           size = GET_MODE_SIZE (get_pool_mode (op));
  58           if (size > ia64_section_threshold)
  59             return false;
  60         }
  61       else
  62         {
  63           tree t;
  64
  65           if (!SYMBOL_REF_LOCAL_P (op) || !SYMBOL_REF_SMALL_P (op))
  66             return false;
  67
  68           /* Note that in addition to DECLs, we can get various forms
  69              of constants here.  */
  70           t = SYMBOL_REF_DECL (op);
  71           if (DECL_P (t))
  72             t = DECL_SIZE_UNIT (t);
  73           else
  74             t = TYPE_SIZE_UNIT (TREE_TYPE (t));
  75           if (t && host_integerp (t, 0))
  76             {
  77               size = tree_low_cst (t, 0);
  78               if (size < 0)
  79                 size = 0;
  80             }
  81         }
  82
  83       /* Deny the stupid user trick of addressing outside the object.  Such
  84          things quickly result in GPREL22 relocation overflows.  Of course,
  85          they're also highly undefined.  From a pure pedant's point of view
  86          they deserve a slap on the wrist (such as provided by a relocation
  87          overflow), but that just leads to bugzilla noise.  */
  88       return (offset >= 0 && offset <= size);
  89
  90     default:
  91       gcc_unreachable ();
  92     }
  93 })
  94
  95 ;; True if OP refers to a symbol in the small address area.
  96 (define_predicate "small_addr_symbolic_operand"
  97   (match_code "symbol_ref,const")
  98 {
  99   switch (GET_CODE (op))
 100     {
 101     case CONST:
 102       op = XEXP (op, 0);
 103       if (GET_CODE (op) != PLUS
 104           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
 105           || GET_CODE (XEXP (op, 1)) != CONST_INT)
 106         return false;
 107       op = XEXP (op, 0);
 108       /* FALLTHRU */
 109
 110     case SYMBOL_REF:
 111       return SYMBOL_REF_SMALL_ADDR_P (op);
 112
 113     default:
 114       gcc_unreachable ();
 115     }
 116 })
 117
 118 ;; True if OP refers to a symbol with which we may use any offset.
 119 (define_predicate "any_offset_symbol_operand"
 120   (match_code "symbol_ref")
 121 {
 122   if (TARGET_NO_PIC || TARGET_AUTO_PIC)
 123     return true;
 124   if (SYMBOL_REF_SMALL_ADDR_P (op))
 125     return true;
 126   if (SYMBOL_REF_FUNCTION_P (op))
 127     return false;
 128   if (sdata_symbolic_operand (op, mode))
 129     return true;
 130   return false;
 131 })
 132
 133 ;; True if OP refers to a symbol with which we may use 14-bit aligned offsets.
 134 ;; False if OP refers to a symbol with which we may not use any offset at any
 135 ;; time.
 136 (define_predicate "aligned_offset_symbol_operand"
 137   (and (match_code "symbol_ref")
 138        (match_test "! SYMBOL_REF_FUNCTION_P (op)")))
 139
 140 ;; True if OP refers to a symbol, and is appropriate for a GOT load.
 141 (define_predicate "got_symbolic_operand"
 142   (match_operand 0 "symbolic_operand" "")
 143 {
 144   HOST_WIDE_INT addend = 0;
 145
 146   switch (GET_CODE (op))
 147     {
 148     case LABEL_REF:
 149       return true;
 150
 151     case CONST:
 152       /* Accept only (plus (symbol_ref) (const_int)).  */
 153       op = XEXP (op, 0);
 154       if (GET_CODE (op) != PLUS
 155           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
 156           || GET_CODE (XEXP (op, 1)) != CONST_INT)
 157         return false;
 158
 159       addend = INTVAL (XEXP (op, 1));
 160       op = XEXP (op, 0);
 161       /* FALLTHRU */
 162
 163     case SYMBOL_REF:
 164       /* These symbols shouldn't be used with got loads.  */
 165       if (SYMBOL_REF_SMALL_ADDR_P (op))
 166         return false;
 167       if (SYMBOL_REF_TLS_MODEL (op) != 0)
 168         return false;
 169
 170       if (any_offset_symbol_operand (op, mode))
 171         return true;
 172
 173       /* The low 14 bits of the constant have been forced to zero
 174          so that we do not use up so many GOT entries.  Prevent cse
 175          from undoing this.  */
 176       if (aligned_offset_symbol_operand (op, mode))
 177         return (addend & 0x3fff) == 0;
 178
 179       return addend == 0;
 180
 181     default:
 182       gcc_unreachable ();
 183     }
 184 })
 185
 186 ;; Return true if OP is a valid thread local storage symbolic operand.
 187 (define_predicate "tls_symbolic_operand"
 188   (match_code "symbol_ref,const")
 189 {
 190   switch (GET_CODE (op))
 191     {
 192     case SYMBOL_REF:
 193       return SYMBOL_REF_TLS_MODEL (op) != 0;
 194
 195     case CONST:
 196       op = XEXP (op, 0);
 197       if (GET_CODE (op) != PLUS
 198           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
 199           || GET_CODE (XEXP (op, 1)) != CONST_INT)
 200         return false;
 201
 202       /* We only allow certain offsets for certain tls models.  */
 203       switch (SYMBOL_REF_TLS_MODEL (XEXP (op, 0)))
 204         {
 205         case TLS_MODEL_GLOBAL_DYNAMIC:
 206         case TLS_MODEL_LOCAL_DYNAMIC:
 207           return false;
 208
 209         case TLS_MODEL_INITIAL_EXEC:
 210           return (INTVAL (XEXP (op, 1)) & 0x3fff) == 0;
 211
 212         case TLS_MODEL_LOCAL_EXEC:
 213           return true;
 214
 215         default:
 216           return false;
 217         }
 218
 219     default:
 220       gcc_unreachable ();
 221     }
 222 })
 223
 224 ;; Return true if OP is a local-dynamic thread local storage symbolic operand.
 225 (define_predicate "ld_tls_symbolic_operand"
 226   (and (match_code "symbol_ref")
 227        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_DYNAMIC")))
 228
 229 ;; Return true if OP is an initial-exec thread local storage symbolic operand.
 230 (define_predicate "ie_tls_symbolic_operand"
 231   (match_code "symbol_ref,const")
 232 {
 233   switch (GET_CODE (op))
 234     {
 235     case CONST:
 236       op = XEXP (op, 0);
 237       if (GET_CODE (op) != PLUS
 238           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
 239           || GET_CODE (XEXP (op, 1)) != CONST_INT
 240           || (INTVAL (XEXP (op, 1)) & 0x3fff) != 0)
 241         return false;
 242       op = XEXP (op, 0);
 243       /* FALLTHRU */
 244
 245     case SYMBOL_REF:
 246       return SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_INITIAL_EXEC;
 247
 248     default:
 249       gcc_unreachable ();
 250     }
 251 })
 252
 253 ;; Return true if OP is a local-exec thread local storage symbolic operand.
 254 (define_predicate "le_tls_symbolic_operand"
 255   (match_code "symbol_ref,const")
 256 {
 257   switch (GET_CODE (op))
 258     {
 259     case CONST:
 260       op = XEXP (op, 0);
 261       if (GET_CODE (op) != PLUS
 262           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
 263           || GET_CODE (XEXP (op, 1)) != CONST_INT)
 264         return false;
 265       op = XEXP (op, 0);
 266       /* FALLTHRU */
 267
 268     case SYMBOL_REF:
 269       return SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_EXEC;
 270
 271     default:
 272       gcc_unreachable ();
 273     }
 274 })
 275
 276 ;; Like nonimmediate_operand, but don't allow MEMs that try to use a
 277 ;; POST_MODIFY with a REG as displacement.
 278 (define_predicate "destination_operand"
 279   (and (match_operand 0 "nonimmediate_operand")
 280        (match_test "GET_CODE (op) != MEM
 281                     || GET_CODE (XEXP (op, 0)) != POST_MODIFY
 282                     || GET_CODE (XEXP (XEXP (XEXP (op, 0), 1), 1)) != REG")))
 283
 284 ;; Like destination_operand, but don't allow any post-increments.
 285 (define_predicate "not_postinc_destination_operand"
 286   (and (match_operand 0 "nonimmediate_operand")
 287        (match_test "GET_CODE (op) != MEM
 288         || GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC")))
 289
 290 ;; Like memory_operand, but don't allow post-increments.
 291 (define_predicate "not_postinc_memory_operand"
 292   (and (match_operand 0 "memory_operand")
 293        (match_test "GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC")))
 294
 295 ;; True if OP is a general operand, with some restrictions on symbols.
 296 (define_predicate "move_operand"
 297   (match_operand 0 "general_operand")
 298 {
 299   switch (GET_CODE (op))
 300     {
 301     case CONST:
 302       {
 303         HOST_WIDE_INT addend;
 304
 305         /* Accept only (plus (symbol_ref) (const_int)).  */
 306         op = XEXP (op, 0);
 307         if (GET_CODE (op) != PLUS
 308             || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
 309             || GET_CODE (XEXP (op, 1)) != CONST_INT)
 310           return false;
 311
 312         addend = INTVAL (XEXP (op, 1));
 313         op = XEXP (op, 0);
 314
 315         /* After reload, we want to allow any offset whatsoever.  This
 316            allows reload the opportunity to avoid spilling addresses to
 317            the stack, and instead simply substitute in the value from a
 318            REG_EQUIV.  We'll split this up again when splitting the insn.  */
 319         if (reload_in_progress || reload_completed)
 320           return true;
 321
 322         /* Some symbol types we allow to use with any offset.  */
 323         if (any_offset_symbol_operand (op, mode))
 324           return true;
 325
 326         /* Some symbol types we allow offsets with the low 14 bits of the
 327            constant forced to zero so that we do not use up so many GOT
 328            entries.  We want to prevent cse from undoing this.  */
 329         if (aligned_offset_symbol_operand (op, mode))
 330           return (addend & 0x3fff) == 0;
 331
 332         /* The remaining symbol types may never be used with an offset.  */
 333         return false;
 334       }
 335
 336     default:
 337       return true;
 338     }
 339 })
 340
 341 ;; Like move_operand but don't allow post-increments.
 342 (define_predicate "not_postinc_move_operand"
 343   (and (match_operand 0 "move_operand")
 344        (match_test "GET_CODE (op) != MEM
 345         || GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC")))
 346
 347 ;; True if OP is a register operand that is (or could be) a GR reg.
 348 (define_predicate "gr_register_operand"
 349   (match_operand 0 "register_operand")
 350 {
 351   unsigned int regno;
 352   if (GET_CODE (op) == SUBREG)
 353     op = SUBREG_REG (op);
 354
 355   regno = REGNO (op);
 356   return (regno >= FIRST_PSEUDO_REGISTER || GENERAL_REGNO_P (regno));
 357 })
 358
 359 ;; True if OP is a register operand that is (or could be) an FR reg.
 360 (define_predicate "fr_register_operand"
 361   (match_operand 0 "register_operand")
 362 {
 363   unsigned int regno;
 364   if (GET_CODE (op) == SUBREG)
 365     op = SUBREG_REG (op);
 366
 367   regno = REGNO (op);
 368   return (regno >= FIRST_PSEUDO_REGISTER || FR_REGNO_P (regno));
 369 })
 370
 371 ;; True if OP is a register operand that is (or could be) a GR/FR reg.
 372 (define_predicate "grfr_register_operand"
 373   (match_operand 0 "register_operand")
 374 {
 375   unsigned int regno;
 376   if (GET_CODE (op) == SUBREG)
 377     op = SUBREG_REG (op);
 378
 379   regno = REGNO (op);
 380   return (regno >= FIRST_PSEUDO_REGISTER
 381           || GENERAL_REGNO_P (regno)
 382           || FR_REGNO_P (regno));
 383 })
 384
 385 ;; True if OP is a nonimmediate operand that is (or could be) a GR reg.
 386 (define_predicate "gr_nonimmediate_operand"
 387   (match_operand 0 "nonimmediate_operand")
 388 {
 389   unsigned int regno;
 390
 391   if (GET_CODE (op) == MEM)
 392     return true;
 393   if (GET_CODE (op) == SUBREG)
 394     op = SUBREG_REG (op);
 395
 396   regno = REGNO (op);
 397   return (regno >= FIRST_PSEUDO_REGISTER || GENERAL_REGNO_P (regno));
 398 })
 399
 400 ;; True if OP is a nonimmediate operand that is (or could be) a FR reg.
 401 (define_predicate "fr_nonimmediate_operand"
 402   (match_operand 0 "nonimmediate_operand")
 403 {
 404   unsigned int regno;
 405
 406   if (GET_CODE (op) == MEM)
 407     return true;
 408   if (GET_CODE (op) == SUBREG)
 409     op = SUBREG_REG (op);
 410
 411   regno = REGNO (op);
 412   return (regno >= FIRST_PSEUDO_REGISTER || FR_REGNO_P (regno));
 413 })
 414
 415 ;; True if OP is a nonimmediate operand that is (or could be) a GR/FR reg.
 416 (define_predicate "grfr_nonimmediate_operand"
 417   (match_operand 0 "nonimmediate_operand")
 418 {
 419   unsigned int regno;
 420
 421   if (GET_CODE (op) == MEM)
 422     return true;
 423   if (GET_CODE (op) == SUBREG)
 424     op = SUBREG_REG (op);
 425
 426   regno = REGNO (op);
 427   return (regno >= FIRST_PSEUDO_REGISTER
 428           || GENERAL_REGNO_P (regno)
 429           || FR_REGNO_P (regno));
 430 })
 431
 432 ;; True if OP is a GR register operand, or zero.
 433 (define_predicate "gr_reg_or_0_operand"
 434   (ior (match_operand 0 "gr_register_operand")
 435        (and (match_code "const_int,const_double,const_vector")
 436             (match_test "op == CONST0_RTX (GET_MODE (op))"))))
 437
 438 ;; True if OP is a GR register operand, or a 5-bit immediate operand.
 439 (define_predicate "gr_reg_or_5bit_operand"
 440   (ior (match_operand 0 "gr_register_operand")
 441        (and (match_code "const_int")
 442             (match_test "INTVAL (op) >= 0 && INTVAL (op) < 32"))))
 443
 444 ;; True if OP is a GR register operand, or a 6-bit immediate operand.
 445 (define_predicate "gr_reg_or_6bit_operand"
 446   (ior (match_operand 0 "gr_register_operand")
 447        (and (match_code "const_int")
 448             (match_test "satisfies_constraint_M (op)"))))
 449
 450 ;; True if OP is a GR register operand, or an 8-bit immediate operand.
 451 (define_predicate "gr_reg_or_8bit_operand"
 452   (ior (match_operand 0 "gr_register_operand")
 453        (and (match_code "const_int")
 454             (match_test "satisfies_constraint_K (op)"))))
 455
 456 ;; True if OP is a GR/FR register operand, or an 8-bit immediate operand.
 457 (define_predicate "grfr_reg_or_8bit_operand"
 458   (ior (match_operand 0 "grfr_register_operand")
 459        (and (match_code "const_int")
 460             (match_test "satisfies_constraint_K (op)"))))
 461
 462 ;; True if OP is a register operand, or an 8-bit adjusted immediate operand.
 463 (define_predicate "gr_reg_or_8bit_adjusted_operand"
 464   (ior (match_operand 0 "gr_register_operand")
 465        (and (match_code "const_int")
 466             (match_test "satisfies_constraint_L (op)"))))
 467
 468 ;; True if OP is a register operand, or is valid for both an 8-bit
 469 ;; immediate and an 8-bit adjusted immediate operand.  This is necessary
 470 ;; because when we emit a compare, we don't know what the condition will be,
 471 ;; so we need the union of the immediates accepted by GT and LT.
 472 (define_predicate "gr_reg_or_8bit_and_adjusted_operand"
 473   (ior (match_operand 0 "gr_register_operand")
 474        (and (match_code "const_int")
 475             (match_test "satisfies_constraint_K (op)
 476                          && satisfies_constraint_L (op)"))))
 477
 478 ;; True if OP is a register operand, or a 14-bit immediate operand.
 479 (define_predicate "gr_reg_or_14bit_operand"
 480   (ior (match_operand 0 "gr_register_operand")
 481        (and (match_code "const_int")
 482             (match_test "satisfies_constraint_I (op)"))))
 483
 484 ;;  True if OP is a register operand, or a 22-bit immediate operand.
 485 (define_predicate "gr_reg_or_22bit_operand"
 486   (ior (match_operand 0 "gr_register_operand")
 487        (and (match_code "const_int")
 488             (match_test "satisfies_constraint_J (op)"))))
 489
 490 ;; True if OP is a 7-bit immediate operand.
 491 (define_predicate "dshift_count_operand"
 492   (and (match_code "const_int")
 493        (match_test "INTVAL (op) >= 0 && INTVAL (op) < 128")))
 494
 495 ;; True if OP is a 6-bit immediate operand.
 496 (define_predicate "shift_count_operand"
 497   (and (match_code "const_int")
 498        (match_test "satisfies_constraint_M (op)")))
 499
 500 ;; True if OP-1 is a 6-bit immediate operand, used in extr instruction.
 501 (define_predicate "extr_len_operand"
 502   (and (match_code "const_int")
 503        (match_test "satisfies_constraint_M (GEN_INT (INTVAL (op) - 1))")))
 504
 505 ;; True if OP is a 5-bit immediate operand.
 506 (define_predicate "shift_32bit_count_operand"
 507    (and (match_code "const_int")
 508         (match_test "INTVAL (op) >= 0 && INTVAL (op) < 32")))
 509
 510 ;; True if OP is one of the immediate values 2, 4, 8, or 16.
 511 (define_predicate "shladd_operand"
 512   (and (match_code "const_int")
 513        (match_test "INTVAL (op) == 2 || INTVAL (op) == 4 ||
 514                     INTVAL (op) == 8 || INTVAL (op) == 16")))
 515
 516 ;; True if OP is one of the immediate values 1, 2, 3, or 4.
 517 (define_predicate "shladd_log2_operand"
 518   (and (match_code "const_int")
 519        (match_test "INTVAL (op) >= 1 && INTVAL (op) <= 4")))
 520
 521 ;; True if OP is one of the immediate values  -16, -8, -4, -1, 1, 4, 8, 16.
 522 (define_predicate "fetchadd_operand"
 523   (and (match_code "const_int")
 524        (match_test "INTVAL (op) == -16 || INTVAL (op) == -8 ||
 525                     INTVAL (op) == -4  || INTVAL (op) == -1 ||
 526                     INTVAL (op) == 1   || INTVAL (op) == 4  ||
 527                     INTVAL (op) == 8   || INTVAL (op) == 16")))
 528
 529 ;; True if OP is one of the immediate values 0, 7, 15, 16
 530 (define_predicate "pmpyshr_operand"
 531   (and (match_code "const_int")
 532        (match_test "INTVAL (op) == 0 || INTVAL (op) == 7
 533                     || INTVAL (op) == 15 || INTVAL (op) == 16")))
 534
 535 ;; True if OP is 0..3.
 536 (define_predicate "const_int_2bit_operand"
 537   (and (match_code "const_int")
 538         (match_test "INTVAL (op) >= 0 && INTVAL (op) <= 3")))
 539
 540 ;; True if OP is a floating-point constant zero, one, or a register.
 541 (define_predicate "fr_reg_or_fp01_operand"
 542   (ior (match_operand 0 "fr_register_operand")
 543        (and (match_code "const_double")
 544             (match_test "satisfies_constraint_G (op)"))))
 545
 546 ;; Like fr_reg_or_fp01_operand, but don't allow any SUBREGs.
 547 (define_predicate "xfreg_or_fp01_operand"
 548   (and (match_operand 0 "fr_reg_or_fp01_operand")
 549        (not (match_code "subreg"))))
 550
 551 ;; Like fr_reg_or_fp01_operand, but don't allow 0 if flag_signed_zero is set.
 552 ;; Using f0 as the second arg to fadd or fsub, or as the third arg to fma or
 553 ;; fms can cause a zero result to have the wrong sign.
 554 (define_predicate "fr_reg_or_signed_fp01_operand"
 555   (ior (match_operand 0 "fr_register_operand")
 556        (and (match_code "const_double")
 557             (match_test "satisfies_constraint_Z (op)"))))
 558
 559 ;; Like fr_reg_or_signed_fp01_operand, but don't allow any SUBREGs.
 560 (define_predicate "xfreg_or_signed_fp01_operand"
 561   (and (match_operand 0 "fr_reg_or_signed_fp01_operand")
 562        (not (match_code "subreg"))))
 563
 564 ;; True if OP is a constant zero, or a register.
 565 (define_predicate "fr_reg_or_0_operand"
 566   (ior (match_operand 0 "fr_register_operand")
 567        (and (match_code "const_double,const_vector")
 568             (match_test "op == CONST0_RTX (GET_MODE (op))"))))
 569
 570 ;; Return 1 if OP is a valid comparison operator for "cbranch" instructions.
 571 (define_predicate "ia64_cbranch_operator"
 572   (ior (match_operand 0 "ordered_comparison_operator")
 573        (match_code "ordered,unordered")))
 574
 575 ;; True if this is a comparison operator, which accepts a normal 8-bit
 576 ;; signed immediate operand.
 577 (define_predicate "normal_comparison_operator"
 578   (match_code "eq,ne,gt,le,gtu,leu"))
 579
 580 ;; True if this is a comparison operator, which accepts an adjusted 8-bit
 581 ;; signed immediate operand.
 582 (define_predicate "adjusted_comparison_operator"
 583   (match_code "lt,ge,ltu,geu"))
 584
 585 ;; True if this is a signed inequality operator.
 586 (define_predicate "signed_inequality_operator"
 587   (match_code "ge,gt,le,lt"))
 588
 589 ;; True if this operator is valid for predication.
 590 (define_predicate "predicate_operator"
 591   (match_code "eq,ne"))
 592
 593 ;; True if this operator can be used in a conditional operation.
 594 (define_predicate "condop_operator"
 595   (match_code "plus,minus,ior,xor,and"))
 596
 597 ;; These three are hardware registers that can only be addressed in
 598 ;; DImode.  It's not strictly necessary to test mode == DImode here,
 599 ;; but it makes decent insurance against someone writing a
 600 ;; match_operand wrong.
 601
 602 ;; True if this is the ar.lc register.
 603 (define_predicate "ar_lc_reg_operand"
 604   (and (match_code "reg")
 605        (match_test "mode == DImode && REGNO (op) == AR_LC_REGNUM")))
 606
 607 ;; True if this is the ar.ccv register.
 608 (define_predicate "ar_ccv_reg_operand"
 609   (and (match_code "reg")
 610        (match_test "mode == DImode && REGNO (op) == AR_CCV_REGNUM")))
 611
 612 ;; True if this is the ar.pfs register.
 613 (define_predicate "ar_pfs_reg_operand"
 614   (and (match_code "reg")
 615        (match_test "mode == DImode && REGNO (op) == AR_PFS_REGNUM")))
 616
 617 ;; True if OP is valid as a base register in a reg + offset address.
 618 ;; ??? Should I copy the flag_omit_frame_pointer and cse_not_expected
 619 ;; checks from pa.c basereg_operand as well?  Seems to be OK without them
 620 ;; in test runs.
 621 (define_predicate "basereg_operand"
 622   (match_operand 0 "register_operand")
 623 {
 624   return REG_P (op) && REG_POINTER (op);
 625 })
 626