contrib/gcc-4.4/gcc/config/i386/predicates.md

   1 ;; Predicate definitions for IA-32 and x86-64.
   2 ;; Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
   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 nonzero if OP is either a i387 or SSE fp register.
  22 (define_predicate "any_fp_register_operand"
  23   (and (match_code "reg")
  24        (match_test "ANY_FP_REGNO_P (REGNO (op))")))
  25
  26 ;; Return nonzero if OP is an i387 fp register.
  27 (define_predicate "fp_register_operand"
  28   (and (match_code "reg")
  29        (match_test "FP_REGNO_P (REGNO (op))")))
  30
  31 ;; Return nonzero if OP is a non-fp register_operand.
  32 (define_predicate "register_and_not_any_fp_reg_operand"
  33   (and (match_code "reg")
  34        (not (match_test "ANY_FP_REGNO_P (REGNO (op))"))))
  35
  36 ;; Return nonzero if OP is a register operand other than an i387 fp register.
  37 (define_predicate "register_and_not_fp_reg_operand"
  38   (and (match_code "reg")
  39        (not (match_test "FP_REGNO_P (REGNO (op))"))))
  40
  41 ;; True if the operand is an MMX register.
  42 (define_predicate "mmx_reg_operand"
  43   (and (match_code "reg")
  44        (match_test "MMX_REGNO_P (REGNO (op))")))
  45
  46 ;; True if the operand is a Q_REGS class register.
  47 (define_predicate "q_regs_operand"
  48   (match_operand 0 "register_operand")
  49 {
  50   if (GET_CODE (op) == SUBREG)
  51     op = SUBREG_REG (op);
  52   return ANY_QI_REG_P (op);
  53 })
  54
  55 ;; Match an SI or HImode register for a zero_extract.
  56 (define_special_predicate "ext_register_operand"
  57   (match_operand 0 "register_operand")
  58 {
  59   if ((!TARGET_64BIT || GET_MODE (op) != DImode)
  60       && GET_MODE (op) != SImode && GET_MODE (op) != HImode)
  61     return 0;
  62   if (GET_CODE (op) == SUBREG)
  63     op = SUBREG_REG (op);
  64
  65   /* Be careful to accept only registers having upper parts.  */
  66   return REGNO (op) > LAST_VIRTUAL_REGISTER || REGNO (op) < 4;
  67 })
  68
  69 ;; Return true if op is the AX register.
  70 (define_predicate "ax_reg_operand"
  71   (and (match_code "reg")
  72        (match_test "REGNO (op) == 0")))
  73
  74 ;; Return true if op is the flags register.
  75 (define_predicate "flags_reg_operand"
  76   (and (match_code "reg")
  77        (match_test "REGNO (op) == FLAGS_REG")))
  78
  79 ;; Return true if op is not xmm0 register.
  80 (define_predicate "reg_not_xmm0_operand"
  81    (and (match_operand 0 "register_operand")
  82         (match_test "GET_CODE (op) != REG
  83                      || REGNO (op) != FIRST_SSE_REG")))
  84
  85 ;; As above, but allow nonimmediate operands.
  86 (define_predicate "nonimm_not_xmm0_operand"
  87    (and (match_operand 0 "nonimmediate_operand")
  88         (match_test "GET_CODE (op) != REG
  89                      || REGNO (op) != FIRST_SSE_REG")))
  90
  91 ;; Return 1 if VALUE can be stored in a sign extended immediate field.
  92 (define_predicate "x86_64_immediate_operand"
  93   (match_code "const_int,symbol_ref,label_ref,const")
  94 {
  95   if (!TARGET_64BIT)
  96     return immediate_operand (op, mode);
  97
  98   switch (GET_CODE (op))
  99     {
 100     case CONST_INT:
 101       /* CONST_DOUBLES never match, since HOST_BITS_PER_WIDE_INT is known
 102          to be at least 32 and this all acceptable constants are
 103          represented as CONST_INT.  */
 104       if (HOST_BITS_PER_WIDE_INT == 32)
 105         return 1;
 106       else
 107         {
 108           HOST_WIDE_INT val = trunc_int_for_mode (INTVAL (op), DImode);
 109           return trunc_int_for_mode (val, SImode) == val;
 110         }
 111       break;
 112
 113     case SYMBOL_REF:
 114       /* For certain code models, the symbolic references are known to fit.
 115          in CM_SMALL_PIC model we know it fits if it is local to the shared
 116          library.  Don't count TLS SYMBOL_REFs here, since they should fit
 117          only if inside of UNSPEC handled below.  */
 118       /* TLS symbols are not constant.  */
 119       if (SYMBOL_REF_TLS_MODEL (op))
 120         return false;
 121       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
 122               || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
 123
 124     case LABEL_REF:
 125       /* For certain code models, the code is near as well.  */
 126       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
 127               || ix86_cmodel == CM_KERNEL);
 128
 129     case CONST:
 130       /* We also may accept the offsetted memory references in certain
 131          special cases.  */
 132       if (GET_CODE (XEXP (op, 0)) == UNSPEC)
 133         switch (XINT (XEXP (op, 0), 1))
 134           {
 135           case UNSPEC_GOTPCREL:
 136           case UNSPEC_DTPOFF:
 137           case UNSPEC_GOTNTPOFF:
 138           case UNSPEC_NTPOFF:
 139             return 1;
 140           default:
 141             break;
 142           }
 143
 144       if (GET_CODE (XEXP (op, 0)) == PLUS)
 145         {
 146           rtx op1 = XEXP (XEXP (op, 0), 0);
 147           rtx op2 = XEXP (XEXP (op, 0), 1);
 148           HOST_WIDE_INT offset;
 149
 150           if (ix86_cmodel == CM_LARGE)
 151             return 0;
 152           if (!CONST_INT_P (op2))
 153             return 0;
 154           offset = trunc_int_for_mode (INTVAL (op2), DImode);
 155           switch (GET_CODE (op1))
 156             {
 157             case SYMBOL_REF:
 158               /* TLS symbols are not constant.  */
 159               if (SYMBOL_REF_TLS_MODEL (op1))
 160                 return 0;
 161               /* For CM_SMALL assume that latest object is 16MB before
 162                  end of 31bits boundary.  We may also accept pretty
 163                  large negative constants knowing that all objects are
 164                  in the positive half of address space.  */
 165               if ((ix86_cmodel == CM_SMALL
 166                    || (ix86_cmodel == CM_MEDIUM
 167                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
 168                   && offset < 16*1024*1024
 169                   && trunc_int_for_mode (offset, SImode) == offset)
 170                 return 1;
 171               /* For CM_KERNEL we know that all object resist in the
 172                  negative half of 32bits address space.  We may not
 173                  accept negative offsets, since they may be just off
 174                  and we may accept pretty large positive ones.  */
 175               if (ix86_cmodel == CM_KERNEL
 176                   && offset > 0
 177                   && trunc_int_for_mode (offset, SImode) == offset)
 178                 return 1;
 179               break;
 180
 181             case LABEL_REF:
 182               /* These conditions are similar to SYMBOL_REF ones, just the
 183                  constraints for code models differ.  */
 184               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
 185                   && offset < 16*1024*1024
 186                   && trunc_int_for_mode (offset, SImode) == offset)
 187                 return 1;
 188               if (ix86_cmodel == CM_KERNEL
 189                   && offset > 0
 190                   && trunc_int_for_mode (offset, SImode) == offset)
 191                 return 1;
 192               break;
 193
 194             case UNSPEC:
 195               switch (XINT (op1, 1))
 196                 {
 197                 case UNSPEC_DTPOFF:
 198                 case UNSPEC_NTPOFF:
 199                   if (offset > 0
 200                       && trunc_int_for_mode (offset, SImode) == offset)
 201                     return 1;
 202                 }
 203               break;
 204
 205             default:
 206               break;
 207             }
 208         }
 209       break;
 210
 211       default:
 212         gcc_unreachable ();
 213     }
 214
 215   return 0;
 216 })
 217
 218 ;; Return 1 if VALUE can be stored in the zero extended immediate field.
 219 (define_predicate "x86_64_zext_immediate_operand"
 220   (match_code "const_double,const_int,symbol_ref,label_ref,const")
 221 {
 222   switch (GET_CODE (op))
 223     {
 224     case CONST_DOUBLE:
 225       if (HOST_BITS_PER_WIDE_INT == 32)
 226         return (GET_MODE (op) == VOIDmode && !CONST_DOUBLE_HIGH (op));
 227       else
 228         return 0;
 229
 230     case CONST_INT:
 231       if (HOST_BITS_PER_WIDE_INT == 32)
 232         return INTVAL (op) >= 0;
 233       else
 234         return !(INTVAL (op) & ~(HOST_WIDE_INT) 0xffffffff);
 235
 236     case SYMBOL_REF:
 237       /* For certain code models, the symbolic references are known to fit.  */
 238       /* TLS symbols are not constant.  */
 239       if (SYMBOL_REF_TLS_MODEL (op))
 240         return false;
 241       return (ix86_cmodel == CM_SMALL
 242               || (ix86_cmodel == CM_MEDIUM
 243                   && !SYMBOL_REF_FAR_ADDR_P (op)));
 244
 245     case LABEL_REF:
 246       /* For certain code models, the code is near as well.  */
 247       return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
 248
 249     case CONST:
 250       /* We also may accept the offsetted memory references in certain
 251          special cases.  */
 252       if (GET_CODE (XEXP (op, 0)) == PLUS)
 253         {
 254           rtx op1 = XEXP (XEXP (op, 0), 0);
 255           rtx op2 = XEXP (XEXP (op, 0), 1);
 256
 257           if (ix86_cmodel == CM_LARGE)
 258             return 0;
 259           switch (GET_CODE (op1))
 260             {
 261             case SYMBOL_REF:
 262               /* TLS symbols are not constant.  */
 263               if (SYMBOL_REF_TLS_MODEL (op1))
 264                 return 0;
 265               /* For small code model we may accept pretty large positive
 266                  offsets, since one bit is available for free.  Negative
 267                  offsets are limited by the size of NULL pointer area
 268                  specified by the ABI.  */
 269               if ((ix86_cmodel == CM_SMALL
 270                    || (ix86_cmodel == CM_MEDIUM
 271                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
 272                   && CONST_INT_P (op2)
 273                   && trunc_int_for_mode (INTVAL (op2), DImode) > -0x10000
 274                   && trunc_int_for_mode (INTVAL (op2), SImode) == INTVAL (op2))
 275                 return 1;
 276               /* ??? For the kernel, we may accept adjustment of
 277                  -0x10000000, since we know that it will just convert
 278                  negative address space to positive, but perhaps this
 279                  is not worthwhile.  */
 280               break;
 281
 282             case LABEL_REF:
 283               /* These conditions are similar to SYMBOL_REF ones, just the
 284                  constraints for code models differ.  */
 285               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
 286                   && CONST_INT_P (op2)
 287                   && trunc_int_for_mode (INTVAL (op2), DImode) > -0x10000
 288                   && trunc_int_for_mode (INTVAL (op2), SImode) == INTVAL (op2))
 289                 return 1;
 290               break;
 291
 292             default:
 293               return 0;
 294             }
 295         }
 296       break;
 297
 298     default:
 299       gcc_unreachable ();
 300     }
 301   return 0;
 302 })
 303
 304 ;; Return nonzero if OP is general operand representable on x86_64.
 305 (define_predicate "x86_64_general_operand"
 306   (if_then_else (match_test "TARGET_64BIT")
 307     (ior (match_operand 0 "nonimmediate_operand")
 308          (match_operand 0 "x86_64_immediate_operand"))
 309     (match_operand 0 "general_operand")))
 310
 311 ;; Return nonzero if OP is general operand representable on x86_64
 312 ;; as either sign extended or zero extended constant.
 313 (define_predicate "x86_64_szext_general_operand"
 314   (if_then_else (match_test "TARGET_64BIT")
 315     (ior (match_operand 0 "nonimmediate_operand")
 316          (ior (match_operand 0 "x86_64_immediate_operand")
 317               (match_operand 0 "x86_64_zext_immediate_operand")))
 318     (match_operand 0 "general_operand")))
 319
 320 ;; Return nonzero if OP is nonmemory operand representable on x86_64.
 321 (define_predicate "x86_64_nonmemory_operand"
 322   (if_then_else (match_test "TARGET_64BIT")
 323     (ior (match_operand 0 "register_operand")
 324          (match_operand 0 "x86_64_immediate_operand"))
 325     (match_operand 0 "nonmemory_operand")))
 326
 327 ;; Return nonzero if OP is nonmemory operand representable on x86_64.
 328 (define_predicate "x86_64_szext_nonmemory_operand"
 329   (if_then_else (match_test "TARGET_64BIT")
 330     (ior (match_operand 0 "register_operand")
 331          (ior (match_operand 0 "x86_64_immediate_operand")
 332               (match_operand 0 "x86_64_zext_immediate_operand")))
 333     (match_operand 0 "nonmemory_operand")))
 334
 335 ;; Return true when operand is PIC expression that can be computed by lea
 336 ;; operation.
 337 (define_predicate "pic_32bit_operand"
 338   (match_code "const,symbol_ref,label_ref")
 339 {
 340   if (!flag_pic)
 341     return 0;
 342   /* Rule out relocations that translate into 64bit constants.  */
 343   if (TARGET_64BIT && GET_CODE (op) == CONST)
 344     {
 345       op = XEXP (op, 0);
 346       if (GET_CODE (op) == PLUS && CONST_INT_P (XEXP (op, 1)))
 347         op = XEXP (op, 0);
 348       if (GET_CODE (op) == UNSPEC
 349           && (XINT (op, 1) == UNSPEC_GOTOFF
 350               || XINT (op, 1) == UNSPEC_GOT))
 351         return 0;
 352     }
 353   return symbolic_operand (op, mode);
 354 })
 355
 356
 357 ;; Return nonzero if OP is nonmemory operand acceptable by movabs patterns.
 358 (define_predicate "x86_64_movabs_operand"
 359   (if_then_else (match_test "!TARGET_64BIT || !flag_pic")
 360     (match_operand 0 "nonmemory_operand")
 361     (ior (match_operand 0 "register_operand")
 362          (and (match_operand 0 "const_double_operand")
 363               (match_test "GET_MODE_SIZE (mode) <= 8")))))
 364
 365 ;; Returns nonzero if OP is either a symbol reference or a sum of a symbol
 366 ;; reference and a constant.
 367 (define_predicate "symbolic_operand"
 368   (match_code "symbol_ref,label_ref,const")
 369 {
 370   switch (GET_CODE (op))
 371     {
 372     case SYMBOL_REF:
 373     case LABEL_REF:
 374       return 1;
 375
 376     case CONST:
 377       op = XEXP (op, 0);
 378       if (GET_CODE (op) == SYMBOL_REF
 379           || GET_CODE (op) == LABEL_REF
 380           || (GET_CODE (op) == UNSPEC
 381               && (XINT (op, 1) == UNSPEC_GOT
 382                   || XINT (op, 1) == UNSPEC_GOTOFF
 383                   || XINT (op, 1) == UNSPEC_GOTPCREL)))
 384         return 1;
 385       if (GET_CODE (op) != PLUS
 386           || !CONST_INT_P (XEXP (op, 1)))
 387         return 0;
 388
 389       op = XEXP (op, 0);
 390       if (GET_CODE (op) == SYMBOL_REF
 391           || GET_CODE (op) == LABEL_REF)
 392         return 1;
 393       /* Only @GOTOFF gets offsets.  */
 394       if (GET_CODE (op) != UNSPEC
 395           || XINT (op, 1) != UNSPEC_GOTOFF)
 396         return 0;
 397
 398       op = XVECEXP (op, 0, 0);
 399       if (GET_CODE (op) == SYMBOL_REF
 400           || GET_CODE (op) == LABEL_REF)
 401         return 1;
 402       return 0;
 403
 404     default:
 405       gcc_unreachable ();
 406     }
 407 })
 408
 409 ;; Return true if the operand contains a @GOT or @GOTOFF reference.
 410 (define_predicate "pic_symbolic_operand"
 411   (match_code "const")
 412 {
 413   op = XEXP (op, 0);
 414   if (TARGET_64BIT)
 415     {
 416       if (GET_CODE (op) == UNSPEC
 417           && XINT (op, 1) == UNSPEC_GOTPCREL)
 418         return 1;
 419       if (GET_CODE (op) == PLUS
 420           && GET_CODE (XEXP (op, 0)) == UNSPEC
 421           && XINT (XEXP (op, 0), 1) == UNSPEC_GOTPCREL)
 422         return 1;
 423     }
 424   else
 425     {
 426       if (GET_CODE (op) == UNSPEC)
 427         return 1;
 428       if (GET_CODE (op) != PLUS
 429           || !CONST_INT_P (XEXP (op, 1)))
 430         return 0;
 431       op = XEXP (op, 0);
 432       if (GET_CODE (op) == UNSPEC
 433           && XINT (op, 1) != UNSPEC_MACHOPIC_OFFSET)
 434         return 1;
 435     }
 436   return 0;
 437 })
 438
 439 ;; Return true if OP is a symbolic operand that resolves locally.
 440 (define_predicate "local_symbolic_operand"
 441   (match_code "const,label_ref,symbol_ref")
 442 {
 443   if (GET_CODE (op) == CONST
 444       && GET_CODE (XEXP (op, 0)) == PLUS
 445       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
 446     op = XEXP (XEXP (op, 0), 0);
 447
 448   if (GET_CODE (op) == LABEL_REF)
 449     return 1;
 450
 451   if (GET_CODE (op) != SYMBOL_REF)
 452     return 0;
 453
 454   if (SYMBOL_REF_TLS_MODEL (op) != 0)
 455     return 0;
 456
 457   if (SYMBOL_REF_LOCAL_P (op))
 458     return 1;
 459
 460   /* There is, however, a not insubstantial body of code in the rest of
 461      the compiler that assumes it can just stick the results of
 462      ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done.  */
 463   /* ??? This is a hack.  Should update the body of the compiler to
 464      always create a DECL an invoke targetm.encode_section_info.  */
 465   if (strncmp (XSTR (op, 0), internal_label_prefix,
 466                internal_label_prefix_len) == 0)
 467     return 1;
 468
 469   return 0;
 470 })
 471
 472 ;; Test for a legitimate @GOTOFF operand.
 473 ;;
 474 ;; VxWorks does not impose a fixed gap between segments; the run-time
 475 ;; gap can be different from the object-file gap.  We therefore can't
 476 ;; use @GOTOFF unless we are absolutely sure that the symbol is in the
 477 ;; same segment as the GOT.  Unfortunately, the flexibility of linker
 478 ;; scripts means that we can't be sure of that in general, so assume
 479 ;; that @GOTOFF is never valid on VxWorks.
 480 (define_predicate "gotoff_operand"
 481   (and (match_test "!TARGET_VXWORKS_RTP")
 482        (match_operand 0 "local_symbolic_operand")))
 483
 484 ;; Test for various thread-local symbols.
 485 (define_predicate "tls_symbolic_operand"
 486   (and (match_code "symbol_ref")
 487        (match_test "SYMBOL_REF_TLS_MODEL (op) != 0")))
 488
 489 (define_predicate "tls_modbase_operand"
 490   (and (match_code "symbol_ref")
 491        (match_test "op == ix86_tls_module_base ()")))
 492
 493 (define_predicate "tp_or_register_operand"
 494   (ior (match_operand 0 "register_operand")
 495        (and (match_code "unspec")
 496             (match_test "XINT (op, 1) == UNSPEC_TP"))))
 497
 498 ;; Test for a pc-relative call operand
 499 (define_predicate "constant_call_address_operand"
 500   (match_code "symbol_ref")
 501 {
 502   if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
 503     return false;
 504   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
 505     return false;
 506   return true;
 507 })
 508
 509 ;; True for any non-virtual or eliminable register.  Used in places where
 510 ;; instantiation of such a register may cause the pattern to not be recognized.
 511 (define_predicate "register_no_elim_operand"
 512   (match_operand 0 "register_operand")
 513 {
 514   if (GET_CODE (op) == SUBREG)
 515     op = SUBREG_REG (op);
 516   return !(op == arg_pointer_rtx
 517            || op == frame_pointer_rtx
 518            || IN_RANGE (REGNO (op),
 519                         FIRST_PSEUDO_REGISTER, LAST_VIRTUAL_REGISTER));
 520 })
 521
 522 ;; P6 processors will jump to the address after the decrement when %esp
 523 ;; is used as a call operand, so they will execute return address as a code.
 524 ;; See Pentium Pro errata 70, Pentium 2 errata A33 and Pentium 3 errata E17.
 525
 526 (define_predicate "call_register_no_elim_operand"
 527   (match_operand 0 "register_operand")
 528 {
 529   if (GET_CODE (op) == SUBREG)
 530     op = SUBREG_REG (op);
 531
 532   if (!TARGET_64BIT && op == stack_pointer_rtx)
 533     return 0;
 534
 535   return register_no_elim_operand (op, mode);
 536 })
 537
 538 ;; Similarly, but include the stack pointer.  This is used to prevent esp
 539 ;; from being used as an index reg.
 540 (define_predicate "index_register_operand"
 541   (match_operand 0 "register_operand")
 542 {
 543   if (GET_CODE (op) == SUBREG)
 544     op = SUBREG_REG (op);
 545   if (reload_in_progress || reload_completed)
 546     return REG_OK_FOR_INDEX_STRICT_P (op);
 547   else
 548     return REG_OK_FOR_INDEX_NONSTRICT_P (op);
 549 })
 550
 551 ;; Return false if this is any eliminable register.  Otherwise general_operand.
 552 (define_predicate "general_no_elim_operand"
 553   (if_then_else (match_code "reg,subreg")
 554     (match_operand 0 "register_no_elim_operand")
 555     (match_operand 0 "general_operand")))
 556
 557 ;; Return false if this is any eliminable register.  Otherwise
 558 ;; register_operand or a constant.
 559 (define_predicate "nonmemory_no_elim_operand"
 560   (ior (match_operand 0 "register_no_elim_operand")
 561        (match_operand 0 "immediate_operand")))
 562
 563 ;; Test for a valid operand for a call instruction.
 564 (define_predicate "call_insn_operand"
 565   (ior (match_operand 0 "constant_call_address_operand")
 566        (ior (match_operand 0 "call_register_no_elim_operand")
 567             (match_operand 0 "memory_operand"))))
 568
 569 ;; Similarly, but for tail calls, in which we cannot allow memory references.
 570 (define_predicate "sibcall_insn_operand"
 571   (ior (match_operand 0 "constant_call_address_operand")
 572        (match_operand 0 "register_no_elim_operand")))
 573
 574 ;; Match exactly zero.
 575 (define_predicate "const0_operand"
 576   (match_code "const_int,const_double,const_vector")
 577 {
 578   if (mode == VOIDmode)
 579     mode = GET_MODE (op);
 580   return op == CONST0_RTX (mode);
 581 })
 582
 583 ;; Match exactly one.
 584 (define_predicate "const1_operand"
 585   (and (match_code "const_int")
 586        (match_test "op == const1_rtx")))
 587
 588 ;; Match exactly eight.
 589 (define_predicate "const8_operand"
 590   (and (match_code "const_int")
 591        (match_test "INTVAL (op) == 8")))
 592
 593 ;; Match 2, 4, or 8.  Used for leal multiplicands.
 594 (define_predicate "const248_operand"
 595   (match_code "const_int")
 596 {
 597   HOST_WIDE_INT i = INTVAL (op);
 598   return i == 2 || i == 4 || i == 8;
 599 })
 600
 601 ;; Match 0 or 1.
 602 (define_predicate "const_0_to_1_operand"
 603   (and (match_code "const_int")
 604        (match_test "op == const0_rtx || op == const1_rtx")))
 605
 606 ;; Match 0 to 3.
 607 (define_predicate "const_0_to_3_operand"
 608   (and (match_code "const_int")
 609        (match_test "IN_RANGE (INTVAL (op), 0, 3)")))
 610
 611 ;; Match 0 to 7.
 612 (define_predicate "const_0_to_7_operand"
 613   (and (match_code "const_int")
 614        (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
 615
 616 ;; Match 0 to 15.
 617 (define_predicate "const_0_to_15_operand"
 618   (and (match_code "const_int")
 619        (match_test "IN_RANGE (INTVAL (op), 0, 15)")))
 620
 621 ;; Match 0 to 31.
 622 (define_predicate "const_0_to_31_operand"
 623   (and (match_code "const_int")
 624        (match_test "IN_RANGE (INTVAL (op), 0, 31)")))
 625
 626 ;; Match 0 to 63.
 627 (define_predicate "const_0_to_63_operand"
 628   (and (match_code "const_int")
 629        (match_test "IN_RANGE (INTVAL (op), 0, 63)")))
 630
 631 ;; Match 0 to 255.
 632 (define_predicate "const_0_to_255_operand"
 633   (and (match_code "const_int")
 634        (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
 635
 636 ;; Match (0 to 255) * 8
 637 (define_predicate "const_0_to_255_mul_8_operand"
 638   (match_code "const_int")
 639 {
 640   unsigned HOST_WIDE_INT val = INTVAL (op);
 641   return val <= 255*8 && val % 8 == 0;
 642 })
 643
 644 ;; Return nonzero if OP is CONST_INT >= 1 and <= 31 (a valid operand
 645 ;; for shift & compare patterns, as shifting by 0 does not change flags).
 646 (define_predicate "const_1_to_31_operand"
 647   (and (match_code "const_int")
 648        (match_test "IN_RANGE (INTVAL (op), 1, 31)")))
 649
 650 ;; Return nonzero if OP is CONST_INT >= 1 and <= 63 (a valid operand
 651 ;; for 64bit shift & compare patterns, as shifting by 0 does not change flags).
 652 (define_predicate "const_1_to_63_operand"
 653   (and (match_code "const_int")
 654        (match_test "IN_RANGE (INTVAL (op), 1, 63)")))
 655
 656 ;; Match 2 or 3.
 657 (define_predicate "const_2_to_3_operand"
 658   (and (match_code "const_int")
 659        (match_test "IN_RANGE (INTVAL (op), 2, 3)")))
 660
 661 ;; Match 4 to 5.
 662 (define_predicate "const_4_to_5_operand"
 663   (and (match_code "const_int")
 664        (match_test "IN_RANGE (INTVAL (op), 4, 5)")))
 665
 666 ;; Match 4 to 7.
 667 (define_predicate "const_4_to_7_operand"
 668   (and (match_code "const_int")
 669        (match_test "IN_RANGE (INTVAL (op), 4, 7)")))
 670
 671 ;; Match 6 to 7.
 672 (define_predicate "const_6_to_7_operand"
 673   (and (match_code "const_int")
 674        (match_test "IN_RANGE (INTVAL (op), 6, 7)")))
 675
 676 ;; Match 8 to 11.
 677 (define_predicate "const_8_to_11_operand"
 678   (and (match_code "const_int")
 679        (match_test "IN_RANGE (INTVAL (op), 8, 11)")))
 680
 681 ;; Match 12 to 15.
 682 (define_predicate "const_12_to_15_operand"
 683   (and (match_code "const_int")
 684        (match_test "IN_RANGE (INTVAL (op), 12, 15)")))
 685
 686 ;; Match exactly one bit in 2-bit mask.
 687 (define_predicate "const_pow2_1_to_2_operand"
 688   (and (match_code "const_int")
 689        (match_test "INTVAL (op) == 1 || INTVAL (op) == 2")))
 690
 691 ;; Match exactly one bit in 4-bit mask.
 692 (define_predicate "const_pow2_1_to_8_operand"
 693   (match_code "const_int")
 694 {
 695   unsigned int log = exact_log2 (INTVAL (op));
 696   return log <= 3;
 697 })
 698
 699 ;; Match exactly one bit in 8-bit mask.
 700 (define_predicate "const_pow2_1_to_128_operand"
 701   (match_code "const_int")
 702 {
 703   unsigned int log = exact_log2 (INTVAL (op));
 704   return log <= 7;
 705 })
 706
 707 ;; Match exactly one bit in 16-bit mask.
 708 (define_predicate "const_pow2_1_to_32768_operand"
 709   (match_code "const_int")
 710 {
 711   unsigned int log = exact_log2 (INTVAL (op));
 712   return log <= 15;
 713 })
 714
 715 ;; True if this is a constant appropriate for an increment or decrement.
 716 (define_predicate "incdec_operand"
 717   (match_code "const_int")
 718 {
 719   /* On Pentium4, the inc and dec operations causes extra dependency on flag
 720      registers, since carry flag is not set.  */
 721   if (!TARGET_USE_INCDEC && !optimize_size)
 722     return 0;
 723   return op == const1_rtx || op == constm1_rtx;
 724 })
 725
 726 ;; True for registers, or 1 or -1.  Used to optimize double-word shifts.
 727 (define_predicate "reg_or_pm1_operand"
 728   (ior (match_operand 0 "register_operand")
 729        (and (match_code "const_int")
 730             (match_test "op == const1_rtx || op == constm1_rtx"))))
 731
 732 ;; True if OP is acceptable as operand of DImode shift expander.
 733 (define_predicate "shiftdi_operand"
 734   (if_then_else (match_test "TARGET_64BIT")
 735     (match_operand 0 "nonimmediate_operand")
 736     (match_operand 0 "register_operand")))
 737
 738 (define_predicate "ashldi_input_operand"
 739   (if_then_else (match_test "TARGET_64BIT")
 740     (match_operand 0 "nonimmediate_operand")
 741     (match_operand 0 "reg_or_pm1_operand")))
 742
 743 ;; Return true if OP is a vector load from the constant pool with just
 744 ;; the first element nonzero.
 745 (define_predicate "zero_extended_scalar_load_operand"
 746   (match_code "mem")
 747 {
 748   unsigned n_elts;
 749   op = maybe_get_pool_constant (op);
 750   if (!op)
 751     return 0;
 752   if (GET_CODE (op) != CONST_VECTOR)
 753     return 0;
 754   n_elts =
 755     (GET_MODE_SIZE (GET_MODE (op)) /
 756      GET_MODE_SIZE (GET_MODE_INNER (GET_MODE (op))));
 757   for (n_elts--; n_elts > 0; n_elts--)
 758     {
 759       rtx elt = CONST_VECTOR_ELT (op, n_elts);
 760       if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
 761         return 0;
 762     }
 763   return 1;
 764 })
 765
 766 /* Return true if operand is a vector constant that is all ones. */
 767 (define_predicate "vector_all_ones_operand"
 768   (match_code "const_vector")
 769 {
 770   int nunits = GET_MODE_NUNITS (mode);
 771
 772   if (GET_CODE (op) == CONST_VECTOR
 773       && CONST_VECTOR_NUNITS (op) == nunits)
 774     {
 775       int i;
 776       for (i = 0; i < nunits; ++i)
 777         {
 778           rtx x = CONST_VECTOR_ELT (op, i);
 779           if (x != constm1_rtx)
 780             return 0;
 781         }
 782       return 1;
 783     }
 784
 785   return 0;
 786 })
 787
 788 ; Return 1 when OP is operand acceptable for standard SSE move.
 789 (define_predicate "vector_move_operand"
 790   (ior (match_operand 0 "nonimmediate_operand")
 791        (match_operand 0 "const0_operand")))
 792
 793 ;; Return 1 when OP is nonimmediate or standard SSE constant.
 794 (define_predicate "nonimmediate_or_sse_const_operand"
 795   (match_operand 0 "general_operand")
 796 {
 797   if (nonimmediate_operand (op, mode))
 798     return 1;
 799   if (standard_sse_constant_p (op) > 0)
 800     return 1;
 801   return 0;
 802 })
 803
 804 ;; Return true if OP is a register or a zero.
 805 (define_predicate "reg_or_0_operand"
 806   (ior (match_operand 0 "register_operand")
 807        (match_operand 0 "const0_operand")))
 808
 809 ;; Return true if op if a valid address, and does not contain
 810 ;; a segment override.
 811 (define_special_predicate "no_seg_address_operand"
 812   (match_operand 0 "address_operand")
 813 {
 814   struct ix86_address parts;
 815   int ok;
 816
 817   ok = ix86_decompose_address (op, &parts);
 818   gcc_assert (ok);
 819   return parts.seg == SEG_DEFAULT;
 820 })
 821
 822 ;; Return nonzero if the rtx is known to be at least 32 bits aligned.
 823 (define_predicate "aligned_operand"
 824   (match_operand 0 "general_operand")
 825 {
 826   struct ix86_address parts;
 827   int ok;
 828
 829   /* Registers and immediate operands are always "aligned".  */
 830   if (GET_CODE (op) != MEM)
 831     return 1;
 832
 833   /* All patterns using aligned_operand on memory operands ends up
 834      in promoting memory operand to 64bit and thus causing memory mismatch.  */
 835   if (TARGET_MEMORY_MISMATCH_STALL && !optimize_size)
 836     return 0;
 837
 838   /* Don't even try to do any aligned optimizations with volatiles.  */
 839   if (MEM_VOLATILE_P (op))
 840     return 0;
 841
 842   if (MEM_ALIGN (op) >= 32)
 843     return 1;
 844
 845   op = XEXP (op, 0);
 846
 847   /* Pushes and pops are only valid on the stack pointer.  */
 848   if (GET_CODE (op) == PRE_DEC
 849       || GET_CODE (op) == POST_INC)
 850     return 1;
 851
 852   /* Decode the address.  */
 853   ok = ix86_decompose_address (op, &parts);
 854   gcc_assert (ok);
 855
 856   /* Look for some component that isn't known to be aligned.  */
 857   if (parts.index)
 858     {
 859       if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
 860         return 0;
 861     }
 862   if (parts.base)
 863     {
 864       if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
 865         return 0;
 866     }
 867   if (parts.disp)
 868     {
 869       if (!CONST_INT_P (parts.disp)
 870           || (INTVAL (parts.disp) & 3) != 0)
 871         return 0;
 872     }
 873
 874   /* Didn't find one -- this must be an aligned address.  */
 875   return 1;
 876 })
 877
 878 ;; Returns 1 if OP is memory operand with a displacement.
 879 (define_predicate "memory_displacement_operand"
 880   (match_operand 0 "memory_operand")
 881 {
 882   struct ix86_address parts;
 883   int ok;
 884
 885   ok = ix86_decompose_address (XEXP (op, 0), &parts);
 886   gcc_assert (ok);
 887   return parts.disp != NULL_RTX;
 888 })
 889
 890 ;; Returns 1 if OP is memory operand with a displacement only.
 891 (define_predicate "memory_displacement_only_operand"
 892   (match_operand 0 "memory_operand")
 893 {
 894   struct ix86_address parts;
 895   int ok;
 896
 897   ok = ix86_decompose_address (XEXP (op, 0), &parts);
 898   gcc_assert (ok);
 899
 900   if (parts.base || parts.index)
 901     return 0;
 902
 903   return parts.disp != NULL_RTX;
 904 })
 905
 906 ;; Returns 1 if OP is memory operand which will need zero or
 907 ;; one register at most, not counting stack pointer or frame pointer.
 908 (define_predicate "cmpxchg8b_pic_memory_operand"
 909   (match_operand 0 "memory_operand")
 910 {
 911   struct ix86_address parts;
 912   int ok;
 913
 914   ok = ix86_decompose_address (XEXP (op, 0), &parts);
 915   gcc_assert (ok);
 916   if (parts.base == NULL_RTX
 917       || parts.base == arg_pointer_rtx
 918       || parts.base == frame_pointer_rtx
 919       || parts.base == hard_frame_pointer_rtx
 920       || parts.base == stack_pointer_rtx)
 921     return 1;
 922
 923   if (parts.index == NULL_RTX
 924       || parts.index == arg_pointer_rtx
 925       || parts.index == frame_pointer_rtx
 926       || parts.index == hard_frame_pointer_rtx
 927       || parts.index == stack_pointer_rtx)
 928     return 1;
 929
 930   return 0;
 931 })
 932
 933
 934 ;; Returns 1 if OP is memory operand that cannot be represented
 935 ;; by the modRM array.
 936 (define_predicate "long_memory_operand"
 937   (and (match_operand 0 "memory_operand")
 938        (match_test "memory_address_length (op) != 0")))
 939
 940 ;; Return 1 if OP is a comparison operator that can be issued by fcmov.
 941 (define_predicate "fcmov_comparison_operator"
 942   (match_operand 0 "comparison_operator")
 943 {
 944   enum machine_mode inmode = GET_MODE (XEXP (op, 0));
 945   enum rtx_code code = GET_CODE (op);
 946
 947   if (inmode == CCFPmode || inmode == CCFPUmode)
 948     {
 949       enum rtx_code second_code, bypass_code;
 950       ix86_fp_comparison_codes (code, &bypass_code, &code, &second_code);
 951       if (bypass_code != UNKNOWN || second_code != UNKNOWN)
 952         return 0;
 953       code = ix86_fp_compare_code_to_integer (code);
 954     }
 955   /* i387 supports just limited amount of conditional codes.  */
 956   switch (code)
 957     {
 958     case LTU: case GTU: case LEU: case GEU:
 959       if (inmode == CCmode || inmode == CCFPmode || inmode == CCFPUmode
 960           || inmode == CCCmode)
 961         return 1;
 962       return 0;
 963     case ORDERED: case UNORDERED:
 964     case EQ: case NE:
 965       return 1;
 966     default:
 967       return 0;
 968     }
 969 })
 970
 971 ;; Return 1 if OP is a comparison that can be used in the CMPSS/CMPPS insns.
 972 ;; The first set are supported directly; the second set can't be done with
 973 ;; full IEEE support, i.e. NaNs.
 974 ;;
 975 ;; ??? It would seem that we have a lot of uses of this predicate that pass
 976 ;; it the wrong mode.  We got away with this because the old function didn't
 977 ;; check the mode at all.  Mirror that for now by calling this a special
 978 ;; predicate.
 979
 980 (define_special_predicate "sse_comparison_operator"
 981   (match_code "eq,lt,le,unordered,ne,unge,ungt,ordered"))
 982
 983 ;; Return 1 if OP is a comparison operator that can be issued by
 984 ;; avx predicate generation instructions
 985 (define_predicate "avx_comparison_float_operator"
 986   (match_code "ne,eq,ge,gt,le,lt,unordered,ordered,uneq,unge,ungt,unle,unlt,ltgt"))
 987
 988 ;; Return 1 if OP is a comparison operator that can be issued by sse predicate
 989 ;; generation instructions
 990 (define_predicate "sse5_comparison_float_operator"
 991   (and (match_test "TARGET_SSE5")
 992        (match_code "ne,eq,ge,gt,le,lt,unordered,ordered,uneq,unge,ungt,unle,unlt,ltgt")))
 993
 994 (define_predicate "ix86_comparison_int_operator"
 995   (match_code "ne,eq,ge,gt,le,lt"))
 996
 997 (define_predicate "ix86_comparison_uns_operator"
 998   (match_code "ne,eq,geu,gtu,leu,ltu"))
 999
1000 (define_predicate "bt_comparison_operator"
1001   (match_code "ne,eq"))
1002
1003 ;; Return 1 if OP is a valid comparison operator in valid mode.
1004 (define_predicate "ix86_comparison_operator"
1005   (match_operand 0 "comparison_operator")
1006 {
1007   enum machine_mode inmode = GET_MODE (XEXP (op, 0));
1008   enum rtx_code code = GET_CODE (op);
1009
1010   if (inmode == CCFPmode || inmode == CCFPUmode)
1011     {
1012       enum rtx_code second_code, bypass_code;
1013       ix86_fp_comparison_codes (code, &bypass_code, &code, &second_code);
1014       return (bypass_code == UNKNOWN && second_code == UNKNOWN);
1015     }
1016   switch (code)
1017     {
1018     case EQ: case NE:
1019       return 1;
1020     case LT: case GE:
1021       if (inmode == CCmode || inmode == CCGCmode
1022           || inmode == CCGOCmode || inmode == CCNOmode)
1023         return 1;
1024       return 0;
1025     case LTU: case GTU: case LEU: case GEU:
1026       if (inmode == CCmode || inmode == CCCmode)
1027         return 1;
1028       return 0;
1029     case ORDERED: case UNORDERED:
1030       if (inmode == CCmode)
1031         return 1;
1032       return 0;
1033     case GT: case LE:
1034       if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
1035         return 1;
1036       return 0;
1037     default:
1038       return 0;
1039     }
1040 })
1041
1042 ;; Return 1 if OP is a valid comparison operator testing carry flag to be set.
1043 (define_predicate "ix86_carry_flag_operator"
1044   (match_code "ltu,lt,unlt,gtu,gt,ungt,le,unle,ge,unge,ltgt,uneq")
1045 {
1046   enum machine_mode inmode = GET_MODE (XEXP (op, 0));
1047   enum rtx_code code = GET_CODE (op);
1048
1049   if (!REG_P (XEXP (op, 0))
1050       || REGNO (XEXP (op, 0)) != FLAGS_REG
1051       || XEXP (op, 1) != const0_rtx)
1052     return 0;
1053
1054   if (inmode == CCFPmode || inmode == CCFPUmode)
1055     {
1056       enum rtx_code second_code, bypass_code;
1057       ix86_fp_comparison_codes (code, &bypass_code, &code, &second_code);
1058       if (bypass_code != UNKNOWN || second_code != UNKNOWN)
1059         return 0;
1060       code = ix86_fp_compare_code_to_integer (code);
1061     }
1062   else if (inmode == CCCmode)
1063    return code == LTU || code == GTU;
1064   else if (inmode != CCmode)
1065     return 0;
1066
1067   return code == LTU;
1068 })
1069
1070 ;; Nearly general operand, but accept any const_double, since we wish
1071 ;; to be able to drop them into memory rather than have them get pulled
1072 ;; into registers.
1073 (define_predicate "cmp_fp_expander_operand"
1074   (ior (match_code "const_double")
1075        (match_operand 0 "general_operand")))
1076
1077 ;; Return true if this is a valid binary floating-point operation.
1078 (define_predicate "binary_fp_operator"
1079   (match_code "plus,minus,mult,div"))
1080
1081 ;; Return true if this is a multiply operation.
1082 (define_predicate "mult_operator"
1083   (match_code "mult"))
1084
1085 ;; Return true if this is a division operation.
1086 (define_predicate "div_operator"
1087   (match_code "div"))
1088
1089 ;; Return true if this is a float extend operation.
1090 (define_predicate "float_operator"
1091   (match_code "float"))
1092
1093 ;; Return true for ARITHMETIC_P.
1094 (define_predicate "arith_or_logical_operator"
1095   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div,
1096                mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert"))
1097
1098 ;; Return true for COMMUTATIVE_P.
1099 (define_predicate "commutative_operator"
1100   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax"))
1101
1102 ;; Return 1 if OP is a binary operator that can be promoted to wider mode.
1103 (define_predicate "promotable_binary_operator"
1104   (ior (match_code "plus,and,ior,xor,ashift")
1105        (and (match_code "mult")
1106             (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL"))))
1107
1108 ;; To avoid problems when jump re-emits comparisons like testqi_ext_ccno_0,
1109 ;; re-recognize the operand to avoid a copy_to_mode_reg that will fail.
1110 ;;
1111 ;; ??? It seems likely that this will only work because cmpsi is an
1112 ;; expander, and no actual insns use this.
1113
1114 (define_predicate "cmpsi_operand"
1115   (ior (match_operand 0 "nonimmediate_operand")
1116        (and (match_code "and")
1117             (match_code "zero_extract" "0")
1118             (match_code "const_int"    "1")
1119             (match_code "const_int"    "01")
1120             (match_code "const_int"    "02")
1121             (match_test "INTVAL (XEXP (XEXP (op, 0), 1)) == 8")
1122             (match_test "INTVAL (XEXP (XEXP (op, 0), 2)) == 8")
1123        )))
1124
1125 (define_predicate "compare_operator"
1126   (match_code "compare"))
1127
1128 (define_predicate "absneg_operator"
1129   (match_code "abs,neg"))
1130
1131 ;; Return 1 if OP is misaligned memory operand
1132 (define_predicate "misaligned_operand"
1133   (and (match_code "mem")
1134        (match_test "MEM_ALIGN (op) < GET_MODE_ALIGNMENT (mode)")))
1135
1136 ;; Return 1 if OP is a vzeroall operation, known to be a PARALLEL.
1137 (define_predicate "vzeroall_operation"
1138   (match_code "parallel")
1139 {
1140   int nregs = TARGET_64BIT ? 16 : 8;
1141
1142   if (XVECLEN (op, 0) != nregs + 1)
1143     return 0;
1144
1145   return 1;
1146 })