gcc/config/pa/predicates.md

   1 ;; Predicate definitions for HP PA-RISC.
   2 ;; Copyright (C) 2005 Free Software Foundation, Inc.
   3 ;;
   4 ;; This file is part of GCC.
   5 ;;
   6 ;; GCC is free software; you can redistribute it and/or modify
   7 ;; it under the terms of the GNU General Public License as published by
   8 ;; the Free Software Foundation; either version 2, or (at your option)
   9 ;; any later version.
  10 ;;
  11 ;; GCC is distributed in the hope that it will be useful,
  12 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ;; GNU General Public License for more details.
  15 ;;
  16 ;; You should have received a copy of the GNU General Public License
  17 ;; along with GCC; see the file COPYING.  If not, write to
  18 ;; the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  19 ;; Boston, MA 02110-1301, USA.
  20
  21 ;; Return nonzero only if OP is a register of mode MODE, or
  22 ;; CONST0_RTX.
  23
  24 (define_predicate "reg_or_0_operand"
  25   (match_code "subreg,reg,const_int,const_double")
  26 {
  27   return (op == CONST0_RTX (mode) || register_operand (op, mode));
  28 })
  29
  30 ;; Return nonzero if OP is suitable for use in a call to a named
  31 ;; function.
  32 ;;
  33 ;; For 2.5 try to eliminate either call_operand_address or
  34 ;; function_label_operand, they perform very similar functions.
  35
  36 (define_predicate "call_operand_address"
  37   (match_code "label_ref,symbol_ref,const_int,const_double,const,high")
  38 {
  39   return (GET_MODE (op) == word_mode
  40           && CONSTANT_P (op) && ! TARGET_PORTABLE_RUNTIME);
  41 })
  42
  43 ;; Return 1 iff OP is an indexed memory operand.
  44
  45 (define_predicate "indexed_memory_operand"
  46   (match_code "subreg,mem")
  47 {
  48   if (GET_MODE (op) != mode)
  49     return 0;
  50
  51   /* Before reload, a (SUBREG (MEM...)) forces reloading into a register.  */
  52   if (reload_completed && GET_CODE (op) == SUBREG)
  53     op = SUBREG_REG (op);
  54
  55   if (GET_CODE (op) != MEM || symbolic_memory_operand (op, mode))
  56     return 0;
  57
  58   op = XEXP (op, 0);
  59
  60   return (memory_address_p (mode, op) && IS_INDEX_ADDR_P (op));
  61 })
  62
  63 ;; Return 1 iff OP is a symbolic operand.
  64 ;; Note: an inline copy of this code is present in pa_secondary_reload.
  65
  66 (define_predicate "symbolic_operand"
  67   (match_code "symbol_ref,label_ref,const")
  68 {
  69   switch (GET_CODE (op))
  70     {
  71     case SYMBOL_REF:
  72       return !SYMBOL_REF_TLS_MODEL (op);
  73     case LABEL_REF:
  74       return 1;
  75     case CONST:
  76       op = XEXP (op, 0);
  77       return (((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
  78                 && !SYMBOL_REF_TLS_MODEL (XEXP (op, 0)))
  79                || GET_CODE (XEXP (op, 0)) == LABEL_REF)
  80               && GET_CODE (XEXP (op, 1)) == CONST_INT);
  81     default:
  82       return 0;
  83     }
  84 })
  85
  86 ;; Return truth value of statement that OP is a symbolic memory
  87 ;; operand of mode MODE.
  88
  89 (define_predicate "symbolic_memory_operand"
  90   (match_code "subreg,mem")
  91 {
  92   if (GET_CODE (op) == SUBREG)
  93     op = SUBREG_REG (op);
  94   if (GET_CODE (op) != MEM)
  95     return 0;
  96   op = XEXP (op, 0);
  97   return ((GET_CODE (op) == SYMBOL_REF && !SYMBOL_REF_TLS_MODEL (op))
  98          || GET_CODE (op) == CONST || GET_CODE (op) == HIGH
  99          || GET_CODE (op) == LABEL_REF);
 100 })
 101
 102 ;; Return true if OP is a symbolic operand for the TLS Global Dynamic model.
 103 (define_predicate "tgd_symbolic_operand"
 104   (and (match_code "symbol_ref")
 105        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_GLOBAL_DYNAMIC")))
 106
 107 ;; Return true if OP is a symbolic operand for the TLS Local Dynamic model.
 108 (define_predicate "tld_symbolic_operand"
 109   (and (match_code "symbol_ref")
 110        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_DYNAMIC")))
 111
 112 ;; Return true if OP is a symbolic operand for the TLS Initial Exec model.
 113 (define_predicate "tie_symbolic_operand"
 114   (and (match_code "symbol_ref")
 115        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_INITIAL_EXEC")))
 116
 117 ;; Return true if OP is a symbolic operand for the TLS Local Exec model.
 118 (define_predicate "tle_symbolic_operand"
 119   (and (match_code "symbol_ref")
 120        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_EXEC")))
 121
 122
 123 ;; Return 1 if the operand is a register operand or a non-symbolic
 124 ;; memory operand after reload.  This predicate is used for branch
 125 ;; patterns that internally handle register reloading.  We need to
 126 ;; accept non-symbolic memory operands after reload to ensure that the
 127 ;; pattern is still valid if reload didn't find a hard register for
 128 ;; the operand.
 129
 130 (define_predicate "reg_before_reload_operand"
 131   (match_code "reg,mem")
 132 {
 133   /* Don't accept a SUBREG since it will need a reload.  */
 134   if (GET_CODE (op) == SUBREG)
 135     return 0;
 136
 137   if (register_operand (op, mode))
 138     return 1;
 139
 140   if (reload_completed
 141       && memory_operand (op, mode)
 142       && !symbolic_memory_operand (op, mode))
 143     return 1;
 144
 145   return 0;
 146 })
 147
 148 ;; Return 1 if the operand is either a register, zero, or a memory
 149 ;; operand that is not symbolic.
 150
 151 (define_predicate "reg_or_0_or_nonsymb_mem_operand"
 152   (match_code "subreg,reg,mem,const_int,const_double")
 153 {
 154   if (register_operand (op, mode))
 155     return 1;
 156
 157   if (op == CONST0_RTX (mode))
 158     return 1;
 159
 160   if (GET_CODE (op) == SUBREG)
 161     op = SUBREG_REG (op);
 162
 163   if (GET_CODE (op) != MEM)
 164     return 0;
 165
 166   /* Until problems with management of the REG_POINTER flag are resolved,
 167      we need to delay creating move insns with unscaled indexed addresses
 168      until CSE is not expected.  */
 169   if (!TARGET_NO_SPACE_REGS
 170       && !cse_not_expected
 171       && GET_CODE (XEXP (op, 0)) == PLUS
 172       && REG_P (XEXP (XEXP (op, 0), 0))
 173       && REG_P (XEXP (XEXP (op, 0), 1)))
 174     return 0;
 175
 176   return (!symbolic_memory_operand (op, mode)
 177           && memory_address_p (mode, XEXP (op, 0)));
 178 })
 179
 180 ;; Accept anything that can be used as a destination operand for a
 181 ;; move instruction.  We don't accept indexed memory operands since
 182 ;; they are supported only for floating point stores.
 183
 184 (define_predicate "move_dest_operand"
 185   (match_code "subreg,reg,mem")
 186 {
 187   if (register_operand (op, mode))
 188     return 1;
 189
 190   if (GET_MODE (op) != mode)
 191     return 0;
 192
 193   if (GET_CODE (op) == SUBREG)
 194     op = SUBREG_REG (op);
 195
 196   if (GET_CODE (op) != MEM || symbolic_memory_operand (op, mode))
 197     return 0;
 198
 199   op = XEXP (op, 0);
 200
 201   return (memory_address_p (mode, op)
 202           && !IS_INDEX_ADDR_P (op)
 203           && !IS_LO_SUM_DLT_ADDR_P (op));
 204 })
 205
 206 ;; Accept anything that can be used as a source operand for a move
 207 ;; instruction.
 208
 209 (define_predicate "move_src_operand"
 210   (match_code "subreg,reg,const_int,mem")
 211 {
 212   if (register_operand (op, mode))
 213     return 1;
 214
 215   if (GET_CODE (op) == CONST_INT)
 216     return cint_ok_for_move (INTVAL (op));
 217
 218   if (GET_MODE (op) != mode)
 219     return 0;
 220
 221   if (GET_CODE (op) == SUBREG)
 222     op = SUBREG_REG (op);
 223
 224   if (GET_CODE (op) != MEM)
 225     return 0;
 226
 227   /* Until problems with management of the REG_POINTER flag are resolved,
 228      we need to delay creating move insns with unscaled indexed addresses
 229      until CSE is not expected.  */
 230   if (!TARGET_NO_SPACE_REGS
 231       && !cse_not_expected
 232       && GET_CODE (XEXP (op, 0)) == PLUS
 233       && REG_P (XEXP (XEXP (op, 0), 0))
 234       && REG_P (XEXP (XEXP (op, 0), 1)))
 235     return 0;
 236
 237   return memory_address_p (mode, XEXP (op, 0));
 238 })
 239
 240 ;; Accept anything that can be used as the source operand for a
 241 ;; prefetch instruction with a cache-control completer.
 242
 243 (define_predicate "prefetch_cc_operand"
 244   (match_code "mem")
 245 {
 246   if (GET_CODE (op) != MEM)
 247     return 0;
 248
 249   op = XEXP (op, 0);
 250
 251   /* We must reject virtual registers as we don't allow REG+D.  */
 252   if (op == virtual_incoming_args_rtx
 253       || op == virtual_stack_vars_rtx
 254       || op == virtual_stack_dynamic_rtx
 255       || op == virtual_outgoing_args_rtx
 256       || op == virtual_cfa_rtx)
 257     return 0;
 258
 259   if (!REG_P (op) && !IS_INDEX_ADDR_P (op))
 260     return 0;
 261
 262   /* Until problems with management of the REG_POINTER flag are resolved,
 263      we need to delay creating prefetch insns with unscaled indexed addresses
 264      until CSE is not expected.  */
 265   if (!TARGET_NO_SPACE_REGS
 266       && !cse_not_expected
 267       && GET_CODE (op) == PLUS
 268       && REG_P (XEXP (op, 0)))
 269     return 0;
 270
 271   return memory_address_p (mode, op);
 272 })
 273
 274 ;; Accept anything that can be used as the source operand for a
 275 ;; prefetch instruction with no cache-control completer.
 276
 277 (define_predicate "prefetch_nocc_operand"
 278   (match_code "mem")
 279 {
 280   if (GET_CODE (op) != MEM)
 281     return 0;
 282
 283   op = XEXP (op, 0);
 284
 285   /* Until problems with management of the REG_POINTER flag are resolved,
 286      we need to delay creating prefetch insns with unscaled indexed addresses
 287      until CSE is not expected.  */
 288   if (!TARGET_NO_SPACE_REGS
 289       && !cse_not_expected
 290       && GET_CODE (op) == PLUS
 291       && REG_P (XEXP (op, 0))
 292       && REG_P (XEXP (op, 1)))
 293     return 0;
 294
 295   return memory_address_p (mode, op);
 296 })
 297
 298 ;; Accept REG and any CONST_INT that can be moved in one instruction
 299 ;; into a general register.
 300
 301 (define_predicate "reg_or_cint_move_operand"
 302   (match_code "subreg,reg,const_int")
 303 {
 304   if (register_operand (op, mode))
 305     return 1;
 306
 307   return (GET_CODE (op) == CONST_INT && cint_ok_for_move (INTVAL (op)));
 308 })
 309
 310 ;; TODO: Add a comment here.
 311
 312 (define_predicate "pic_label_operand"
 313   (match_code "label_ref,const")
 314 {
 315   if (!flag_pic)
 316     return 0;
 317
 318   switch (GET_CODE (op))
 319     {
 320     case LABEL_REF:
 321       return 1;
 322     case CONST:
 323       op = XEXP (op, 0);
 324       return (GET_CODE (XEXP (op, 0)) == LABEL_REF
 325               && GET_CODE (XEXP (op, 1)) == CONST_INT);
 326     default:
 327       return 0;
 328     }
 329 })
 330
 331 ;; TODO: Add a comment here.
 332
 333 (define_predicate "fp_reg_operand"
 334   (match_code "reg")
 335 {
 336   return reg_renumber && FP_REG_P (op);
 337 })
 338
 339 ;; Return truth value of whether OP can be used as an operand in a
 340 ;; three operand arithmetic insn that accepts registers of mode MODE
 341 ;; or 14-bit signed integers.
 342
 343 (define_predicate "arith_operand"
 344   (match_code "subreg,reg,const_int")
 345 {
 346   return (register_operand (op, mode)
 347           || (GET_CODE (op) == CONST_INT && INT_14_BITS (op)));
 348 })
 349
 350 ;; Return truth value of whether OP can be used as an operand in a
 351 ;; three operand arithmetic insn that accepts registers of mode MODE
 352 ;; or 11-bit signed integers.
 353
 354 (define_predicate "arith11_operand"
 355   (match_code "subreg,reg,const_int")
 356 {
 357   return (register_operand (op, mode)
 358           || (GET_CODE (op) == CONST_INT && INT_11_BITS (op)));
 359 })
 360
 361 ;; A constant integer suitable for use in a PRE_MODIFY memory
 362 ;; reference.
 363
 364 (define_predicate "pre_cint_operand"
 365   (match_code "const_int")
 366 {
 367   return (GET_CODE (op) == CONST_INT
 368           && INTVAL (op) >= -0x2000 && INTVAL (op) < 0x10);
 369 })
 370
 371 ;; A constant integer suitable for use in a POST_MODIFY memory
 372 ;; reference.
 373
 374 (define_predicate "post_cint_operand"
 375   (match_code "const_int")
 376 {
 377   return (GET_CODE (op) == CONST_INT
 378           && INTVAL (op) < 0x2000 && INTVAL (op) >= -0x10);
 379 })
 380
 381 ;; TODO: Add a comment here.
 382
 383 (define_predicate "arith_double_operand"
 384   (match_code "subreg,reg,const_double")
 385 {
 386   return (register_operand (op, mode)
 387           || (GET_CODE (op) == CONST_DOUBLE
 388               && GET_MODE (op) == mode
 389               && VAL_14_BITS_P (CONST_DOUBLE_LOW (op))
 390               && ((CONST_DOUBLE_HIGH (op) >= 0)
 391                   == ((CONST_DOUBLE_LOW (op) & 0x1000) == 0))));
 392 })
 393
 394 ;; Return truth value of whether OP is an integer which fits the range
 395 ;; constraining immediate operands in three-address insns, or is an
 396 ;; integer register.
 397
 398 (define_predicate "ireg_or_int5_operand"
 399   (match_code "const_int,reg")
 400 {
 401   return ((GET_CODE (op) == CONST_INT && INT_5_BITS (op))
 402           || (GET_CODE (op) == REG && REGNO (op) > 0 && REGNO (op) < 32));
 403 })
 404
 405 ;; Return truth value of whether OP is an integer which fits the range
 406 ;; constraining immediate operands in three-address insns.
 407
 408 (define_predicate "int5_operand"
 409   (match_code "const_int")
 410 {
 411   return (GET_CODE (op) == CONST_INT && INT_5_BITS (op));
 412 })
 413
 414 ;; Return truth value of whether OP is an integer which fits the range
 415 ;; constraining immediate operands in three-address insns.
 416
 417 (define_predicate "uint5_operand"
 418   (match_code "const_int")
 419 {
 420   return (GET_CODE (op) == CONST_INT && INT_U5_BITS (op));
 421 })
 422
 423 ;; Return truth value of whether OP is an integer which fits the range
 424 ;; constraining immediate operands in three-address insns.
 425
 426 (define_predicate "int11_operand"
 427   (match_code "const_int")
 428 {
 429   return (GET_CODE (op) == CONST_INT && INT_11_BITS (op));
 430 })
 431
 432 ;; Return truth value of whether OP is an integer which fits the range
 433 ;; constraining immediate operands in three-address insns.
 434
 435 (define_predicate "uint32_operand"
 436   (match_code "const_int,const_double")
 437 {
 438 #if HOST_BITS_PER_WIDE_INT > 32
 439   /* All allowed constants will fit a CONST_INT.  */
 440   return (GET_CODE (op) == CONST_INT
 441           && (INTVAL (op) >= 0 && INTVAL (op) < (HOST_WIDE_INT) 1 << 32));
 442 #else
 443   return (GET_CODE (op) == CONST_INT
 444           || (GET_CODE (op) == CONST_DOUBLE
 445               && CONST_DOUBLE_HIGH (op) == 0));
 446 #endif
 447 })
 448
 449 ;; Return truth value of whether OP is an integer which fits the range
 450 ;; constraining immediate operands in three-address insns.
 451
 452 (define_predicate "arith5_operand"
 453   (match_code "subreg,reg,const_int")
 454 {
 455   return register_operand (op, mode) || int5_operand (op, mode);
 456 })
 457
 458 ;; True iff depi or extru can be used to compute (reg & OP).
 459
 460 (define_predicate "and_operand"
 461   (match_code "subreg,reg,const_int")
 462 {
 463   return (register_operand (op, mode)
 464           || (GET_CODE (op) == CONST_INT && and_mask_p (INTVAL (op))));
 465 })
 466
 467 ;; True iff depi can be used to compute (reg | OP).
 468
 469 (define_predicate "ior_operand"
 470   (match_code "const_int")
 471 {
 472   return (GET_CODE (op) == CONST_INT && ior_mask_p (INTVAL (op)));
 473 })
 474
 475 ;; True iff OP is a CONST_INT of the forms 0...0xxxx or
 476 ;; 0...01...1xxxx. Such values can be the left hand side x in (x <<
 477 ;; r), using the zvdepi instruction.
 478
 479 (define_predicate "lhs_lshift_cint_operand"
 480   (match_code "const_int")
 481 {
 482   unsigned HOST_WIDE_INT x;
 483   if (GET_CODE (op) != CONST_INT)
 484     return 0;
 485   x = INTVAL (op) >> 4;
 486   return (x & (x + 1)) == 0;
 487 })
 488
 489 ;; TODO: Add a comment here.
 490
 491 (define_predicate "lhs_lshift_operand"
 492   (match_code "subreg,reg,const_int")
 493 {
 494   return register_operand (op, mode) || lhs_lshift_cint_operand (op, mode);
 495 })
 496
 497 ;; TODO: Add a comment here.
 498
 499 (define_predicate "arith32_operand"
 500   (match_code "subreg,reg,const_int")
 501 {
 502   return register_operand (op, mode) || GET_CODE (op) == CONST_INT;
 503 })
 504
 505 ;; TODO: Add a comment here.
 506
 507 (define_predicate "pc_or_label_operand"
 508   (match_code "pc,label_ref")
 509 {
 510   return (GET_CODE (op) == PC || GET_CODE (op) == LABEL_REF);
 511 })
 512
 513 ;; TODO: Add a comment here.
 514
 515 (define_predicate "plus_xor_ior_operator"
 516   (match_code "plus,xor,ior")
 517 {
 518   return (GET_CODE (op) == PLUS || GET_CODE (op) == XOR
 519           || GET_CODE (op) == IOR);
 520 })
 521
 522 ;; Return 1 if OP is a CONST_INT with the value 2, 4, or 8.  These are
 523 ;; the valid constant for shadd instructions.
 524
 525 (define_predicate "shadd_operand"
 526   (match_code "const_int")
 527 {
 528   return (GET_CODE (op) == CONST_INT && shadd_constant_p (INTVAL (op)));
 529 })
 530
 531 ;; TODO: Add a comment here.
 532
 533 (define_predicate "div_operand"
 534   (match_code "reg,const_int")
 535 {
 536   return (mode == SImode
 537           && ((GET_CODE (op) == REG && REGNO (op) == 25)
 538               || (GET_CODE (op) == CONST_INT && INTVAL (op) > 0
 539                   && INTVAL (op) < 16 && magic_milli[INTVAL (op)])));
 540 })
 541
 542 ;; Return nonzero if OP is an integer register, else return zero.
 543
 544 (define_predicate "ireg_operand"
 545   (match_code "reg")
 546 {
 547   return (GET_CODE (op) == REG && REGNO (op) > 0 && REGNO (op) < 32);
 548 })
 549
 550 ;; Return 1 if this is a comparison operator.  This allows the use of
 551 ;; MATCH_OPERATOR to recognize all the branch insns.
 552
 553 (define_predicate "cmpib_comparison_operator"
 554   (match_code "eq,ne,lt,le,leu,gt,gtu,ge")
 555 {
 556   return ((mode == VOIDmode || GET_MODE (op) == mode)
 557           && (GET_CODE (op) == EQ
 558               || GET_CODE (op) == NE
 559               || GET_CODE (op) == GT
 560               || GET_CODE (op) == GTU
 561               || GET_CODE (op) == GE
 562               || GET_CODE (op) == LT
 563               || GET_CODE (op) == LE
 564               || GET_CODE (op) == LEU));
 565 })
 566
 567 ;; Return 1 if OP is an operator suitable for use in a movb
 568 ;; instruction.
 569
 570 (define_predicate "movb_comparison_operator"
 571   (match_code "eq,ne,lt,ge")
 572 {
 573   return (GET_CODE (op) == EQ || GET_CODE (op) == NE
 574           || GET_CODE (op) == LT || GET_CODE (op) == GE);
 575 })