1169689Skan;; Predicate definitions for IA-64. 2169689Skan;; Copyright (C) 2004, 2005 Free Software Foundation, Inc. 3169689Skan;; 4169689Skan;; This file is part of GCC. 5169689Skan;; 6169689Skan;; GCC is free software; you can redistribute it and/or modify 7169689Skan;; it under the terms of the GNU General Public License as published by 8169689Skan;; the Free Software Foundation; either version 2, or (at your option) 9169689Skan;; any later version. 10169689Skan;; 11169689Skan;; GCC is distributed in the hope that it will be useful, 12169689Skan;; but WITHOUT ANY WARRANTY; without even the implied warranty of 13169689Skan;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14169689Skan;; GNU General Public License for more details. 15169689Skan;; 16169689Skan;; You should have received a copy of the GNU General Public License 17169689Skan;; along with GCC; see the file COPYING. If not, write to 18169689Skan;; the Free Software Foundation, 51 Franklin Street, Fifth Floor, 19169689Skan;; Boston, MA 02110-1301, USA. 20169689Skan 21169689Skan;; True if OP is a valid operand for the MEM of a CALL insn. 22169689Skan(define_predicate "call_operand" 23169689Skan (ior (match_code "symbol_ref") 24169689Skan (match_operand 0 "register_operand"))) 25169689Skan 26169689Skan;; True if OP refers to any kind of symbol. 27169689Skan;; For roughly the same reasons that pmode_register_operand exists, this 28169689Skan;; predicate ignores its mode argument. 29169689Skan(define_special_predicate "symbolic_operand" 30169689Skan (match_code "symbol_ref,const,label_ref")) 31169689Skan 32169689Skan;; True if OP is a SYMBOL_REF which refers to a function. 33169689Skan(define_predicate "function_operand" 34169689Skan (and (match_code "symbol_ref") 35169689Skan (match_test "SYMBOL_REF_FUNCTION_P (op)"))) 36169689Skan 37169689Skan;; True if OP refers to a symbol in the sdata section. 38169689Skan(define_predicate "sdata_symbolic_operand" 39169689Skan (match_code "symbol_ref,const") 40169689Skan{ 41169689Skan HOST_WIDE_INT offset = 0, size = 0; 42169689Skan 43169689Skan switch (GET_CODE (op)) 44169689Skan { 45169689Skan case CONST: 46169689Skan op = XEXP (op, 0); 47169689Skan if (GET_CODE (op) != PLUS 48169689Skan || GET_CODE (XEXP (op, 0)) != SYMBOL_REF 49169689Skan || GET_CODE (XEXP (op, 1)) != CONST_INT) 50169689Skan return false; 51169689Skan offset = INTVAL (XEXP (op, 1)); 52169689Skan op = XEXP (op, 0); 53169689Skan /* FALLTHRU */ 54169689Skan 55169689Skan case SYMBOL_REF: 56169689Skan if (CONSTANT_POOL_ADDRESS_P (op)) 57169689Skan { 58169689Skan size = GET_MODE_SIZE (get_pool_mode (op)); 59169689Skan if (size > ia64_section_threshold) 60169689Skan return false; 61169689Skan } 62169689Skan else 63169689Skan { 64169689Skan tree t; 65169689Skan 66169689Skan if (!SYMBOL_REF_LOCAL_P (op) || !SYMBOL_REF_SMALL_P (op)) 67169689Skan return false; 68169689Skan 69169689Skan /* Note that in addition to DECLs, we can get various forms 70169689Skan of constants here. */ 71169689Skan t = SYMBOL_REF_DECL (op); 72169689Skan if (DECL_P (t)) 73169689Skan t = DECL_SIZE_UNIT (t); 74169689Skan else 75169689Skan t = TYPE_SIZE_UNIT (TREE_TYPE (t)); 76169689Skan if (t && host_integerp (t, 0)) 77169689Skan { 78169689Skan size = tree_low_cst (t, 0); 79169689Skan if (size < 0) 80169689Skan size = 0; 81169689Skan } 82169689Skan } 83169689Skan 84169689Skan /* Deny the stupid user trick of addressing outside the object. Such 85169689Skan things quickly result in GPREL22 relocation overflows. Of course, 86169689Skan they're also highly undefined. From a pure pedant's point of view 87169689Skan they deserve a slap on the wrist (such as provided by a relocation 88169689Skan overflow), but that just leads to bugzilla noise. */ 89169689Skan return (offset >= 0 && offset <= size); 90169689Skan 91169689Skan default: 92169689Skan gcc_unreachable (); 93169689Skan } 94169689Skan}) 95169689Skan 96169689Skan;; True if OP refers to a symbol in the small address area. 97169689Skan(define_predicate "small_addr_symbolic_operand" 98169689Skan (match_code "symbol_ref,const") 99169689Skan{ 100169689Skan switch (GET_CODE (op)) 101169689Skan { 102169689Skan case CONST: 103169689Skan op = XEXP (op, 0); 104169689Skan if (GET_CODE (op) != PLUS 105169689Skan || GET_CODE (XEXP (op, 0)) != SYMBOL_REF 106169689Skan || GET_CODE (XEXP (op, 1)) != CONST_INT) 107169689Skan return false; 108169689Skan op = XEXP (op, 0); 109169689Skan /* FALLTHRU */ 110169689Skan 111169689Skan case SYMBOL_REF: 112169689Skan return SYMBOL_REF_SMALL_ADDR_P (op); 113169689Skan 114169689Skan default: 115169689Skan gcc_unreachable (); 116169689Skan } 117169689Skan}) 118169689Skan 119169689Skan;; True if OP refers to a symbol with which we may use any offset. 120169689Skan(define_predicate "any_offset_symbol_operand" 121169689Skan (match_code "symbol_ref") 122169689Skan{ 123169689Skan if (TARGET_NO_PIC || TARGET_AUTO_PIC) 124169689Skan return true; 125169689Skan if (SYMBOL_REF_SMALL_ADDR_P (op)) 126169689Skan return true; 127169689Skan if (SYMBOL_REF_FUNCTION_P (op)) 128169689Skan return false; 129169689Skan if (sdata_symbolic_operand (op, mode)) 130169689Skan return true; 131169689Skan return false; 132169689Skan}) 133169689Skan 134169689Skan;; True if OP refers to a symbol with which we may use 14-bit aligned offsets. 135169689Skan;; False if OP refers to a symbol with which we may not use any offset at any 136169689Skan;; time. 137169689Skan(define_predicate "aligned_offset_symbol_operand" 138169689Skan (and (match_code "symbol_ref") 139169689Skan (match_test "! SYMBOL_REF_FUNCTION_P (op)"))) 140169689Skan 141169689Skan;; True if OP refers to a symbol, and is appropriate for a GOT load. 142169689Skan(define_predicate "got_symbolic_operand" 143169689Skan (match_operand 0 "symbolic_operand" "") 144169689Skan{ 145169689Skan HOST_WIDE_INT addend = 0; 146169689Skan 147169689Skan switch (GET_CODE (op)) 148169689Skan { 149169689Skan case LABEL_REF: 150169689Skan return true; 151169689Skan 152169689Skan case CONST: 153169689Skan /* Accept only (plus (symbol_ref) (const_int)). */ 154169689Skan op = XEXP (op, 0); 155169689Skan if (GET_CODE (op) != PLUS 156169689Skan || GET_CODE (XEXP (op, 0)) != SYMBOL_REF 157169689Skan || GET_CODE (XEXP (op, 1)) != CONST_INT) 158169689Skan return false; 159169689Skan 160169689Skan addend = INTVAL (XEXP (op, 1)); 161169689Skan op = XEXP (op, 0); 162169689Skan /* FALLTHRU */ 163169689Skan 164169689Skan case SYMBOL_REF: 165169689Skan /* These symbols shouldn't be used with got loads. */ 166169689Skan if (SYMBOL_REF_SMALL_ADDR_P (op)) 167169689Skan return false; 168169689Skan if (SYMBOL_REF_TLS_MODEL (op) != 0) 169169689Skan return false; 170169689Skan 171169689Skan if (any_offset_symbol_operand (op, mode)) 172169689Skan return true; 173169689Skan 174169689Skan /* The low 14 bits of the constant have been forced to zero 175169689Skan so that we do not use up so many GOT entries. Prevent cse 176169689Skan from undoing this. */ 177169689Skan if (aligned_offset_symbol_operand (op, mode)) 178169689Skan return (addend & 0x3fff) == 0; 179169689Skan 180169689Skan return addend == 0; 181169689Skan 182169689Skan default: 183169689Skan gcc_unreachable (); 184169689Skan } 185169689Skan}) 186169689Skan 187169689Skan;; Return true if OP is a valid thread local storage symbolic operand. 188169689Skan(define_predicate "tls_symbolic_operand" 189169689Skan (match_code "symbol_ref,const") 190169689Skan{ 191169689Skan switch (GET_CODE (op)) 192169689Skan { 193169689Skan case SYMBOL_REF: 194169689Skan return SYMBOL_REF_TLS_MODEL (op) != 0; 195169689Skan 196169689Skan case CONST: 197169689Skan op = XEXP (op, 0); 198169689Skan if (GET_CODE (op) != PLUS 199169689Skan || GET_CODE (XEXP (op, 0)) != SYMBOL_REF 200169689Skan || GET_CODE (XEXP (op, 1)) != CONST_INT) 201169689Skan return false; 202169689Skan 203169689Skan /* We only allow certain offsets for certain tls models. */ 204169689Skan switch (SYMBOL_REF_TLS_MODEL (XEXP (op, 0))) 205169689Skan { 206169689Skan case TLS_MODEL_GLOBAL_DYNAMIC: 207169689Skan case TLS_MODEL_LOCAL_DYNAMIC: 208169689Skan return false; 209169689Skan 210169689Skan case TLS_MODEL_INITIAL_EXEC: 211169689Skan return (INTVAL (XEXP (op, 1)) & 0x3fff) == 0; 212169689Skan 213169689Skan case TLS_MODEL_LOCAL_EXEC: 214169689Skan return true; 215169689Skan 216169689Skan default: 217169689Skan return false; 218169689Skan } 219169689Skan 220169689Skan default: 221169689Skan gcc_unreachable (); 222169689Skan } 223169689Skan}) 224169689Skan 225169689Skan;; Return true if OP is a local-dynamic thread local storage symbolic operand. 226169689Skan(define_predicate "ld_tls_symbolic_operand" 227169689Skan (and (match_code "symbol_ref") 228169689Skan (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_DYNAMIC"))) 229169689Skan 230169689Skan;; Return true if OP is an initial-exec thread local storage symbolic operand. 231169689Skan(define_predicate "ie_tls_symbolic_operand" 232169689Skan (match_code "symbol_ref,const") 233169689Skan{ 234169689Skan switch (GET_CODE (op)) 235169689Skan { 236169689Skan case CONST: 237169689Skan op = XEXP (op, 0); 238169689Skan if (GET_CODE (op) != PLUS 239169689Skan || GET_CODE (XEXP (op, 0)) != SYMBOL_REF 240169689Skan || GET_CODE (XEXP (op, 1)) != CONST_INT 241169689Skan || (INTVAL (XEXP (op, 1)) & 0x3fff) != 0) 242169689Skan return false; 243169689Skan op = XEXP (op, 0); 244169689Skan /* FALLTHRU */ 245169689Skan 246169689Skan case SYMBOL_REF: 247169689Skan return SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_INITIAL_EXEC; 248169689Skan 249169689Skan default: 250169689Skan gcc_unreachable (); 251169689Skan } 252169689Skan}) 253169689Skan 254169689Skan;; Return true if OP is a local-exec thread local storage symbolic operand. 255169689Skan(define_predicate "le_tls_symbolic_operand" 256169689Skan (match_code "symbol_ref,const") 257169689Skan{ 258169689Skan switch (GET_CODE (op)) 259169689Skan { 260169689Skan case CONST: 261169689Skan op = XEXP (op, 0); 262169689Skan if (GET_CODE (op) != PLUS 263169689Skan || GET_CODE (XEXP (op, 0)) != SYMBOL_REF 264169689Skan || GET_CODE (XEXP (op, 1)) != CONST_INT) 265169689Skan return false; 266169689Skan op = XEXP (op, 0); 267169689Skan /* FALLTHRU */ 268169689Skan 269169689Skan case SYMBOL_REF: 270169689Skan return SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_EXEC; 271169689Skan 272169689Skan default: 273169689Skan gcc_unreachable (); 274169689Skan } 275169689Skan}) 276169689Skan 277169689Skan;; Like nonimmediate_operand, but don't allow MEMs that try to use a 278169689Skan;; POST_MODIFY with a REG as displacement. 279169689Skan(define_predicate "destination_operand" 280169689Skan (and (match_operand 0 "nonimmediate_operand") 281169689Skan (match_test "GET_CODE (op) != MEM 282169689Skan || GET_CODE (XEXP (op, 0)) != POST_MODIFY 283169689Skan || GET_CODE (XEXP (XEXP (XEXP (op, 0), 1), 1)) != REG"))) 284169689Skan 285169689Skan;; Like memory_operand, but don't allow post-increments. 286169689Skan(define_predicate "not_postinc_memory_operand" 287169689Skan (and (match_operand 0 "memory_operand") 288169689Skan (match_test "GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC"))) 289169689Skan 290169689Skan;; True if OP is a general operand, with some restrictions on symbols. 291169689Skan(define_predicate "move_operand" 292169689Skan (match_operand 0 "general_operand") 293169689Skan{ 294169689Skan switch (GET_CODE (op)) 295169689Skan { 296169689Skan case CONST: 297169689Skan { 298169689Skan HOST_WIDE_INT addend; 299169689Skan 300169689Skan /* Accept only (plus (symbol_ref) (const_int)). */ 301169689Skan op = XEXP (op, 0); 302169689Skan if (GET_CODE (op) != PLUS 303169689Skan || GET_CODE (XEXP (op, 0)) != SYMBOL_REF 304169689Skan || GET_CODE (XEXP (op, 1)) != CONST_INT) 305169689Skan return false; 306169689Skan 307169689Skan addend = INTVAL (XEXP (op, 1)); 308169689Skan op = XEXP (op, 0); 309169689Skan 310169689Skan /* After reload, we want to allow any offset whatsoever. This 311169689Skan allows reload the opportunity to avoid spilling addresses to 312169689Skan the stack, and instead simply substitute in the value from a 313169689Skan REG_EQUIV. We'll split this up again when splitting the insn. */ 314169689Skan if (reload_in_progress || reload_completed) 315169689Skan return true; 316169689Skan 317169689Skan /* Some symbol types we allow to use with any offset. */ 318169689Skan if (any_offset_symbol_operand (op, mode)) 319169689Skan return true; 320169689Skan 321169689Skan /* Some symbol types we allow offsets with the low 14 bits of the 322169689Skan constant forced to zero so that we do not use up so many GOT 323169689Skan entries. We want to prevent cse from undoing this. */ 324169689Skan if (aligned_offset_symbol_operand (op, mode)) 325169689Skan return (addend & 0x3fff) == 0; 326169689Skan 327169689Skan /* The remaining symbol types may never be used with an offset. */ 328169689Skan return false; 329169689Skan } 330169689Skan 331169689Skan default: 332169689Skan return true; 333169689Skan } 334169689Skan}) 335169689Skan 336169689Skan;; True if OP is a register operand that is (or could be) a GR reg. 337169689Skan(define_predicate "gr_register_operand" 338169689Skan (match_operand 0 "register_operand") 339169689Skan{ 340169689Skan unsigned int regno; 341169689Skan if (GET_CODE (op) == SUBREG) 342169689Skan op = SUBREG_REG (op); 343169689Skan 344169689Skan regno = REGNO (op); 345169689Skan return (regno >= FIRST_PSEUDO_REGISTER || GENERAL_REGNO_P (regno)); 346169689Skan}) 347169689Skan 348169689Skan;; True if OP is a register operand that is (or could be) an FR reg. 349169689Skan(define_predicate "fr_register_operand" 350169689Skan (match_operand 0 "register_operand") 351169689Skan{ 352169689Skan unsigned int regno; 353169689Skan if (GET_CODE (op) == SUBREG) 354169689Skan op = SUBREG_REG (op); 355169689Skan 356169689Skan regno = REGNO (op); 357169689Skan return (regno >= FIRST_PSEUDO_REGISTER || FR_REGNO_P (regno)); 358169689Skan}) 359169689Skan 360169689Skan;; True if OP is a register operand that is (or could be) a GR/FR reg. 361169689Skan(define_predicate "grfr_register_operand" 362169689Skan (match_operand 0 "register_operand") 363169689Skan{ 364169689Skan unsigned int regno; 365169689Skan if (GET_CODE (op) == SUBREG) 366169689Skan op = SUBREG_REG (op); 367169689Skan 368169689Skan regno = REGNO (op); 369169689Skan return (regno >= FIRST_PSEUDO_REGISTER 370169689Skan || GENERAL_REGNO_P (regno) 371169689Skan || FR_REGNO_P (regno)); 372169689Skan}) 373169689Skan 374169689Skan;; True if OP is a nonimmediate operand that is (or could be) a GR reg. 375169689Skan(define_predicate "gr_nonimmediate_operand" 376169689Skan (match_operand 0 "nonimmediate_operand") 377169689Skan{ 378169689Skan unsigned int regno; 379169689Skan 380169689Skan if (GET_CODE (op) == MEM) 381169689Skan return true; 382169689Skan if (GET_CODE (op) == SUBREG) 383169689Skan op = SUBREG_REG (op); 384169689Skan 385169689Skan regno = REGNO (op); 386169689Skan return (regno >= FIRST_PSEUDO_REGISTER || GENERAL_REGNO_P (regno)); 387169689Skan}) 388169689Skan 389169689Skan;; True if OP is a nonimmediate operand that is (or could be) a FR reg. 390169689Skan(define_predicate "fr_nonimmediate_operand" 391169689Skan (match_operand 0 "nonimmediate_operand") 392169689Skan{ 393169689Skan unsigned int regno; 394169689Skan 395169689Skan if (GET_CODE (op) == MEM) 396169689Skan return true; 397169689Skan if (GET_CODE (op) == SUBREG) 398169689Skan op = SUBREG_REG (op); 399169689Skan 400169689Skan regno = REGNO (op); 401169689Skan return (regno >= FIRST_PSEUDO_REGISTER || FR_REGNO_P (regno)); 402169689Skan}) 403169689Skan 404169689Skan;; True if OP is a nonimmediate operand that is (or could be) a GR/FR reg. 405169689Skan(define_predicate "grfr_nonimmediate_operand" 406169689Skan (match_operand 0 "nonimmediate_operand") 407169689Skan{ 408169689Skan unsigned int regno; 409169689Skan 410169689Skan if (GET_CODE (op) == MEM) 411169689Skan return true; 412169689Skan if (GET_CODE (op) == SUBREG) 413169689Skan op = SUBREG_REG (op); 414169689Skan 415169689Skan regno = REGNO (op); 416169689Skan return (regno >= FIRST_PSEUDO_REGISTER 417169689Skan || GENERAL_REGNO_P (regno) 418169689Skan || FR_REGNO_P (regno)); 419169689Skan}) 420169689Skan 421169689Skan;; True if OP is a GR register operand, or zero. 422169689Skan(define_predicate "gr_reg_or_0_operand" 423169689Skan (ior (match_operand 0 "gr_register_operand") 424169689Skan (and (match_code "const_int,const_double,const_vector") 425169689Skan (match_test "op == CONST0_RTX (GET_MODE (op))")))) 426169689Skan 427169689Skan;; True if OP is a GR register operand, or a 5 bit immediate operand. 428169689Skan(define_predicate "gr_reg_or_5bit_operand" 429169689Skan (ior (match_operand 0 "gr_register_operand") 430169689Skan (and (match_code "const_int") 431169689Skan (match_test "INTVAL (op) >= 0 && INTVAL (op) < 32")))) 432169689Skan 433169689Skan;; True if OP is a GR register operand, or a 6 bit immediate operand. 434169689Skan(define_predicate "gr_reg_or_6bit_operand" 435169689Skan (ior (match_operand 0 "gr_register_operand") 436169689Skan (and (match_code "const_int") 437169689Skan (match_test "CONST_OK_FOR_M (INTVAL (op))")))) 438169689Skan 439169689Skan;; True if OP is a GR register operand, or an 8 bit immediate operand. 440169689Skan(define_predicate "gr_reg_or_8bit_operand" 441169689Skan (ior (match_operand 0 "gr_register_operand") 442169689Skan (and (match_code "const_int") 443169689Skan (match_test "CONST_OK_FOR_K (INTVAL (op))")))) 444169689Skan 445169689Skan;; True if OP is a GR/FR register operand, or an 8 bit immediate operand. 446169689Skan(define_predicate "grfr_reg_or_8bit_operand" 447169689Skan (ior (match_operand 0 "grfr_register_operand") 448169689Skan (and (match_code "const_int") 449169689Skan (match_test "CONST_OK_FOR_K (INTVAL (op))")))) 450169689Skan 451169689Skan;; True if OP is a register operand, or an 8 bit adjusted immediate operand. 452169689Skan(define_predicate "gr_reg_or_8bit_adjusted_operand" 453169689Skan (ior (match_operand 0 "gr_register_operand") 454169689Skan (and (match_code "const_int") 455169689Skan (match_test "CONST_OK_FOR_L (INTVAL (op))")))) 456169689Skan 457169689Skan;; True if OP is a register operand, or is valid for both an 8 bit 458169689Skan;; immediate and an 8 bit adjusted immediate operand. This is necessary 459169689Skan;; because when we emit a compare, we don't know what the condition will be, 460169689Skan;; so we need the union of the immediates accepted by GT and LT. 461169689Skan(define_predicate "gr_reg_or_8bit_and_adjusted_operand" 462169689Skan (ior (match_operand 0 "gr_register_operand") 463169689Skan (and (match_code "const_int") 464169689Skan (match_test "CONST_OK_FOR_K (INTVAL (op)) 465169689Skan && CONST_OK_FOR_L (INTVAL (op))")))) 466169689Skan 467169689Skan;; True if OP is a register operand, or a 14 bit immediate operand. 468169689Skan(define_predicate "gr_reg_or_14bit_operand" 469169689Skan (ior (match_operand 0 "gr_register_operand") 470169689Skan (and (match_code "const_int") 471169689Skan (match_test "CONST_OK_FOR_I (INTVAL (op))")))) 472169689Skan 473169689Skan;; True if OP is a register operand, or a 22 bit immediate operand. 474169689Skan(define_predicate "gr_reg_or_22bit_operand" 475169689Skan (ior (match_operand 0 "gr_register_operand") 476169689Skan (and (match_code "const_int") 477169689Skan (match_test "CONST_OK_FOR_J (INTVAL (op))")))) 478169689Skan 479169689Skan;; True if OP is a 7 bit immediate operand. 480169689Skan(define_predicate "dshift_count_operand" 481169689Skan (and (match_code "const_int") 482169689Skan (match_test "INTVAL (op) >= 0 && INTVAL (op) < 128"))) 483169689Skan 484169689Skan;; True if OP is a 6 bit immediate operand. 485169689Skan(define_predicate "shift_count_operand" 486169689Skan (and (match_code "const_int") 487169689Skan (match_test "CONST_OK_FOR_M (INTVAL (op))"))) 488169689Skan 489169689Skan;; True if OP-1 is a 6 bit immediate operand, used in extr instruction. 490169689Skan(define_predicate "extr_len_operand" 491169689Skan (and (match_code "const_int") 492169689Skan (match_test "CONST_OK_FOR_M (INTVAL (op) - 1)"))) 493169689Skan 494169689Skan;; True if OP is a 5 bit immediate operand. 495169689Skan(define_predicate "shift_32bit_count_operand" 496169689Skan (and (match_code "const_int") 497169689Skan (match_test "INTVAL (op) >= 0 && INTVAL (op) < 32"))) 498169689Skan 499169689Skan;; True if OP is one of the immediate values 2, 4, 8, or 16. 500169689Skan(define_predicate "shladd_operand" 501169689Skan (and (match_code "const_int") 502169689Skan (match_test "INTVAL (op) == 2 || INTVAL (op) == 4 || 503169689Skan INTVAL (op) == 8 || INTVAL (op) == 16"))) 504169689Skan 505169689Skan;; True if OP is one of the immediate values 1, 2, 3, or 4. 506169689Skan(define_predicate "shladd_log2_operand" 507169689Skan (and (match_code "const_int") 508169689Skan (match_test "INTVAL (op) >= 1 && INTVAL (op) <= 4"))) 509169689Skan 510169689Skan;; True if OP is one of the immediate values -16, -8, -4, -1, 1, 4, 8, 16. 511169689Skan(define_predicate "fetchadd_operand" 512169689Skan (and (match_code "const_int") 513169689Skan (match_test "INTVAL (op) == -16 || INTVAL (op) == -8 || 514169689Skan INTVAL (op) == -4 || INTVAL (op) == -1 || 515169689Skan INTVAL (op) == 1 || INTVAL (op) == 4 || 516169689Skan INTVAL (op) == 8 || INTVAL (op) == 16"))) 517169689Skan 518169689Skan;; True if OP is 0..3. 519169689Skan(define_predicate "const_int_2bit_operand" 520169689Skan (and (match_code "const_int") 521169689Skan (match_test "INTVAL (op) >= 0 && INTVAL (op) <= 3"))) 522169689Skan 523169689Skan;; True if OP is a floating-point constant zero, one, or a register. 524169689Skan(define_predicate "fr_reg_or_fp01_operand" 525169689Skan (ior (match_operand 0 "fr_register_operand") 526169689Skan (and (match_code "const_double") 527169689Skan (match_test "CONST_DOUBLE_OK_FOR_G (op)")))) 528169689Skan 529169689Skan;; Like fr_reg_or_fp01_operand, but don't allow any SUBREGs. 530169689Skan(define_predicate "xfreg_or_fp01_operand" 531169689Skan (and (match_operand 0 "fr_reg_or_fp01_operand") 532169689Skan (not (match_code "subreg")))) 533169689Skan 534169689Skan;; True if OP is a constant zero, or a register. 535169689Skan(define_predicate "fr_reg_or_0_operand" 536169689Skan (ior (match_operand 0 "fr_register_operand") 537169689Skan (and (match_code "const_double,const_vector") 538169689Skan (match_test "op == CONST0_RTX (GET_MODE (op))")))) 539169689Skan 540169689Skan;; True if this is a comparison operator, which accepts a normal 8-bit 541169689Skan;; signed immediate operand. 542169689Skan(define_predicate "normal_comparison_operator" 543169689Skan (match_code "eq,ne,gt,le,gtu,leu")) 544169689Skan 545169689Skan;; True if this is a comparison operator, which accepts an adjusted 8-bit 546169689Skan;; signed immediate operand. 547169689Skan(define_predicate "adjusted_comparison_operator" 548169689Skan (match_code "lt,ge,ltu,geu")) 549169689Skan 550169689Skan;; True if this is a signed inequality operator. 551169689Skan(define_predicate "signed_inequality_operator" 552169689Skan (match_code "ge,gt,le,lt")) 553169689Skan 554169689Skan;; True if this operator is valid for predication. 555169689Skan(define_predicate "predicate_operator" 556169689Skan (match_code "eq,ne")) 557169689Skan 558169689Skan;; True if this operator can be used in a conditional operation. 559169689Skan(define_predicate "condop_operator" 560169689Skan (match_code "plus,minus,ior,xor,and")) 561169689Skan 562169689Skan;; These three are hardware registers that can only be addressed in 563169689Skan;; DImode. It's not strictly necessary to test mode == DImode here, 564169689Skan;; but it makes decent insurance against someone writing a 565169689Skan;; match_operand wrong. 566169689Skan 567169689Skan;; True if this is the ar.lc register. 568169689Skan(define_predicate "ar_lc_reg_operand" 569169689Skan (and (match_code "reg") 570169689Skan (match_test "mode == DImode && REGNO (op) == AR_LC_REGNUM"))) 571169689Skan 572169689Skan;; True if this is the ar.ccv register. 573169689Skan(define_predicate "ar_ccv_reg_operand" 574169689Skan (and (match_code "reg") 575169689Skan (match_test "mode == DImode && REGNO (op) == AR_CCV_REGNUM"))) 576169689Skan 577169689Skan;; True if this is the ar.pfs register. 578169689Skan(define_predicate "ar_pfs_reg_operand" 579169689Skan (and (match_code "reg") 580169689Skan (match_test "mode == DImode && REGNO (op) == AR_PFS_REGNUM"))) 581169689Skan 582169689Skan;; True if OP is valid as a base register in a reg + offset address. 583169689Skan;; ??? Should I copy the flag_omit_frame_pointer and cse_not_expected 584169689Skan;; checks from pa.c basereg_operand as well? Seems to be OK without them 585169689Skan;; in test runs. 586169689Skan(define_predicate "basereg_operand" 587169689Skan (match_operand 0 "register_operand") 588169689Skan{ 589169689Skan return REG_P (op) && REG_POINTER (op); 590169689Skan}) 591169689Skan 592