gcc/config/sparc/predicates.md

   1 ;; Predicate definitions for SPARC.
   2 ;; Copyright (C) 2005, 2007, 2008, 2010, 2012 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 ;; Predicates for numerical constants.
  21
  22 ;; Return true if OP is the zero constant for MODE.
  23 (define_predicate "const_zero_operand"
  24   (and (match_code "const_int,const_double,const_vector")
  25        (match_test "op == CONST0_RTX (mode)")))
  26
  27 ;; Return true if the integer representation of OP is
  28 ;; all-ones.
  29 (define_predicate "const_all_ones_operand"
  30   (match_code "const_int,const_double,const_vector")
  31 {
  32   if (GET_CODE (op) == CONST_INT && INTVAL (op) == -1)
  33     return true;
  34 #if HOST_BITS_PER_WIDE_INT == 32
  35   if (GET_CODE (op) == CONST_DOUBLE
  36       && GET_MODE (op) == VOIDmode
  37       && CONST_DOUBLE_HIGH (op) == ~(HOST_WIDE_INT)0
  38       && CONST_DOUBLE_LOW (op) == ~(HOST_WIDE_INT)0)
  39     return true;
  40 #endif
  41   if (GET_CODE (op) == CONST_VECTOR)
  42     {
  43       int i, num_elem = CONST_VECTOR_NUNITS (op);
  44
  45       for (i = 0; i < num_elem; i++)
  46         {
  47           rtx n = CONST_VECTOR_ELT (op, i);
  48           if (! const_all_ones_operand (n, mode))
  49             return false;
  50         }
  51       return true;
  52     }
  53   return false;
  54 })
  55
  56 ;; Return true if OP is the integer constant 4096.
  57 (define_predicate "const_4096_operand"
  58   (and (match_code "const_int")
  59        (match_test "INTVAL (op) == 4096")))
  60
  61 ;; Return true if OP is a constant that is representable by a 13-bit
  62 ;; signed field.  This is an acceptable immediate operand for most
  63 ;; 3-address instructions.
  64 (define_predicate "small_int_operand"
  65   (and (match_code "const_int")
  66        (match_test "SPARC_SIMM13_P (INTVAL (op))")))
  67
  68 ;; Return true if OP is a constant operand for the umul instruction.  That
  69 ;; instruction sign-extends immediate values just like all other SPARC
  70 ;; instructions, but interprets the extended result as an unsigned number.
  71 (define_predicate "uns_small_int_operand"
  72   (match_code "const_int,const_double")
  73 {
  74 #if HOST_BITS_PER_WIDE_INT == 32
  75   return ((GET_CODE (op) == CONST_INT && (unsigned) INTVAL (op) < 0x1000)
  76           || (GET_CODE (op) == CONST_DOUBLE
  77               && CONST_DOUBLE_HIGH (op) == 0
  78               && (unsigned) CONST_DOUBLE_LOW (op) - 0xFFFFF000 < 0x1000));
  79 #else
  80   return (GET_CODE (op) == CONST_INT
  81           && ((INTVAL (op) >= 0 && INTVAL (op) < 0x1000)
  82               || (INTVAL (op) >= 0xFFFFF000
  83                   && INTVAL (op) <= 0xFFFFFFFF)));
  84 #endif
  85 })
  86
  87 ;; Return true if OP is a constant that can be loaded by the sethi instruction.
  88 ;; The first test avoids emitting sethi to load zero for example.
  89 (define_predicate "const_high_operand"
  90   (and (match_code "const_int")
  91        (and (not (match_operand 0 "small_int_operand"))
  92             (match_test "SPARC_SETHI_P (INTVAL (op) & GET_MODE_MASK (mode))"))))
  93
  94 ;; Return true if OP is a constant whose 1's complement can be loaded by the
  95 ;; sethi instruction.
  96 (define_predicate "const_compl_high_operand"
  97   (and (match_code "const_int")
  98        (and (not (match_operand 0 "small_int_operand"))
  99             (match_test "SPARC_SETHI_P (~INTVAL (op) & GET_MODE_MASK (mode))"))))
 100
 101 ;; Return true if OP is a FP constant that needs to be loaded by the sethi/losum
 102 ;; pair of instructions.
 103 (define_predicate "fp_const_high_losum_operand"
 104   (match_operand 0 "const_double_operand")
 105 {
 106   gcc_assert (mode == SFmode);
 107   return fp_high_losum_p (op);
 108 })
 109
 110 ;; Return true if OP is a const_double or const_vector.
 111 (define_predicate "const_double_or_vector_operand"
 112   (match_code "const_double,const_vector"))
 113
 114 ;; Return true if OP is Zero, or if the target is V7.
 115 (define_predicate "zero_or_v7_operand"
 116   (and (match_code "const_int")
 117        (ior (match_test "INTVAL (op) == 0")
 118             (match_test "!TARGET_V8 && !TARGET_V9"))))
 119
 120 ;; Predicates for symbolic constants.
 121
 122 ;; Return true if OP is either a symbol reference or a sum of a symbol
 123 ;; reference and a constant.
 124 (define_predicate "symbolic_operand"
 125   (match_code "symbol_ref,label_ref,const")
 126 {
 127   enum machine_mode omode = GET_MODE (op);
 128
 129   if (omode != mode && omode != VOIDmode && mode != VOIDmode)
 130     return false;
 131
 132   switch (GET_CODE (op))
 133     {
 134     case SYMBOL_REF:
 135       return !SYMBOL_REF_TLS_MODEL (op);
 136
 137     case LABEL_REF:
 138       return true;
 139
 140     case CONST:
 141       op = XEXP (op, 0);
 142       return (((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
 143                 && !SYMBOL_REF_TLS_MODEL (XEXP (op, 0)))
 144                || GET_CODE (XEXP (op, 0)) == LABEL_REF)
 145               && GET_CODE (XEXP (op, 1)) == CONST_INT);
 146
 147     default:
 148       gcc_unreachable ();
 149     }
 150 })
 151
 152 ;; Return true if OP is a symbolic operand for the TLS Global Dynamic model.
 153 (define_predicate "tgd_symbolic_operand"
 154   (and (match_code "symbol_ref")
 155        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_GLOBAL_DYNAMIC")))
 156
 157 ;; Return true if OP is a symbolic operand for the TLS Local Dynamic model.
 158 (define_predicate "tld_symbolic_operand"
 159   (and (match_code "symbol_ref")
 160        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_DYNAMIC")))
 161
 162 ;; Return true if OP is a symbolic operand for the TLS Initial Exec model.
 163 (define_predicate "tie_symbolic_operand"
 164   (and (match_code "symbol_ref")
 165        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_INITIAL_EXEC")))
 166
 167 ;; Return true if OP is a symbolic operand for the TLS Local Exec model.
 168 (define_predicate "tle_symbolic_operand"
 169   (and (match_code "symbol_ref")
 170        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_EXEC")))
 171
 172 ;; Return true if the operand is an argument used in generating PIC references
 173 ;; in either the medium/low or embedded medium/anywhere code models on V9.
 174 ;; Check for (const (minus (symbol_ref:GOT)
 175 ;;                         (const (minus (label) (pc)))))
 176 (define_predicate "medium_pic_operand"
 177   (match_code "const")
 178 {
 179   /* Check for (const (minus (symbol_ref:GOT)
 180                              (const (minus (label) (pc))))).  */
 181   op = XEXP (op, 0);
 182   return GET_CODE (op) == MINUS
 183          && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
 184          && GET_CODE (XEXP (op, 1)) == CONST
 185          && GET_CODE (XEXP (XEXP (op, 1), 0)) == MINUS;
 186 })
 187
 188 ;; Return true if OP is a LABEL_REF of mode MODE.
 189 (define_predicate "label_ref_operand"
 190   (and (match_code "label_ref")
 191        (match_test "GET_MODE (op) == mode")))
 192
 193 ;; Return true if OP is a data segment reference.  This includes the readonly
 194 ;; data segment or, in other words, anything but the text segment.
 195 ;; This is needed in the embedded medium/anywhere code model on V9.  These
 196 ;; values are accessed with EMBMEDANY_BASE_REG.  */
 197 (define_predicate "data_segment_operand"
 198   (match_code "symbol_ref,plus,const")
 199 {
 200   switch (GET_CODE (op))
 201     {
 202     case SYMBOL_REF :
 203       return ! SYMBOL_REF_FUNCTION_P (op);
 204     case PLUS :
 205       /* Assume canonical format of symbol + constant.
 206          Fall through.  */
 207     case CONST :
 208       return data_segment_operand (XEXP (op, 0), VOIDmode);
 209     default :
 210       gcc_unreachable ();
 211     }
 212 })
 213
 214 ;; Return true if OP is a text segment reference.
 215 ;; This is needed in the embedded medium/anywhere code model on V9.
 216 (define_predicate "text_segment_operand"
 217   (match_code "label_ref,symbol_ref,plus,const")
 218 {
 219   switch (GET_CODE (op))
 220     {
 221     case LABEL_REF :
 222       return true;
 223     case SYMBOL_REF :
 224       return SYMBOL_REF_FUNCTION_P (op);
 225     case PLUS :
 226       /* Assume canonical format of symbol + constant.
 227          Fall through.  */
 228     case CONST :
 229       return text_segment_operand (XEXP (op, 0), VOIDmode);
 230     default :
 231       gcc_unreachable ();
 232     }
 233 })
 234
 235
 236 ;; Predicates for registers.
 237
 238 ;; Return true if OP is either the zero constant or a register.
 239 (define_predicate "register_or_zero_operand"
 240   (ior (match_operand 0 "register_operand")
 241        (match_operand 0 "const_zero_operand")))
 242
 243 (define_predicate "register_or_v9_zero_operand"
 244   (ior (match_operand 0 "register_operand")
 245        (and (match_test "TARGET_V9")
 246             (match_operand 0 "const_zero_operand"))))
 247
 248 ;; Return true if OP is either the zero constant, the all-ones
 249 ;; constant, or a register.
 250 (define_predicate "register_or_zero_or_all_ones_operand"
 251   (ior (match_operand 0 "register_or_zero_operand")
 252        (match_operand 0 "const_all_ones_operand")))
 253
 254 ;; Return true if OP is a register operand in a floating point register.
 255 (define_predicate "fp_register_operand"
 256   (match_operand 0 "register_operand")
 257 {
 258   if (GET_CODE (op) == SUBREG)
 259     op = SUBREG_REG (op); /* Possibly a MEM */
 260   return REG_P (op) && SPARC_FP_REG_P (REGNO (op));
 261 })
 262
 263 ;; Return true if OP is an integer register.
 264 (define_special_predicate "int_register_operand"
 265   (ior (match_test "register_operand (op, SImode)")
 266        (match_test "TARGET_ARCH64 && register_operand (op, DImode)")))
 267
 268 ;; Return true if OP is a floating point condition code register.
 269 (define_predicate "fcc_register_operand"
 270   (match_code "reg")
 271 {
 272   if (mode != VOIDmode && mode != GET_MODE (op))
 273     return false;
 274   if (mode == VOIDmode
 275       && (GET_MODE (op) != CCFPmode && GET_MODE (op) != CCFPEmode))
 276     return false;
 277
 278 #if 0 /* ??? 1 when %fcc0-3 are pseudos first.  See gen_compare_reg().  */
 279   if (reg_renumber == 0)
 280     return REGNO (op) >= FIRST_PSEUDO_REGISTER;
 281   return REGNO_OK_FOR_CCFP_P (REGNO (op));
 282 #else
 283   return ((unsigned) REGNO (op) - SPARC_FIRST_V9_FCC_REG) < 4;
 284 #endif
 285 })
 286
 287 ;; Return true if OP is the floating point condition code register fcc0.
 288 (define_predicate "fcc0_register_operand"
 289   (match_code "reg")
 290 {
 291   if (mode != VOIDmode && mode != GET_MODE (op))
 292     return false;
 293   if (mode == VOIDmode
 294       && (GET_MODE (op) != CCFPmode && GET_MODE (op) != CCFPEmode))
 295     return false;
 296
 297   return REGNO (op) == SPARC_FCC_REG;
 298 })
 299
 300 ;; Return true if OP is an integer or floating point condition code register.
 301 (define_predicate "icc_or_fcc_register_operand"
 302   (match_code "reg")
 303 {
 304   if (REGNO (op) == SPARC_ICC_REG)
 305     {
 306       if (mode != VOIDmode && mode != GET_MODE (op))
 307         return false;
 308       if (mode == VOIDmode
 309           && GET_MODE (op) != CCmode && GET_MODE (op) != CCXmode)
 310         return false;
 311
 312       return true;
 313     }
 314
 315   return fcc_register_operand (op, mode);
 316 })
 317
 318
 319 ;; Predicates for arithmetic instructions.
 320
 321 ;; Return true if OP is a register, or is a constant that is representable
 322 ;; by a 13-bit signed field.  This is an acceptable operand for most
 323 ;; 3-address instructions.
 324 (define_predicate "arith_operand"
 325   (ior (match_operand 0 "register_operand")
 326        (match_operand 0 "small_int_operand")))
 327
 328 ;; 64-bit: Same as above.
 329 ;; 32-bit: Return true if OP is a register, or is a constant that is
 330 ;; representable by a couple of 13-bit signed fields.  This is an
 331 ;; acceptable operand for most 3-address splitters.
 332 (define_predicate "arith_double_operand"
 333   (match_code "const_int,const_double,reg,subreg")
 334 {
 335   bool arith_simple_operand = arith_operand (op, mode);
 336   HOST_WIDE_INT m1, m2;
 337
 338   if (TARGET_ARCH64 || arith_simple_operand)
 339     return arith_simple_operand;
 340
 341 #if HOST_BITS_PER_WIDE_INT == 32
 342   if (GET_CODE (op) != CONST_DOUBLE)
 343     return false;
 344   m1 = CONST_DOUBLE_LOW (op);
 345   m2 = CONST_DOUBLE_HIGH (op);
 346 #else
 347   if (GET_CODE (op) != CONST_INT)
 348     return false;
 349   m1 = trunc_int_for_mode (INTVAL (op), SImode);
 350   m2 = trunc_int_for_mode (INTVAL (op) >> 32, SImode);
 351 #endif
 352
 353   return SPARC_SIMM13_P (m1) && SPARC_SIMM13_P (m2);
 354 })
 355
 356 ;; Return true if OP is suitable as second operand for add/sub.
 357 (define_predicate "arith_add_operand"
 358   (ior (match_operand 0 "arith_operand")
 359        (match_operand 0 "const_4096_operand")))
 360
 361 ;; Return true if OP is suitable as second double operand for add/sub.
 362 (define_predicate "arith_double_add_operand"
 363   (match_code "const_int,const_double,reg,subreg")
 364 {
 365   bool _arith_double_operand = arith_double_operand (op, mode);
 366
 367   if (_arith_double_operand)
 368     return true;
 369
 370   return TARGET_ARCH64 && const_4096_operand (op, mode);
 371 })
 372
 373 ;; Return true if OP is a register, or is a CONST_INT that can fit in a
 374 ;; signed 10-bit immediate field.  This is an acceptable SImode operand for
 375 ;; the movrcc instructions.
 376 (define_predicate "arith10_operand"
 377   (ior (match_operand 0 "register_operand")
 378        (and (match_code "const_int")
 379             (match_test "SPARC_SIMM10_P (INTVAL (op))"))))
 380
 381 ;; Return true if OP is a register, or is a CONST_INT that can fit in a
 382 ;; signed 11-bit immediate field.  This is an acceptable SImode operand for
 383 ;; the movcc instructions.
 384 (define_predicate "arith11_operand"
 385   (ior (match_operand 0 "register_operand")
 386        (and (match_code "const_int")
 387             (match_test "SPARC_SIMM11_P (INTVAL (op))"))))
 388
 389 ;; Return true if OP is a register or a constant for the umul instruction.
 390 (define_predicate "uns_arith_operand"
 391   (ior (match_operand 0 "register_operand")
 392        (match_operand 0 "uns_small_int_operand")))
 393
 394
 395 ;; Predicates for miscellaneous instructions.
 396
 397 ;; Return true if OP is valid for the lhs of a comparison insn.
 398 (define_predicate "compare_operand"
 399   (match_code "reg,subreg,zero_extract")
 400 {
 401   if (GET_CODE (op) == ZERO_EXTRACT)
 402     return (register_operand (XEXP (op, 0), mode)
 403             && small_int_operand (XEXP (op, 1), mode)
 404             && small_int_operand (XEXP (op, 2), mode)
 405             /* This matches cmp_zero_extract.  */
 406             && ((mode == SImode
 407                  && INTVAL (XEXP (op, 2)) > 19)
 408                 /* This matches cmp_zero_extract_sp64.  */
 409                 || (TARGET_ARCH64
 410                     && mode == DImode
 411                     && INTVAL (XEXP (op, 2)) > 51)));
 412   else
 413     return register_operand (op, mode);
 414 })
 415
 416 ;; Return true if OP is a valid operand for the source of a move insn.
 417 (define_predicate "input_operand"
 418   (match_code "const_int,const_double,const_vector,reg,subreg,mem")
 419 {
 420   enum mode_class mclass;
 421
 422   /* If both modes are non-void they must be the same.  */
 423   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 424     return false;
 425
 426   mclass = GET_MODE_CLASS (mode);
 427
 428   /* Allow any 1-instruction integer constant.  */
 429   if (mclass == MODE_INT
 430       && (small_int_operand (op, mode) || const_high_operand (op, mode)))
 431     return true;
 432
 433   /* If 32-bit mode and this is a DImode constant, allow it
 434      so that the splits can be generated.  */
 435   if (TARGET_ARCH32
 436       && mode == DImode
 437       && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
 438     return true;
 439
 440   if (mclass == MODE_FLOAT && GET_CODE (op) == CONST_DOUBLE)
 441     return true;
 442
 443   if (mclass == MODE_VECTOR_INT && GET_CODE (op) == CONST_VECTOR
 444       && (const_zero_operand (op, mode)
 445           || const_all_ones_operand (op, mode)))
 446     return true;
 447
 448   if (register_operand (op, mode))
 449     return true;
 450
 451   /* If this is a SUBREG, look inside so that we handle paradoxical ones.  */
 452   if (GET_CODE (op) == SUBREG)
 453     op = SUBREG_REG (op);
 454
 455   /* Check for valid MEM forms.  */
 456   if (GET_CODE (op) == MEM)
 457     return memory_address_p (mode, XEXP (op, 0));
 458
 459   return false;
 460 })
 461
 462 ;; Return true if OP is an address suitable for a call insn.
 463 ;; Call insn on SPARC can take a PC-relative constant address
 464 ;; or any regular memory address.
 465 (define_predicate "call_address_operand"
 466   (ior (match_operand 0 "symbolic_operand")
 467        (match_test "memory_address_p (Pmode, op)")))
 468
 469 ;; Return true if OP is an operand suitable for a call insn.
 470 (define_predicate "call_operand"
 471   (and (match_code "mem")
 472        (match_test "call_address_operand (XEXP (op, 0), mode)")))
 473
 474
 475 (define_predicate "mem_noofs_operand"
 476   (and (match_code "mem")
 477        (match_code "reg" "0")))
 478
 479 ;; Predicates for operators.
 480
 481 ;; Return true if OP is a comparison operator.  This allows the use of
 482 ;; MATCH_OPERATOR to recognize all the branch insns.
 483 (define_predicate "noov_compare_operator"
 484   (match_code "ne,eq,ge,gt,le,lt,geu,gtu,leu,ltu")
 485 {
 486   enum rtx_code code = GET_CODE (op);
 487   if (GET_MODE (XEXP (op, 0)) == CC_NOOVmode
 488       || GET_MODE (XEXP (op, 0)) == CCX_NOOVmode)
 489     /* These are the only branches which work with CC_NOOVmode.  */
 490     return (code == EQ || code == NE || code == GE || code == LT);
 491   return true;
 492 })
 493
 494 ;; Return true if OP is a 64-bit comparison operator.  This allows the use of
 495 ;; MATCH_OPERATOR to recognize all the branch insns.
 496 (define_predicate "noov_compare64_operator"
 497   (and (match_code "ne,eq,ge,gt,le,lt,geu,gtu,leu,ltu")
 498        (match_test "TARGET_V9"))
 499 {
 500   enum rtx_code code = GET_CODE (op);
 501   if (GET_MODE (XEXP (op, 0)) == CCX_NOOVmode)
 502     /* These are the only branches which work with CCX_NOOVmode.  */
 503     return (code == EQ || code == NE || code == GE || code == LT);
 504   return (GET_MODE (XEXP (op, 0)) == CCXmode);
 505 })
 506
 507 ;; Return true if OP is a comparison operator suitable for use in V9
 508 ;; conditional move or branch on register contents instructions.
 509 (define_predicate "v9_register_compare_operator"
 510   (match_code "eq,ne,ge,lt,le,gt"))
 511
 512 ;; Return true if OP is an operator which can set the condition codes
 513 ;; explicitly.  We do not include PLUS and MINUS because these
 514 ;; require CC_NOOVmode, which we handle explicitly.
 515 (define_predicate "cc_arith_operator"
 516   (match_code "and,ior,xor"))
 517
 518 ;; Return true if OP is an operator which can bitwise complement its
 519 ;; second operand and set the condition codes explicitly.
 520 ;; XOR is not here because combine canonicalizes (xor (not ...) ...)
 521 ;; and (xor ... (not ...)) to (not (xor ...)).  */
 522 (define_predicate "cc_arith_not_operator"
 523   (match_code "and,ior"))