gnu/dist/gcc4/gcc/config/sh/predicates.md

   1 ;; Predicate definitions for Renesas / SuperH SH.
   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 ;; TODO: Add a comment here.
  22
  23 (define_predicate "trapping_target_operand"
  24   (match_code "if_then_else")
  25 {
  26   rtx cond, mem, res, tar, and;
  27
  28   if (GET_MODE (op) != PDImode)
  29     return 0;
  30   cond = XEXP (op, 0);
  31   mem = XEXP (op, 1);
  32   res = XEXP (op, 2);
  33   if (GET_CODE (mem) != MEM
  34       || (GET_CODE (res) != SIGN_EXTEND && GET_CODE (res) != TRUNCATE))
  35     return 0;
  36   tar = XEXP (res, 0);
  37   if (!rtx_equal_p (XEXP (mem, 0), tar)
  38       || GET_MODE (tar) != Pmode)
  39     return 0;
  40   if (GET_CODE (cond) == CONST)
  41     {
  42       cond = XEXP (cond, 0);
  43       if (!EXTRA_CONSTRAINT_Csy (tar))
  44         return 0;
  45       if (GET_CODE (tar) == CONST)
  46         tar = XEXP (tar, 0);
  47     }
  48   else if (!arith_reg_operand (tar, VOIDmode)
  49            && ! EXTRA_CONSTRAINT_Csy (tar))
  50     return 0;
  51   if (GET_CODE (cond) != EQ)
  52     return 0;
  53   and = XEXP (cond, 0);
  54   return (GET_CODE (and) == AND
  55           && rtx_equal_p (XEXP (and, 0), tar)
  56           && GET_CODE (XEXP (and, 1)) == CONST_INT
  57           && GET_CODE (XEXP (cond, 1)) == CONST_INT
  58           && INTVAL (XEXP (and, 1)) == 3
  59           && INTVAL (XEXP (cond, 1)) == 3);
  60 })
  61
  62 ;; TODO: Add a comment here.
  63
  64 (define_predicate "and_operand"
  65   (match_code "subreg,reg,const_int")
  66 {
  67   if (logical_operand (op, mode))
  68     return 1;
  69
  70   /* Check mshflo.l / mshflhi.l opportunities.  */
  71   if (TARGET_SHMEDIA
  72       && mode == DImode
  73       && GET_CODE (op) == CONST_INT
  74       && CONST_OK_FOR_J16 (INTVAL (op)))
  75     return 1;
  76
  77   return 0;
  78 })
  79
  80 ;; Like arith_reg_dest, but this predicate is defined with
  81 ;; define_special_predicate, not define_predicate.
  82
  83 (define_special_predicate "any_arith_reg_dest"
  84   (match_code "subreg,reg")
  85 {
  86   return arith_reg_dest (op, mode);
  87 })
  88
  89 ;; Like register_operand, but this predicate is defined with
  90 ;; define_special_predicate, not define_predicate.
  91
  92 (define_special_predicate "any_register_operand"
  93   (match_code "subreg,reg")
  94 {
  95   return register_operand (op, mode);
  96 })
  97
  98 ;; Returns 1 if OP is a valid source operand for an arithmetic insn.
  99
 100 (define_predicate "arith_operand"
 101   (match_code "subreg,reg,const_int,truncate")
 102 {
 103   if (arith_reg_operand (op, mode))
 104     return 1;
 105
 106   if (TARGET_SHMEDIA)
 107     {
 108       /* FIXME: We should be checking whether the CONST_INT fits in a
 109          CONST_OK_FOR_I16 here, but this causes reload_cse to crash when
 110          attempting to transform a sequence of two 64-bit sets of the
 111          same register from literal constants into a set and an add,
 112          when the difference is too wide for an add.  */
 113       if (GET_CODE (op) == CONST_INT
 114           || EXTRA_CONSTRAINT_C16 (op))
 115         return 1;
 116       else if (GET_CODE (op) == TRUNCATE
 117                && ! system_reg_operand (XEXP (op, 0), VOIDmode)
 118                && (mode == VOIDmode || mode == GET_MODE (op))
 119                && (GET_MODE_SIZE (GET_MODE (op))
 120                    < GET_MODE_SIZE (GET_MODE (XEXP (op, 0))))
 121                && (! FP_REGISTER_P (REGNO (XEXP (op, 0)))
 122                    || GET_MODE_SIZE (GET_MODE (op)) == 4))
 123         return register_operand (XEXP (op, 0), VOIDmode);
 124       else
 125         return 0;
 126     }
 127   else if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_I08 (INTVAL (op)))
 128     return 1;
 129
 130   return 0;
 131 })
 132
 133 ;; Like above, but for DImode destinations: forbid paradoxical DImode
 134 ;; subregs, because this would lead to missing sign extensions when
 135 ;; truncating from DImode to SImode.
 136
 137 (define_predicate "arith_reg_dest"
 138   (match_code "subreg,reg")
 139 {
 140   if (mode == DImode && GET_CODE (op) == SUBREG
 141       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))) < 8
 142       && TARGET_SHMEDIA)
 143     return 0;
 144   return arith_reg_operand (op, mode);
 145 })
 146
 147 ;; Returns 1 if OP is a normal arithmetic register.
 148
 149 (define_predicate "arith_reg_operand"
 150   (match_code "subreg,reg,sign_extend")
 151 {
 152   if (register_operand (op, mode))
 153     {
 154       int regno;
 155
 156       if (GET_CODE (op) == REG)
 157         regno = REGNO (op);
 158       else if (GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == REG)
 159         regno = REGNO (SUBREG_REG (op));
 160       else
 161         return 1;
 162
 163       return (regno != T_REG && regno != PR_REG
 164               && ! TARGET_REGISTER_P (regno)
 165               && (regno != FPUL_REG || TARGET_SH4)
 166               && regno != MACH_REG && regno != MACL_REG);
 167     }
 168   /* Allow a no-op sign extension - compare LOAD_EXTEND_OP.
 169      We allow SImode here, as not using an FP register is just a matter of
 170      proper register allocation.  */
 171   if (TARGET_SHMEDIA
 172       && GET_MODE (op) == DImode && GET_CODE (op) == SIGN_EXTEND
 173       && GET_MODE (XEXP (op, 0)) == SImode
 174       && GET_CODE (XEXP (op, 0)) != SUBREG)
 175     return register_operand (XEXP (op, 0), VOIDmode);
 176 #if 0 /* Can't do this because of PROMOTE_MODE for unsigned vars.  */
 177   if (GET_MODE (op) == SImode && GET_CODE (op) == SIGN_EXTEND
 178       && GET_MODE (XEXP (op, 0)) == HImode
 179       && GET_CODE (XEXP (op, 0)) == REG
 180       && REGNO (XEXP (op, 0)) <= LAST_GENERAL_REG)
 181     return register_operand (XEXP (op, 0), VOIDmode);
 182 #endif
 183   if (GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_INT
 184       && GET_CODE (op) == SUBREG
 185       && GET_MODE (SUBREG_REG (op)) == DImode
 186       && GET_CODE (SUBREG_REG (op)) == SIGN_EXTEND
 187       && GET_MODE (XEXP (SUBREG_REG (op), 0)) == SImode
 188       && GET_CODE (XEXP (SUBREG_REG (op), 0)) != SUBREG)
 189     return register_operand (XEXP (SUBREG_REG (op), 0), VOIDmode);
 190   return 0;
 191 })
 192
 193 ;; Returns 1 if OP is a valid source operand for a compare insn.
 194
 195 (define_predicate "arith_reg_or_0_operand"
 196   (match_code "subreg,reg,const_int,const_vector")
 197 {
 198   if (arith_reg_operand (op, mode))
 199     return 1;
 200
 201   if (EXTRA_CONSTRAINT_Z (op))
 202     return 1;
 203
 204   return 0;
 205 })
 206
 207 ;; TODO: Add a comment here.
 208
 209 (define_predicate "binary_float_operator"
 210   (match_code "plus,minus,mult,div")
 211 {
 212   if (GET_MODE (op) != mode)
 213     return 0;
 214   switch (GET_CODE (op))
 215     {
 216     case PLUS:
 217     case MINUS:
 218     case MULT:
 219     case DIV:
 220       return 1;
 221     default:
 222       break;
 223     }
 224   return 0;
 225 })
 226
 227 ;; TODO: Add a comment here.
 228
 229 (define_predicate "binary_logical_operator"
 230   (match_code "and,ior,xor")
 231 {
 232   if (GET_MODE (op) != mode)
 233     return 0;
 234   switch (GET_CODE (op))
 235     {
 236     case IOR:
 237     case AND:
 238     case XOR:
 239       return 1;
 240     default:
 241       break;
 242     }
 243   return 0;
 244 })
 245
 246 ;; TODO: Add a comment here.
 247
 248 (define_predicate "cache_address_operand"
 249   (match_code "plus,reg")
 250 {
 251   if (GET_CODE (op) == PLUS)
 252     {
 253       if (GET_CODE (XEXP (op, 0)) != REG)
 254         return 0;
 255       if (GET_CODE (XEXP (op, 1)) != CONST_INT
 256           || (INTVAL (XEXP (op, 1)) & 31))
 257         return 0;
 258     }
 259   else if (GET_CODE (op) != REG)
 260     return 0;
 261   return address_operand (op, mode);
 262 })
 263
 264 ;; Return 1 if OP is a valid source operand for shmedia cmpgt / cmpgtu.
 265
 266 (define_predicate "cmp_operand"
 267   (match_code "subreg,reg,const_int")
 268 {
 269   if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_N (INTVAL (op)))
 270     return 1;
 271   if (TARGET_SHMEDIA
 272       && mode != DImode && GET_CODE (op) == SUBREG
 273       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))) > 4)
 274     return 0;
 275   return arith_reg_operand (op, mode);
 276 })
 277
 278 ;; TODO: Add a comment here.
 279
 280 (define_predicate "cmpsi_operand"
 281   (match_code "subreg,reg,const_int")
 282 {
 283   if (GET_CODE (op) == REG && REGNO (op) == T_REG
 284       && GET_MODE (op) == SImode
 285       && TARGET_SH1)
 286     return 1;
 287   return arith_operand (op, mode);
 288 })
 289
 290 ;; TODO: Add a comment here.
 291
 292 (define_predicate "commutative_float_operator"
 293   (match_code "plus,mult")
 294 {
 295   if (GET_MODE (op) != mode)
 296     return 0;
 297   switch (GET_CODE (op))
 298     {
 299     case PLUS:
 300     case MULT:
 301       return 1;
 302     default:
 303       break;
 304     }
 305   return 0;
 306 })
 307
 308 ;; TODO: Add a comment here.
 309
 310 (define_predicate "equality_comparison_operator"
 311   (match_code "eq,ne")
 312 {
 313   return ((mode == VOIDmode || GET_MODE (op) == mode)
 314           && (GET_CODE (op) == EQ || GET_CODE (op) == NE));
 315 })
 316
 317 ;; TODO: Add a comment here.
 318
 319 (define_predicate "extend_reg_operand"
 320   (match_code "subreg,reg,truncate")
 321 {
 322   return (GET_CODE (op) == TRUNCATE
 323           ? arith_operand
 324           : arith_reg_operand) (op, mode);
 325 })
 326
 327 ;; TODO: Add a comment here.
 328
 329 (define_predicate "extend_reg_or_0_operand"
 330   (match_code "subreg,reg,truncate,const_int")
 331 {
 332   return (GET_CODE (op) == TRUNCATE
 333           ? arith_operand
 334           : arith_reg_or_0_operand) (op, mode);
 335 })
 336
 337 ;; Like arith_reg_operand, but this predicate does not accept SIGN_EXTEND.
 338
 339 (define_predicate "ext_dest_operand"
 340   (match_code "subreg,reg")
 341 {
 342   return arith_reg_operand (op, mode);
 343 })
 344
 345 ;; TODO: Add a comment here.
 346
 347 (define_predicate "fp_arith_reg_dest"
 348   (match_code "subreg,reg")
 349 {
 350   if (mode == DImode && GET_CODE (op) == SUBREG
 351       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))) < 8)
 352     return 0;
 353   return fp_arith_reg_operand (op, mode);
 354 })
 355
 356 ;; TODO: Add a comment here.
 357
 358 (define_predicate "fp_arith_reg_operand"
 359   (match_code "subreg,reg")
 360 {
 361   if (register_operand (op, mode))
 362     {
 363       int regno;
 364
 365       if (GET_CODE (op) == REG)
 366         regno = REGNO (op);
 367       else if (GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == REG)
 368         regno = REGNO (SUBREG_REG (op));
 369       else
 370         return 1;
 371
 372       return (regno >= FIRST_PSEUDO_REGISTER
 373               || FP_REGISTER_P (regno));
 374     }
 375   return 0;
 376 })
 377
 378 ;; TODO: Add a comment here.
 379
 380 (define_predicate "fpscr_operand"
 381   (match_code "reg")
 382 {
 383   return (GET_CODE (op) == REG
 384           && (REGNO (op) == FPSCR_REG
 385               || (REGNO (op) >= FIRST_PSEUDO_REGISTER
 386                   && !(reload_in_progress || reload_completed)))
 387           && GET_MODE (op) == PSImode);
 388 })
 389
 390 ;; TODO: Add a comment here.
 391
 392 (define_predicate "fpul_operand"
 393   (match_code "reg")
 394 {
 395   if (TARGET_SHMEDIA)
 396     return fp_arith_reg_operand (op, mode);
 397
 398   return (GET_CODE (op) == REG
 399           && (REGNO (op) == FPUL_REG || REGNO (op) >= FIRST_PSEUDO_REGISTER)
 400           && GET_MODE (op) == mode);
 401 })
 402
 403 ;; TODO: Add a comment here.
 404
 405 (define_predicate "general_extend_operand"
 406   (match_code "subreg,reg,mem,truncate")
 407 {
 408   return (GET_CODE (op) == TRUNCATE
 409           ? arith_operand
 410           : nonimmediate_operand) (op, mode);
 411 })
 412
 413 ;; Returns 1 if OP can be source of a simple move operation. Same as
 414 ;; general_operand, but a LABEL_REF is valid, PRE_DEC is invalid as
 415 ;; are subregs of system registers.
 416
 417 (define_predicate "general_movsrc_operand"
 418   (match_code "subreg,reg,const_int,const_double,mem,symbol_ref,label_ref,const,const_vector")
 419 {
 420   if (GET_CODE (op) == MEM)
 421     {
 422       rtx inside = XEXP (op, 0);
 423       if (GET_CODE (inside) == CONST)
 424         inside = XEXP (inside, 0);
 425
 426       if (GET_CODE (inside) == LABEL_REF)
 427         return 1;
 428
 429       if (GET_CODE (inside) == PLUS
 430           && GET_CODE (XEXP (inside, 0)) == LABEL_REF
 431           && GET_CODE (XEXP (inside, 1)) == CONST_INT)
 432         return 1;
 433
 434       /* Only post inc allowed.  */
 435       if (GET_CODE (inside) == PRE_DEC)
 436         return 0;
 437     }
 438
 439   if ((mode == QImode || mode == HImode)
 440       && (GET_CODE (op) == SUBREG
 441           && GET_CODE (XEXP (op, 0)) == REG
 442           && system_reg_operand (XEXP (op, 0), mode)))
 443     return 0;
 444
 445   if (TARGET_SHMEDIA
 446       && (GET_CODE (op) == PARALLEL || GET_CODE (op) == CONST_VECTOR)
 447       && sh_rep_vec (op, mode))
 448     return 1;
 449   if (TARGET_SHMEDIA && 1
 450       && GET_CODE (op) == SUBREG && GET_MODE (op) == mode
 451       && SUBREG_REG (op) == const0_rtx && subreg_lowpart_p (op))
 452     /* FIXME */ abort (); /* return 1; */
 453   return general_operand (op, mode);
 454 })
 455
 456 ;; Returns 1 if OP can be a destination of a move. Same as
 457 ;; general_operand, but no preinc allowed.
 458
 459 (define_predicate "general_movdst_operand"
 460   (match_code "subreg,reg,mem")
 461 {
 462   /* Only pre dec allowed.  */
 463   if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == POST_INC)
 464     return 0;
 465   if (mode == DImode && TARGET_SHMEDIA && GET_CODE (op) == SUBREG
 466       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))) < 8
 467       && ! (high_life_started || reload_completed))
 468     return 0;
 469
 470   return general_operand (op, mode);
 471 })
 472
 473 ;; Returns 1 if OP is a MEM that can be source of a simple move operation.
 474
 475 (define_predicate "unaligned_load_operand"
 476   (match_code "mem")
 477 {
 478   rtx inside;
 479
 480   if (GET_CODE (op) != MEM || GET_MODE (op) != mode)
 481     return 0;
 482
 483   inside = XEXP (op, 0);
 484
 485   if (GET_CODE (inside) == POST_INC)
 486     inside = XEXP (inside, 0);
 487
 488   if (GET_CODE (inside) == REG)
 489     return 1;
 490
 491   return 0;
 492 })
 493
 494 ;; TODO: Add a comment here.
 495
 496 (define_predicate "greater_comparison_operator"
 497   (match_code "gt,ge,gtu,geu")
 498 {
 499   if (mode != VOIDmode && GET_MODE (op) != mode)
 500     return 0;
 501   switch (GET_CODE (op))
 502     {
 503     case GT:
 504     case GE:
 505     case GTU:
 506     case GEU:
 507       return 1;
 508     default:
 509       return 0;
 510     }
 511 })
 512
 513 ;; TODO: Add a comment here.
 514
 515 (define_predicate "inqhi_operand"
 516   (match_code "truncate")
 517 {
 518   if (GET_CODE (op) != TRUNCATE || mode != GET_MODE (op))
 519     return 0;
 520   op = XEXP (op, 0);
 521   /* Can't use true_regnum here because copy_cost wants to know about
 522      SECONDARY_INPUT_RELOAD_CLASS.  */
 523   return GET_CODE (op) == REG && FP_REGISTER_P (REGNO (op));
 524 })
 525
 526 ;; TODO: Add a comment here.
 527
 528 (define_special_predicate "int_gpr_dest"
 529   (match_code "subreg,reg")
 530 {
 531   enum machine_mode op_mode = GET_MODE (op);
 532
 533   if (GET_MODE_CLASS (op_mode) != MODE_INT
 534       || GET_MODE_SIZE (op_mode) >= UNITS_PER_WORD)
 535     return 0;
 536   if (! reload_completed)
 537     return 0;
 538   return true_regnum (op) <= LAST_GENERAL_REG;
 539 })
 540
 541 ;; TODO: Add a comment here.
 542
 543 (define_predicate "less_comparison_operator"
 544   (match_code "lt,le,ltu,leu")
 545 {
 546   if (mode != VOIDmode && GET_MODE (op) != mode)
 547     return 0;
 548   switch (GET_CODE (op))
 549     {
 550     case LT:
 551     case LE:
 552     case LTU:
 553     case LEU:
 554       return 1;
 555     default:
 556       return 0;
 557     }
 558 })
 559
 560 ;; Returns 1 if OP is a valid source operand for a logical operation.
 561
 562 (define_predicate "logical_operand"
 563   (match_code "subreg,reg,const_int")
 564 {
 565   if (TARGET_SHMEDIA
 566       && mode != DImode && GET_CODE (op) == SUBREG
 567       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))) > 4)
 568     return 0;
 569
 570   if (arith_reg_operand (op, mode))
 571     return 1;
 572
 573   if (TARGET_SHMEDIA)
 574     {
 575       if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_I10 (INTVAL (op)))
 576         return 1;
 577       else
 578         return 0;
 579     }
 580   else if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_K08 (INTVAL (op)))
 581     return 1;
 582
 583   return 0;
 584 })
 585
 586 ;; TODO: Add a comment here.
 587
 588 (define_predicate "logical_operator"
 589   (match_code "and,ior,xor")
 590 {
 591   if (mode != VOIDmode && GET_MODE (op) != mode)
 592     return 0;
 593   switch (GET_CODE (op))
 594     {
 595     case AND:
 596     case IOR:
 597     case XOR:
 598       return 1;
 599     default:
 600       return 0;
 601     }
 602 })
 603
 604 ;; Like arith_reg_operand, but for register source operands of narrow
 605 ;; logical SHMEDIA operations: forbid subregs of DImode / TImode regs.
 606
 607 (define_predicate "logical_reg_operand"
 608   (match_code "subreg,reg")
 609 {
 610   if (TARGET_SHMEDIA
 611       && GET_CODE (op) == SUBREG
 612       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))) > 4
 613       && mode != DImode)
 614     return 0;
 615   return arith_reg_operand (op, mode);
 616 })
 617
 618 ;; TODO: Add a comment here.
 619
 620 (define_predicate "mextr_bit_offset"
 621   (match_code "const_int")
 622 {
 623   HOST_WIDE_INT i;
 624
 625   if (GET_CODE (op) != CONST_INT)
 626     return 0;
 627   i = INTVAL (op);
 628   return i >= 1 * 8 && i <= 7 * 8 && (i & 7) == 0;
 629 })
 630
 631 ;; TODO: Add a comment here.
 632
 633 (define_predicate "minuend_operand"
 634   (match_code "subreg,reg,truncate,const_int")
 635 {
 636   return op == constm1_rtx || extend_reg_or_0_operand (op, mode);
 637 })
 638
 639 ;; TODO: Add a comment here.
 640
 641 (define_predicate "noncommutative_float_operator"
 642   (match_code "minus,div")
 643 {
 644   if (GET_MODE (op) != mode)
 645     return 0;
 646   switch (GET_CODE (op))
 647     {
 648     case MINUS:
 649     case DIV:
 650       return 1;
 651     default:
 652       break;
 653     }
 654   return 0;
 655 })
 656
 657 ;; TODO: Add a comment here.
 658
 659 (define_predicate "sh_const_vec"
 660   (match_code "const_vector")
 661 {
 662   int i;
 663
 664   if (GET_CODE (op) != CONST_VECTOR
 665       || (GET_MODE (op) != mode && mode != VOIDmode))
 666     return 0;
 667   i = XVECLEN (op, 0) - 1;
 668   for (; i >= 0; i--)
 669     if (GET_CODE (XVECEXP (op, 0, i)) != CONST_INT)
 670       return 0;
 671   return 1;
 672 })
 673
 674 ;; Determine if OP is a constant vector matching MODE with only one
 675 ;; element that is not a sign extension.  Two byte-sized elements
 676 ;; count as one.
 677
 678 (define_predicate "sh_1el_vec"
 679   (match_code "const_vector")
 680 {
 681   int unit_size;
 682   int i, last, least, sign_ix;
 683   rtx sign;
 684
 685   if (GET_CODE (op) != CONST_VECTOR
 686       || (GET_MODE (op) != mode && mode != VOIDmode))
 687     return 0;
 688   /* Determine numbers of last and of least significant elements.  */
 689   last = XVECLEN (op, 0) - 1;
 690   least = TARGET_LITTLE_ENDIAN ? 0 : last;
 691   if (GET_CODE (XVECEXP (op, 0, least)) != CONST_INT)
 692     return 0;
 693   sign_ix = least;
 694   if (GET_MODE_UNIT_SIZE (mode) == 1)
 695     sign_ix = TARGET_LITTLE_ENDIAN ? 1 : last - 1;
 696   if (GET_CODE (XVECEXP (op, 0, sign_ix)) != CONST_INT)
 697     return 0;
 698   unit_size = GET_MODE_UNIT_SIZE (GET_MODE (op));
 699   sign = (INTVAL (XVECEXP (op, 0, sign_ix)) >> (unit_size * BITS_PER_UNIT - 1)
 700           ? constm1_rtx : const0_rtx);
 701   i = XVECLEN (op, 0) - 1;
 702   do
 703     if (i != least && i != sign_ix && XVECEXP (op, 0, i) != sign)
 704       return 0;
 705   while (--i);
 706   return 1;
 707 })
 708
 709 ;; Like register_operand, but take into account that SHMEDIA can use
 710 ;; the constant zero like a general register.
 711
 712 (define_predicate "sh_register_operand"
 713   (match_code "reg,subreg,const_int")
 714 {
 715   if (op == CONST0_RTX (mode) && TARGET_SHMEDIA)
 716     return 1;
 717   return register_operand (op, mode);
 718 })
 719
 720 ;; TODO: Add a comment here.
 721
 722 (define_predicate "sh_rep_vec"
 723   (match_code "const_vector")
 724 {
 725   int i;
 726   rtx x, y;
 727
 728   if ((GET_CODE (op) != CONST_VECTOR && GET_CODE (op) != PARALLEL)
 729       || (GET_MODE (op) != mode && mode != VOIDmode))
 730     return 0;
 731   i = XVECLEN (op, 0) - 2;
 732   x = XVECEXP (op, 0, i + 1);
 733   if (GET_MODE_UNIT_SIZE (mode) == 1)
 734     {
 735       y = XVECEXP (op, 0, i);
 736       for (i -= 2; i >= 0; i -= 2)
 737         if (! rtx_equal_p (XVECEXP (op, 0, i + 1), x)
 738             || ! rtx_equal_p (XVECEXP (op, 0, i), y))
 739           return 0;
 740     }
 741   else
 742     for (; i >= 0; i--)
 743       if (XVECEXP (op, 0, i) != x)
 744         return 0;
 745   return 1;
 746 })
 747
 748 ;; TODO: Add a comment here.
 749
 750 (define_predicate "shift_count_operand"
 751   (match_code "const_int,const_double,const,symbol_ref,label_ref,subreg,reg,zero_extend,sign_extend")
 752 {
 753   return (CONSTANT_P (op)
 754           ? (GET_CODE (op) == CONST_INT
 755              ? (unsigned) INTVAL (op) < GET_MODE_BITSIZE (mode)
 756              : nonmemory_operand (op, mode))
 757           : shift_count_reg_operand (op, mode));
 758 })
 759
 760 ;; TODO: Add a comment here.
 761
 762 (define_predicate "shift_count_reg_operand"
 763   (match_code "subreg,reg,zero_extend,sign_extend")
 764 {
 765   if ((GET_CODE (op) == ZERO_EXTEND || GET_CODE (op) == SIGN_EXTEND
 766        || (GET_CODE (op) == SUBREG && SUBREG_BYTE (op) == 0))
 767       && (mode == VOIDmode || mode == GET_MODE (op))
 768       && GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0))) >= 6
 769       && GET_MODE_CLASS (GET_MODE (XEXP (op, 0))) == MODE_INT)
 770     {
 771       mode = VOIDmode;
 772       do
 773         op = XEXP (op, 0);
 774       while ((GET_CODE (op) == ZERO_EXTEND || GET_CODE (op) == SIGN_EXTEND
 775               || GET_CODE (op) == TRUNCATE)
 776              && GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0))) >= 6
 777              && GET_MODE_CLASS (GET_MODE (XEXP (op, 0))) == MODE_INT);
 778
 779     }
 780   return arith_reg_operand (op, mode);
 781 })
 782
 783 ;; TODO: Add a comment here.
 784
 785 (define_predicate "shift_operator"
 786   (match_code "ashift,ashiftrt,lshiftrt")
 787 {
 788   if (mode != VOIDmode && GET_MODE (op) != mode)
 789     return 0;
 790   switch (GET_CODE (op))
 791     {
 792     case ASHIFT:
 793     case ASHIFTRT:
 794     case LSHIFTRT:
 795       return 1;
 796     default:
 797       return 0;
 798     }
 799 })
 800
 801 ;; TODO: Add a comment here.
 802
 803 (define_predicate "symbol_ref_operand"
 804   (match_code "symbol_ref")
 805 {
 806   return (GET_CODE (op) == SYMBOL_REF);
 807 })
 808
 809 ;; Same as target_reg_operand, except that label_refs and symbol_refs
 810 ;; are accepted before reload.
 811
 812 (define_special_predicate "target_operand"
 813   (match_code "subreg,reg,label_ref,symbol_ref,const,unspec")
 814 {
 815   if (mode != VOIDmode && mode != Pmode)
 816     return 0;
 817
 818   if ((GET_MODE (op) == Pmode || GET_MODE (op) == VOIDmode)
 819       && EXTRA_CONSTRAINT_Csy (op))
 820     return ! reload_completed;
 821
 822   return target_reg_operand (op, mode);
 823 })
 824
 825 ;; Accept pseudos and branch target registers.
 826
 827 (define_special_predicate "target_reg_operand"
 828   (match_code "subreg,reg")
 829 {
 830   if (mode == VOIDmode
 831      ? GET_MODE (op) != Pmode && GET_MODE (op) != PDImode
 832      : mode != GET_MODE (op))
 833     return 0;
 834
 835   if (GET_CODE (op) == SUBREG)
 836     op = XEXP (op, 0);
 837
 838   if (GET_CODE (op) != REG)
 839     return 0;
 840
 841   /* We must protect ourselves from matching pseudos that are virtual
 842      register, because they will eventually be replaced with hardware
 843      registers that aren't branch-target registers.  */
 844   if (REGNO (op) > LAST_VIRTUAL_REGISTER
 845       || TARGET_REGISTER_P (REGNO (op)))
 846     return 1;
 847
 848   return 0;
 849 })
 850
 851 ;; TODO: Add a comment here.
 852
 853 (define_special_predicate "trunc_hi_operand"
 854   (match_code "subreg,reg,truncate")
 855 {
 856   enum machine_mode op_mode = GET_MODE (op);
 857
 858   if (op_mode != SImode && op_mode != DImode
 859       && op_mode != V4HImode && op_mode != V2SImode)
 860     return 0;
 861   return extend_reg_operand (op, mode);
 862 })
 863
 864 ;; TODO: Add a comment here.
 865
 866 (define_predicate "ua_address_operand"
 867   (match_code "subreg,reg,plus")
 868 {
 869   if (GET_CODE (op) == PLUS
 870       && (GET_CODE (XEXP (op, 1)) != CONST_INT
 871           || ! CONST_OK_FOR_I06 (INTVAL (XEXP (op, 1)))))
 872     return 0;
 873   return address_operand (op, QImode);
 874 })
 875
 876 ;; TODO: Add a comment here.
 877
 878 (define_predicate "ua_offset"
 879   (match_code "const_int")
 880 {
 881   return GET_CODE (op) == CONST_INT && CONST_OK_FOR_I06 (INTVAL (op));
 882 })
 883
 884 ;; TODO: Add a comment here.
 885
 886 (define_predicate "unary_float_operator"
 887   (match_code "abs,neg,sqrt")
 888 {
 889   if (GET_MODE (op) != mode)
 890     return 0;
 891   switch (GET_CODE (op))
 892     {
 893     case ABS:
 894     case NEG:
 895     case SQRT:
 896       return 1;
 897     default:
 898       break;
 899     }
 900   return 0;
 901 })
 902
 903 ;; Return 1 if OP is a valid source operand for xor.
 904
 905 (define_predicate "xor_operand"
 906   (match_code "subreg,reg,const_int")
 907 {
 908   if (GET_CODE (op) == CONST_INT)
 909     return (TARGET_SHMEDIA
 910             ? (CONST_OK_FOR_I06 (INTVAL (op))
 911                || (no_new_pseudos && INTVAL (op) == 0xff))
 912             : CONST_OK_FOR_K08 (INTVAL (op)));
 913   if (TARGET_SHMEDIA
 914       && mode != DImode && GET_CODE (op) == SUBREG
 915       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))) > 4)
 916     return 0;
 917   return arith_reg_operand (op, mode);
 918 })