gcc/config/ia64/predicates.md

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