1;; Predicate definitions for IA-32 and x86-64. 2;; Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 3;; Free Software Foundation, Inc. 4;; 5;; This file is part of GCC. 6;; 7;; GCC is free software; you can redistribute it and/or modify 8;; it under the terms of the GNU General Public License as published by 9;; the Free Software Foundation; either version 3, or (at your option) 10;; any later version. 11;; 12;; GCC is distributed in the hope that it will be useful, 13;; but WITHOUT ANY WARRANTY; without even the implied warranty of 14;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15;; GNU General Public License for more details. 16;; 17;; You should have received a copy of the GNU General Public License 18;; along with GCC; see the file COPYING3. If not see 19;; <http://www.gnu.org/licenses/>. 20 21;; Return true if OP is either a i387 or SSE fp register. 22(define_predicate "any_fp_register_operand" 23 (and (match_code "reg") 24 (match_test "ANY_FP_REGNO_P (REGNO (op))"))) 25 26;; Return true if OP is an i387 fp register. 27(define_predicate "fp_register_operand" 28 (and (match_code "reg") 29 (match_test "FP_REGNO_P (REGNO (op))"))) 30 31;; Return true if OP is a non-fp register_operand. 32(define_predicate "register_and_not_any_fp_reg_operand" 33 (and (match_code "reg") 34 (not (match_test "ANY_FP_REGNO_P (REGNO (op))")))) 35 36;; Return true if OP is a register operand other than an i387 fp register. 37(define_predicate "register_and_not_fp_reg_operand" 38 (and (match_code "reg") 39 (not (match_test "FP_REGNO_P (REGNO (op))")))) 40 41;; True if the operand is an MMX register. 42(define_predicate "mmx_reg_operand" 43 (and (match_code "reg") 44 (match_test "MMX_REGNO_P (REGNO (op))"))) 45 46;; True if the operand is an SSE register. 47(define_predicate "sse_reg_operand" 48 (and (match_code "reg") 49 (match_test "SSE_REGNO_P (REGNO (op))"))) 50 51;; True if the operand is a Q_REGS class register. 52(define_predicate "q_regs_operand" 53 (match_operand 0 "register_operand") 54{ 55 if (GET_CODE (op) == SUBREG) 56 op = SUBREG_REG (op); 57 return ANY_QI_REG_P (op); 58}) 59 60;; Match an SI or HImode register for a zero_extract. 61(define_special_predicate "ext_register_operand" 62 (match_operand 0 "register_operand") 63{ 64 if ((!TARGET_64BIT || GET_MODE (op) != DImode) 65 && GET_MODE (op) != SImode && GET_MODE (op) != HImode) 66 return false; 67 if (GET_CODE (op) == SUBREG) 68 op = SUBREG_REG (op); 69 70 /* Be careful to accept only registers having upper parts. */ 71 return (REG_P (op) 72 && (REGNO (op) > LAST_VIRTUAL_REGISTER || REGNO (op) <= BX_REG)); 73}) 74 75;; Return true if op is the AX register. 76(define_predicate "ax_reg_operand" 77 (and (match_code "reg") 78 (match_test "REGNO (op) == AX_REG"))) 79 80;; Return true if op is the flags register. 81(define_predicate "flags_reg_operand" 82 (and (match_code "reg") 83 (match_test "REGNO (op) == FLAGS_REG"))) 84 85;; Return true if op is one of QImode registers: %[abcd][hl]. 86(define_predicate "QIreg_operand" 87 (match_test "QI_REG_P (op)")) 88 89;; Return true if op is a QImode register operand other than 90;; %[abcd][hl]. 91(define_predicate "ext_QIreg_operand" 92 (and (match_code "reg") 93 (match_test "TARGET_64BIT") 94 (match_test "REGNO (op) > BX_REG"))) 95 96;; Return true if op is not xmm0 register. 97(define_predicate "reg_not_xmm0_operand" 98 (match_operand 0 "register_operand") 99{ 100 if (GET_CODE (op) == SUBREG) 101 op = SUBREG_REG (op); 102 103 return !REG_P (op) || REGNO (op) != FIRST_SSE_REG; 104}) 105 106;; As above, but also allow memory operands. 107(define_predicate "nonimm_not_xmm0_operand" 108 (ior (match_operand 0 "memory_operand") 109 (match_operand 0 "reg_not_xmm0_operand"))) 110 111;; Return true if op is not xmm0 register, but only for non-AVX targets. 112(define_predicate "reg_not_xmm0_operand_maybe_avx" 113 (if_then_else (match_test "TARGET_AVX") 114 (match_operand 0 "register_operand") 115 (match_operand 0 "reg_not_xmm0_operand"))) 116 117;; As above, but also allow memory operands. 118(define_predicate "nonimm_not_xmm0_operand_maybe_avx" 119 (if_then_else (match_test "TARGET_AVX") 120 (match_operand 0 "nonimmediate_operand") 121 (match_operand 0 "nonimm_not_xmm0_operand"))) 122 123;; Return true if VALUE can be stored in a sign extended immediate field. 124(define_predicate "x86_64_immediate_operand" 125 (match_code "const_int,symbol_ref,label_ref,const") 126{ 127 if (!TARGET_64BIT) 128 return immediate_operand (op, mode); 129 130 switch (GET_CODE (op)) 131 { 132 case CONST_INT: 133 /* CONST_DOUBLES never match, since HOST_BITS_PER_WIDE_INT is known 134 to be at least 32 and this all acceptable constants are 135 represented as CONST_INT. */ 136 if (HOST_BITS_PER_WIDE_INT == 32) 137 return true; 138 else 139 { 140 HOST_WIDE_INT val = trunc_int_for_mode (INTVAL (op), DImode); 141 return trunc_int_for_mode (val, SImode) == val; 142 } 143 break; 144 145 case SYMBOL_REF: 146 /* For certain code models, the symbolic references are known to fit. 147 in CM_SMALL_PIC model we know it fits if it is local to the shared 148 library. Don't count TLS SYMBOL_REFs here, since they should fit 149 only if inside of UNSPEC handled below. */ 150 /* TLS symbols are not constant. */ 151 if (SYMBOL_REF_TLS_MODEL (op)) 152 return false; 153 return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL 154 || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op))); 155 156 case LABEL_REF: 157 /* For certain code models, the code is near as well. */ 158 return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM 159 || ix86_cmodel == CM_KERNEL); 160 161 case CONST: 162 /* We also may accept the offsetted memory references in certain 163 special cases. */ 164 if (GET_CODE (XEXP (op, 0)) == UNSPEC) 165 switch (XINT (XEXP (op, 0), 1)) 166 { 167 case UNSPEC_GOTPCREL: 168 case UNSPEC_DTPOFF: 169 case UNSPEC_GOTNTPOFF: 170 case UNSPEC_NTPOFF: 171 return true; 172 default: 173 break; 174 } 175 176 if (GET_CODE (XEXP (op, 0)) == PLUS) 177 { 178 rtx op1 = XEXP (XEXP (op, 0), 0); 179 rtx op2 = XEXP (XEXP (op, 0), 1); 180 HOST_WIDE_INT offset; 181 182 if (ix86_cmodel == CM_LARGE) 183 return false; 184 if (!CONST_INT_P (op2)) 185 return false; 186 offset = trunc_int_for_mode (INTVAL (op2), DImode); 187 switch (GET_CODE (op1)) 188 { 189 case SYMBOL_REF: 190 /* TLS symbols are not constant. */ 191 if (SYMBOL_REF_TLS_MODEL (op1)) 192 return false; 193 /* For CM_SMALL assume that latest object is 16MB before 194 end of 31bits boundary. We may also accept pretty 195 large negative constants knowing that all objects are 196 in the positive half of address space. */ 197 if ((ix86_cmodel == CM_SMALL 198 || (ix86_cmodel == CM_MEDIUM 199 && !SYMBOL_REF_FAR_ADDR_P (op1))) 200 && offset < 16*1024*1024 201 && trunc_int_for_mode (offset, SImode) == offset) 202 return true; 203 /* For CM_KERNEL we know that all object resist in the 204 negative half of 32bits address space. We may not 205 accept negative offsets, since they may be just off 206 and we may accept pretty large positive ones. */ 207 if (ix86_cmodel == CM_KERNEL 208 && offset > 0 209 && trunc_int_for_mode (offset, SImode) == offset) 210 return true; 211 break; 212 213 case LABEL_REF: 214 /* These conditions are similar to SYMBOL_REF ones, just the 215 constraints for code models differ. */ 216 if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM) 217 && offset < 16*1024*1024 218 && trunc_int_for_mode (offset, SImode) == offset) 219 return true; 220 if (ix86_cmodel == CM_KERNEL 221 && offset > 0 222 && trunc_int_for_mode (offset, SImode) == offset) 223 return true; 224 break; 225 226 case UNSPEC: 227 switch (XINT (op1, 1)) 228 { 229 case UNSPEC_DTPOFF: 230 case UNSPEC_NTPOFF: 231 if (offset > 0 232 && trunc_int_for_mode (offset, SImode) == offset) 233 return true; 234 } 235 break; 236 237 default: 238 break; 239 } 240 } 241 break; 242 243 default: 244 gcc_unreachable (); 245 } 246 247 return false; 248}) 249 250;; Return true if VALUE can be stored in the zero extended immediate field. 251(define_predicate "x86_64_zext_immediate_operand" 252 (match_code "const_double,const_int,symbol_ref,label_ref,const") 253{ 254 switch (GET_CODE (op)) 255 { 256 case CONST_DOUBLE: 257 if (HOST_BITS_PER_WIDE_INT == 32) 258 return (GET_MODE (op) == VOIDmode && !CONST_DOUBLE_HIGH (op)); 259 else 260 return false; 261 262 case CONST_INT: 263 if (HOST_BITS_PER_WIDE_INT == 32) 264 return INTVAL (op) >= 0; 265 else 266 return !(INTVAL (op) & ~(HOST_WIDE_INT) 0xffffffff); 267 268 case SYMBOL_REF: 269 /* For certain code models, the symbolic references are known to fit. */ 270 /* TLS symbols are not constant. */ 271 if (SYMBOL_REF_TLS_MODEL (op)) 272 return false; 273 return (ix86_cmodel == CM_SMALL 274 || (ix86_cmodel == CM_MEDIUM 275 && !SYMBOL_REF_FAR_ADDR_P (op))); 276 277 case LABEL_REF: 278 /* For certain code models, the code is near as well. */ 279 return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM; 280 281 case CONST: 282 /* We also may accept the offsetted memory references in certain 283 special cases. */ 284 if (GET_CODE (XEXP (op, 0)) == PLUS) 285 { 286 rtx op1 = XEXP (XEXP (op, 0), 0); 287 rtx op2 = XEXP (XEXP (op, 0), 1); 288 289 if (ix86_cmodel == CM_LARGE) 290 return false; 291 switch (GET_CODE (op1)) 292 { 293 case SYMBOL_REF: 294 /* TLS symbols are not constant. */ 295 if (SYMBOL_REF_TLS_MODEL (op1)) 296 return false; 297 /* For small code model we may accept pretty large positive 298 offsets, since one bit is available for free. Negative 299 offsets are limited by the size of NULL pointer area 300 specified by the ABI. */ 301 if ((ix86_cmodel == CM_SMALL 302 || (ix86_cmodel == CM_MEDIUM 303 && !SYMBOL_REF_FAR_ADDR_P (op1))) 304 && CONST_INT_P (op2) 305 && trunc_int_for_mode (INTVAL (op2), DImode) > -0x10000 306 && trunc_int_for_mode (INTVAL (op2), SImode) == INTVAL (op2)) 307 return true; 308 /* ??? For the kernel, we may accept adjustment of 309 -0x10000000, since we know that it will just convert 310 negative address space to positive, but perhaps this 311 is not worthwhile. */ 312 break; 313 314 case LABEL_REF: 315 /* These conditions are similar to SYMBOL_REF ones, just the 316 constraints for code models differ. */ 317 if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM) 318 && CONST_INT_P (op2) 319 && trunc_int_for_mode (INTVAL (op2), DImode) > -0x10000 320 && trunc_int_for_mode (INTVAL (op2), SImode) == INTVAL (op2)) 321 return true; 322 break; 323 324 default: 325 return false; 326 } 327 } 328 break; 329 330 default: 331 gcc_unreachable (); 332 } 333 return false; 334}) 335 336;; Return true if OP is general operand representable on x86_64. 337(define_predicate "x86_64_general_operand" 338 (if_then_else (match_test "TARGET_64BIT") 339 (ior (match_operand 0 "nonimmediate_operand") 340 (match_operand 0 "x86_64_immediate_operand")) 341 (match_operand 0 "general_operand"))) 342 343;; Return true if OP is general operand representable on x86_64 344;; as either sign extended or zero extended constant. 345(define_predicate "x86_64_szext_general_operand" 346 (if_then_else (match_test "TARGET_64BIT") 347 (ior (match_operand 0 "nonimmediate_operand") 348 (match_operand 0 "x86_64_immediate_operand") 349 (match_operand 0 "x86_64_zext_immediate_operand")) 350 (match_operand 0 "general_operand"))) 351 352;; Return true if OP is nonmemory operand representable on x86_64. 353(define_predicate "x86_64_nonmemory_operand" 354 (if_then_else (match_test "TARGET_64BIT") 355 (ior (match_operand 0 "register_operand") 356 (match_operand 0 "x86_64_immediate_operand")) 357 (match_operand 0 "nonmemory_operand"))) 358 359;; Return true if OP is nonmemory operand representable on x86_64. 360(define_predicate "x86_64_szext_nonmemory_operand" 361 (if_then_else (match_test "TARGET_64BIT") 362 (ior (match_operand 0 "register_operand") 363 (match_operand 0 "x86_64_immediate_operand") 364 (match_operand 0 "x86_64_zext_immediate_operand")) 365 (match_operand 0 "nonmemory_operand"))) 366 367;; Return true when operand is PIC expression that can be computed by lea 368;; operation. 369(define_predicate "pic_32bit_operand" 370 (match_code "const,symbol_ref,label_ref") 371{ 372 if (!flag_pic) 373 return false; 374 375 /* Rule out relocations that translate into 64bit constants. */ 376 if (TARGET_64BIT && GET_CODE (op) == CONST) 377 { 378 op = XEXP (op, 0); 379 if (GET_CODE (op) == PLUS && CONST_INT_P (XEXP (op, 1))) 380 op = XEXP (op, 0); 381 if (GET_CODE (op) == UNSPEC 382 && (XINT (op, 1) == UNSPEC_GOTOFF 383 || XINT (op, 1) == UNSPEC_GOT)) 384 return false; 385 } 386 387 return symbolic_operand (op, mode); 388}) 389 390;; Return true if OP is nonmemory operand acceptable by movabs patterns. 391(define_predicate "x86_64_movabs_operand" 392 (and (match_operand 0 "nonmemory_operand") 393 (not (match_operand 0 "pic_32bit_operand")))) 394 395;; Return true if OP is either a symbol reference or a sum of a symbol 396;; reference and a constant. 397(define_predicate "symbolic_operand" 398 (match_code "symbol_ref,label_ref,const") 399{ 400 switch (GET_CODE (op)) 401 { 402 case SYMBOL_REF: 403 case LABEL_REF: 404 return true; 405 406 case CONST: 407 op = XEXP (op, 0); 408 if (GET_CODE (op) == SYMBOL_REF 409 || GET_CODE (op) == LABEL_REF 410 || (GET_CODE (op) == UNSPEC 411 && (XINT (op, 1) == UNSPEC_GOT 412 || XINT (op, 1) == UNSPEC_GOTOFF 413 || XINT (op, 1) == UNSPEC_PCREL 414 || XINT (op, 1) == UNSPEC_GOTPCREL))) 415 return true; 416 if (GET_CODE (op) != PLUS 417 || !CONST_INT_P (XEXP (op, 1))) 418 return false; 419 420 op = XEXP (op, 0); 421 if (GET_CODE (op) == SYMBOL_REF 422 || GET_CODE (op) == LABEL_REF) 423 return true; 424 /* Only @GOTOFF gets offsets. */ 425 if (GET_CODE (op) != UNSPEC 426 || XINT (op, 1) != UNSPEC_GOTOFF) 427 return false; 428 429 op = XVECEXP (op, 0, 0); 430 if (GET_CODE (op) == SYMBOL_REF 431 || GET_CODE (op) == LABEL_REF) 432 return true; 433 return false; 434 435 default: 436 gcc_unreachable (); 437 } 438}) 439 440;; Return true if OP is a symbolic operand that resolves locally. 441(define_predicate "local_symbolic_operand" 442 (match_code "const,label_ref,symbol_ref") 443{ 444 if (GET_CODE (op) == CONST 445 && GET_CODE (XEXP (op, 0)) == PLUS 446 && CONST_INT_P (XEXP (XEXP (op, 0), 1))) 447 op = XEXP (XEXP (op, 0), 0); 448 449 if (GET_CODE (op) == LABEL_REF) 450 return true; 451 452 if (GET_CODE (op) != SYMBOL_REF) 453 return false; 454 455 if (SYMBOL_REF_TLS_MODEL (op)) 456 return false; 457 458 if (SYMBOL_REF_LOCAL_P (op)) 459 return true; 460 461 /* There is, however, a not insubstantial body of code in the rest of 462 the compiler that assumes it can just stick the results of 463 ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done. */ 464 /* ??? This is a hack. Should update the body of the compiler to 465 always create a DECL an invoke targetm.encode_section_info. */ 466 if (strncmp (XSTR (op, 0), internal_label_prefix, 467 internal_label_prefix_len) == 0) 468 return true; 469 470 return false; 471}) 472 473;; Test for a legitimate @GOTOFF operand. 474;; 475;; VxWorks does not impose a fixed gap between segments; the run-time 476;; gap can be different from the object-file gap. We therefore can't 477;; use @GOTOFF unless we are absolutely sure that the symbol is in the 478;; same segment as the GOT. Unfortunately, the flexibility of linker 479;; scripts means that we can't be sure of that in general, so assume 480;; that @GOTOFF is never valid on VxWorks. 481(define_predicate "gotoff_operand" 482 (and (not (match_test "TARGET_VXWORKS_RTP")) 483 (match_operand 0 "local_symbolic_operand"))) 484 485;; Test for various thread-local symbols. 486(define_predicate "tls_symbolic_operand" 487 (and (match_code "symbol_ref") 488 (match_test "SYMBOL_REF_TLS_MODEL (op)"))) 489 490(define_predicate "tls_modbase_operand" 491 (and (match_code "symbol_ref") 492 (match_test "op == ix86_tls_module_base ()"))) 493 494;; Test for a pc-relative call operand 495(define_predicate "constant_call_address_operand" 496 (match_code "symbol_ref") 497{ 498 if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC) 499 return false; 500 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op)) 501 return false; 502 return true; 503}) 504 505;; P6 processors will jump to the address after the decrement when %esp 506;; is used as a call operand, so they will execute return address as a code. 507;; See Pentium Pro errata 70, Pentium 2 errata A33 and Pentium 3 errata E17. 508 509(define_predicate "call_register_no_elim_operand" 510 (match_operand 0 "register_operand") 511{ 512 if (GET_CODE (op) == SUBREG) 513 op = SUBREG_REG (op); 514 515 if (!TARGET_64BIT && op == stack_pointer_rtx) 516 return false; 517 518 return register_no_elim_operand (op, mode); 519}) 520 521;; True for any non-virtual or eliminable register. Used in places where 522;; instantiation of such a register may cause the pattern to not be recognized. 523(define_predicate "register_no_elim_operand" 524 (match_operand 0 "register_operand") 525{ 526 if (GET_CODE (op) == SUBREG) 527 op = SUBREG_REG (op); 528 return !(op == arg_pointer_rtx 529 || op == frame_pointer_rtx 530 || IN_RANGE (REGNO (op), 531 FIRST_PSEUDO_REGISTER, LAST_VIRTUAL_REGISTER)); 532}) 533 534;; Similarly, but include the stack pointer. This is used to prevent esp 535;; from being used as an index reg. 536(define_predicate "index_register_operand" 537 (match_operand 0 "register_operand") 538{ 539 if (GET_CODE (op) == SUBREG) 540 op = SUBREG_REG (op); 541 if (reload_in_progress || reload_completed) 542 return REG_OK_FOR_INDEX_STRICT_P (op); 543 else 544 return REG_OK_FOR_INDEX_NONSTRICT_P (op); 545}) 546 547;; Return false if this is any eliminable register. Otherwise general_operand. 548(define_predicate "general_no_elim_operand" 549 (if_then_else (match_code "reg,subreg") 550 (match_operand 0 "register_no_elim_operand") 551 (match_operand 0 "general_operand"))) 552 553;; Return false if this is any eliminable register. Otherwise 554;; register_operand or a constant. 555(define_predicate "nonmemory_no_elim_operand" 556 (ior (match_operand 0 "register_no_elim_operand") 557 (match_operand 0 "immediate_operand"))) 558 559;; Test for a valid operand for indirect branch. 560(define_predicate "indirect_branch_operand" 561 (if_then_else (match_test "TARGET_X32") 562 (match_operand 0 "register_operand") 563 (match_operand 0 "nonimmediate_operand"))) 564 565;; Test for a valid operand for a call instruction. 566(define_predicate "call_insn_operand" 567 (ior (match_operand 0 "constant_call_address_operand") 568 (match_operand 0 "call_register_no_elim_operand") 569 (and (not (match_test "TARGET_X32")) 570 (match_operand 0 "memory_operand")))) 571 572;; Similarly, but for tail calls, in which we cannot allow memory references. 573(define_predicate "sibcall_insn_operand" 574 (ior (match_operand 0 "constant_call_address_operand") 575 (match_operand 0 "register_no_elim_operand"))) 576 577;; Match exactly zero. 578(define_predicate "const0_operand" 579 (match_code "const_int,const_double,const_vector") 580{ 581 if (mode == VOIDmode) 582 mode = GET_MODE (op); 583 return op == CONST0_RTX (mode); 584}) 585 586;; Match exactly one. 587(define_predicate "const1_operand" 588 (and (match_code "const_int") 589 (match_test "op == const1_rtx"))) 590 591;; Match exactly eight. 592(define_predicate "const8_operand" 593 (and (match_code "const_int") 594 (match_test "INTVAL (op) == 8"))) 595 596;; Match exactly 128. 597(define_predicate "const128_operand" 598 (and (match_code "const_int") 599 (match_test "INTVAL (op) == 128"))) 600 601;; Match exactly 0x0FFFFFFFF in anddi as a zero-extension operation 602(define_predicate "const_32bit_mask" 603 (and (match_code "const_int") 604 (match_test "trunc_int_for_mode (INTVAL (op), DImode) 605 == (HOST_WIDE_INT) 0xffffffff"))) 606 607;; Match 2, 4, or 8. Used for leal multiplicands. 608(define_predicate "const248_operand" 609 (match_code "const_int") 610{ 611 HOST_WIDE_INT i = INTVAL (op); 612 return i == 2 || i == 4 || i == 8; 613}) 614 615;; Match 1, 2, 4, or 8 616(define_predicate "const1248_operand" 617 (match_code "const_int") 618{ 619 HOST_WIDE_INT i = INTVAL (op); 620 return i == 1 || i == 2 || i == 4 || i == 8; 621}) 622 623;; Match 3, 5, or 9. Used for leal multiplicands. 624(define_predicate "const359_operand" 625 (match_code "const_int") 626{ 627 HOST_WIDE_INT i = INTVAL (op); 628 return i == 3 || i == 5 || i == 9; 629}) 630 631;; Match 0 or 1. 632(define_predicate "const_0_to_1_operand" 633 (and (match_code "const_int") 634 (ior (match_test "op == const0_rtx") 635 (match_test "op == const1_rtx")))) 636 637;; Match 0 to 3. 638(define_predicate "const_0_to_3_operand" 639 (and (match_code "const_int") 640 (match_test "IN_RANGE (INTVAL (op), 0, 3)"))) 641 642;; Match 0 to 7. 643(define_predicate "const_0_to_7_operand" 644 (and (match_code "const_int") 645 (match_test "IN_RANGE (INTVAL (op), 0, 7)"))) 646 647;; Match 0 to 15. 648(define_predicate "const_0_to_15_operand" 649 (and (match_code "const_int") 650 (match_test "IN_RANGE (INTVAL (op), 0, 15)"))) 651 652;; Match 0 to 31. 653(define_predicate "const_0_to_31_operand" 654 (and (match_code "const_int") 655 (match_test "IN_RANGE (INTVAL (op), 0, 31)"))) 656 657;; Match 0 to 63. 658(define_predicate "const_0_to_63_operand" 659 (and (match_code "const_int") 660 (match_test "IN_RANGE (INTVAL (op), 0, 63)"))) 661 662;; Match 0 to 255. 663(define_predicate "const_0_to_255_operand" 664 (and (match_code "const_int") 665 (match_test "IN_RANGE (INTVAL (op), 0, 255)"))) 666 667;; Match (0 to 255) * 8 668(define_predicate "const_0_to_255_mul_8_operand" 669 (match_code "const_int") 670{ 671 unsigned HOST_WIDE_INT val = INTVAL (op); 672 return val <= 255*8 && val % 8 == 0; 673}) 674 675;; Return true if OP is CONST_INT >= 1 and <= 31 (a valid operand 676;; for shift & compare patterns, as shifting by 0 does not change flags). 677(define_predicate "const_1_to_31_operand" 678 (and (match_code "const_int") 679 (match_test "IN_RANGE (INTVAL (op), 1, 31)"))) 680 681;; Return true if OP is CONST_INT >= 1 and <= 63 (a valid operand 682;; for 64bit shift & compare patterns, as shifting by 0 does not change flags). 683(define_predicate "const_1_to_63_operand" 684 (and (match_code "const_int") 685 (match_test "IN_RANGE (INTVAL (op), 1, 63)"))) 686 687;; Match 2 or 3. 688(define_predicate "const_2_to_3_operand" 689 (and (match_code "const_int") 690 (match_test "IN_RANGE (INTVAL (op), 2, 3)"))) 691 692;; Match 4 to 5. 693(define_predicate "const_4_to_5_operand" 694 (and (match_code "const_int") 695 (match_test "IN_RANGE (INTVAL (op), 4, 5)"))) 696 697;; Match 4 to 7. 698(define_predicate "const_4_to_7_operand" 699 (and (match_code "const_int") 700 (match_test "IN_RANGE (INTVAL (op), 4, 7)"))) 701 702;; Match 6 to 7. 703(define_predicate "const_6_to_7_operand" 704 (and (match_code "const_int") 705 (match_test "IN_RANGE (INTVAL (op), 6, 7)"))) 706 707;; Match 8 to 11. 708(define_predicate "const_8_to_11_operand" 709 (and (match_code "const_int") 710 (match_test "IN_RANGE (INTVAL (op), 8, 11)"))) 711 712;; Match 12 to 15. 713(define_predicate "const_12_to_15_operand" 714 (and (match_code "const_int") 715 (match_test "IN_RANGE (INTVAL (op), 12, 15)"))) 716 717;; True if this is a constant appropriate for an increment or decrement. 718(define_predicate "incdec_operand" 719 (match_code "const_int") 720{ 721 /* On Pentium4, the inc and dec operations causes extra dependency on flag 722 registers, since carry flag is not set. */ 723 if (!TARGET_USE_INCDEC && !optimize_insn_for_size_p ()) 724 return false; 725 return op == const1_rtx || op == constm1_rtx; 726}) 727 728;; True for registers, or 1 or -1. Used to optimize double-word shifts. 729(define_predicate "reg_or_pm1_operand" 730 (ior (match_operand 0 "register_operand") 731 (and (match_code "const_int") 732 (ior (match_test "op == const1_rtx") 733 (match_test "op == constm1_rtx"))))) 734 735;; True if OP is acceptable as operand of DImode shift expander. 736(define_predicate "shiftdi_operand" 737 (if_then_else (match_test "TARGET_64BIT") 738 (match_operand 0 "nonimmediate_operand") 739 (match_operand 0 "register_operand"))) 740 741(define_predicate "ashldi_input_operand" 742 (if_then_else (match_test "TARGET_64BIT") 743 (match_operand 0 "nonimmediate_operand") 744 (match_operand 0 "reg_or_pm1_operand"))) 745 746;; Return true if OP is a vector load from the constant pool with just 747;; the first element nonzero. 748(define_predicate "zero_extended_scalar_load_operand" 749 (match_code "mem") 750{ 751 unsigned n_elts; 752 op = maybe_get_pool_constant (op); 753 754 if (!(op && GET_CODE (op) == CONST_VECTOR)) 755 return false; 756 757 n_elts = CONST_VECTOR_NUNITS (op); 758 759 for (n_elts--; n_elts > 0; n_elts--) 760 { 761 rtx elt = CONST_VECTOR_ELT (op, n_elts); 762 if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op)))) 763 return false; 764 } 765 return true; 766}) 767 768/* Return true if operand is a vector constant that is all ones. */ 769(define_predicate "vector_all_ones_operand" 770 (match_code "const_vector") 771{ 772 int nunits = GET_MODE_NUNITS (mode); 773 774 if (GET_CODE (op) == CONST_VECTOR 775 && CONST_VECTOR_NUNITS (op) == nunits) 776 { 777 int i; 778 for (i = 0; i < nunits; ++i) 779 { 780 rtx x = CONST_VECTOR_ELT (op, i); 781 if (x != constm1_rtx) 782 return false; 783 } 784 return true; 785 } 786 787 return false; 788}) 789 790; Return true when OP is operand acceptable for standard SSE move. 791(define_predicate "vector_move_operand" 792 (ior (match_operand 0 "nonimmediate_operand") 793 (match_operand 0 "const0_operand"))) 794 795;; Return true when OP is nonimmediate or standard SSE constant. 796(define_predicate "nonimmediate_or_sse_const_operand" 797 (match_operand 0 "general_operand") 798{ 799 if (nonimmediate_operand (op, mode)) 800 return true; 801 if (standard_sse_constant_p (op) > 0) 802 return true; 803 return false; 804}) 805 806;; Return true if OP is a register or a zero. 807(define_predicate "reg_or_0_operand" 808 (ior (match_operand 0 "register_operand") 809 (match_operand 0 "const0_operand"))) 810 811;; Return true if op if a valid address for LEA, and does not contain 812;; a segment override. Defined as a special predicate to allow 813;; mode-less const_int operands pass to address_operand. 814(define_special_predicate "lea_address_operand" 815 (match_operand 0 "address_operand") 816{ 817 struct ix86_address parts; 818 int ok; 819 820 ok = ix86_decompose_address (op, &parts); 821 gcc_assert (ok); 822 return parts.seg == SEG_DEFAULT; 823}) 824 825;; Return true if op if a valid base register, displacement or 826;; sum of base register and displacement for VSIB addressing. 827(define_predicate "vsib_address_operand" 828 (match_operand 0 "address_operand") 829{ 830 struct ix86_address parts; 831 int ok; 832 rtx disp; 833 834 ok = ix86_decompose_address (op, &parts); 835 gcc_assert (ok); 836 if (parts.index || parts.seg != SEG_DEFAULT) 837 return false; 838 839 /* VSIB addressing doesn't support (%rip). */ 840 if (parts.disp && GET_CODE (parts.disp) == CONST) 841 { 842 disp = XEXP (parts.disp, 0); 843 if (GET_CODE (disp) == PLUS) 844 disp = XEXP (disp, 0); 845 if (GET_CODE (disp) == UNSPEC) 846 switch (XINT (disp, 1)) 847 { 848 case UNSPEC_GOTPCREL: 849 case UNSPEC_PCREL: 850 case UNSPEC_GOTNTPOFF: 851 return false; 852 } 853 } 854 855 return true; 856}) 857 858(define_predicate "vsib_mem_operator" 859 (match_code "mem")) 860 861;; Return true if the rtx is known to be at least 32 bits aligned. 862(define_predicate "aligned_operand" 863 (match_operand 0 "general_operand") 864{ 865 struct ix86_address parts; 866 int ok; 867 868 /* Registers and immediate operands are always "aligned". */ 869 if (!MEM_P (op)) 870 return true; 871 872 /* All patterns using aligned_operand on memory operands ends up 873 in promoting memory operand to 64bit and thus causing memory mismatch. */ 874 if (TARGET_MEMORY_MISMATCH_STALL && !optimize_insn_for_size_p ()) 875 return false; 876 877 /* Don't even try to do any aligned optimizations with volatiles. */ 878 if (MEM_VOLATILE_P (op)) 879 return false; 880 881 if (MEM_ALIGN (op) >= 32) 882 return true; 883 884 op = XEXP (op, 0); 885 886 /* Pushes and pops are only valid on the stack pointer. */ 887 if (GET_CODE (op) == PRE_DEC 888 || GET_CODE (op) == POST_INC) 889 return true; 890 891 /* Decode the address. */ 892 ok = ix86_decompose_address (op, &parts); 893 gcc_assert (ok); 894 895 if (parts.base && GET_CODE (parts.base) == SUBREG) 896 parts.base = SUBREG_REG (parts.base); 897 if (parts.index && GET_CODE (parts.index) == SUBREG) 898 parts.index = SUBREG_REG (parts.index); 899 900 /* Look for some component that isn't known to be aligned. */ 901 if (parts.index) 902 { 903 if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32) 904 return false; 905 } 906 if (parts.base) 907 { 908 if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32) 909 return false; 910 } 911 if (parts.disp) 912 { 913 if (!CONST_INT_P (parts.disp) 914 || (INTVAL (parts.disp) & 3)) 915 return false; 916 } 917 918 /* Didn't find one -- this must be an aligned address. */ 919 return true; 920}) 921 922;; Return true if OP is memory operand with a displacement. 923(define_predicate "memory_displacement_operand" 924 (match_operand 0 "memory_operand") 925{ 926 struct ix86_address parts; 927 int ok; 928 929 ok = ix86_decompose_address (XEXP (op, 0), &parts); 930 gcc_assert (ok); 931 return parts.disp != NULL_RTX; 932}) 933 934;; Return true if OP is memory operand with a displacement only. 935(define_predicate "memory_displacement_only_operand" 936 (match_operand 0 "memory_operand") 937{ 938 struct ix86_address parts; 939 int ok; 940 941 if (TARGET_64BIT) 942 return false; 943 944 ok = ix86_decompose_address (XEXP (op, 0), &parts); 945 gcc_assert (ok); 946 947 if (parts.base || parts.index) 948 return false; 949 950 return parts.disp != NULL_RTX; 951}) 952 953;; Return true if OP is memory operand which will need zero or 954;; one register at most, not counting stack pointer or frame pointer. 955(define_predicate "cmpxchg8b_pic_memory_operand" 956 (match_operand 0 "memory_operand") 957{ 958 struct ix86_address parts; 959 int ok; 960 961 if (TARGET_64BIT || !flag_pic) 962 return true; 963 964 ok = ix86_decompose_address (XEXP (op, 0), &parts); 965 gcc_assert (ok); 966 967 if (parts.base && GET_CODE (parts.base) == SUBREG) 968 parts.base = SUBREG_REG (parts.base); 969 if (parts.index && GET_CODE (parts.index) == SUBREG) 970 parts.index = SUBREG_REG (parts.index); 971 972 if (parts.base == NULL_RTX 973 || parts.base == arg_pointer_rtx 974 || parts.base == frame_pointer_rtx 975 || parts.base == hard_frame_pointer_rtx 976 || parts.base == stack_pointer_rtx) 977 return true; 978 979 if (parts.index == NULL_RTX 980 || parts.index == arg_pointer_rtx 981 || parts.index == frame_pointer_rtx 982 || parts.index == hard_frame_pointer_rtx 983 || parts.index == stack_pointer_rtx) 984 return true; 985 986 return false; 987}) 988 989 990;; Return true if OP is memory operand that cannot be represented 991;; by the modRM array. 992(define_predicate "long_memory_operand" 993 (and (match_operand 0 "memory_operand") 994 (match_test "memory_address_length (op)"))) 995 996;; Return true if OP is a comparison operator that can be issued by fcmov. 997(define_predicate "fcmov_comparison_operator" 998 (match_operand 0 "comparison_operator") 999{ 1000 enum machine_mode inmode = GET_MODE (XEXP (op, 0)); 1001 enum rtx_code code = GET_CODE (op); 1002 1003 if (inmode == CCFPmode || inmode == CCFPUmode) 1004 { 1005 if (!ix86_trivial_fp_comparison_operator (op, mode)) 1006 return false; 1007 code = ix86_fp_compare_code_to_integer (code); 1008 } 1009 /* i387 supports just limited amount of conditional codes. */ 1010 switch (code) 1011 { 1012 case LTU: case GTU: case LEU: case GEU: 1013 if (inmode == CCmode || inmode == CCFPmode || inmode == CCFPUmode 1014 || inmode == CCCmode) 1015 return true; 1016 return false; 1017 case ORDERED: case UNORDERED: 1018 case EQ: case NE: 1019 return true; 1020 default: 1021 return false; 1022 } 1023}) 1024 1025;; Return true if OP is a comparison that can be used in the CMPSS/CMPPS insns. 1026;; The first set are supported directly; the second set can't be done with 1027;; full IEEE support, i.e. NaNs. 1028 1029(define_predicate "sse_comparison_operator" 1030 (ior (match_code "eq,ne,lt,le,unordered,unge,ungt,ordered") 1031 (and (match_test "TARGET_AVX") 1032 (match_code "ge,gt,uneq,unle,unlt,ltgt")))) 1033 1034(define_predicate "ix86_comparison_int_operator" 1035 (match_code "ne,eq,ge,gt,le,lt")) 1036 1037(define_predicate "ix86_comparison_uns_operator" 1038 (match_code "ne,eq,geu,gtu,leu,ltu")) 1039 1040(define_predicate "bt_comparison_operator" 1041 (match_code "ne,eq")) 1042 1043;; Return true if OP is a valid comparison operator in valid mode. 1044(define_predicate "ix86_comparison_operator" 1045 (match_operand 0 "comparison_operator") 1046{ 1047 enum machine_mode inmode = GET_MODE (XEXP (op, 0)); 1048 enum rtx_code code = GET_CODE (op); 1049 1050 if (inmode == CCFPmode || inmode == CCFPUmode) 1051 return ix86_trivial_fp_comparison_operator (op, mode); 1052 1053 switch (code) 1054 { 1055 case EQ: case NE: 1056 return true; 1057 case LT: case GE: 1058 if (inmode == CCmode || inmode == CCGCmode 1059 || inmode == CCGOCmode || inmode == CCNOmode) 1060 return true; 1061 return false; 1062 case LTU: case GTU: case LEU: case GEU: 1063 if (inmode == CCmode || inmode == CCCmode) 1064 return true; 1065 return false; 1066 case ORDERED: case UNORDERED: 1067 if (inmode == CCmode) 1068 return true; 1069 return false; 1070 case GT: case LE: 1071 if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode) 1072 return true; 1073 return false; 1074 default: 1075 return false; 1076 } 1077}) 1078 1079;; Return true if OP is a valid comparison operator 1080;; testing carry flag to be set. 1081(define_predicate "ix86_carry_flag_operator" 1082 (match_code "ltu,lt,unlt,gtu,gt,ungt,le,unle,ge,unge,ltgt,uneq") 1083{ 1084 enum machine_mode inmode = GET_MODE (XEXP (op, 0)); 1085 enum rtx_code code = GET_CODE (op); 1086 1087 if (inmode == CCFPmode || inmode == CCFPUmode) 1088 { 1089 if (!ix86_trivial_fp_comparison_operator (op, mode)) 1090 return false; 1091 code = ix86_fp_compare_code_to_integer (code); 1092 } 1093 else if (inmode == CCCmode) 1094 return code == LTU || code == GTU; 1095 else if (inmode != CCmode) 1096 return false; 1097 1098 return code == LTU; 1099}) 1100 1101;; Return true if this comparison only requires testing one flag bit. 1102(define_predicate "ix86_trivial_fp_comparison_operator" 1103 (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered")) 1104 1105;; Return true if we know how to do this comparison. Others require 1106;; testing more than one flag bit, and we let the generic middle-end 1107;; code do that. 1108(define_predicate "ix86_fp_comparison_operator" 1109 (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op)) 1110 == IX86_FPCMP_ARITH") 1111 (match_operand 0 "comparison_operator") 1112 (match_operand 0 "ix86_trivial_fp_comparison_operator"))) 1113 1114;; Same as above, but for swapped comparison used in fp_jcc_4_387. 1115(define_predicate "ix86_swapped_fp_comparison_operator" 1116 (match_operand 0 "comparison_operator") 1117{ 1118 enum rtx_code code = GET_CODE (op); 1119 bool ret; 1120 1121 PUT_CODE (op, swap_condition (code)); 1122 ret = ix86_fp_comparison_operator (op, mode); 1123 PUT_CODE (op, code); 1124 return ret; 1125}) 1126 1127;; Nearly general operand, but accept any const_double, since we wish 1128;; to be able to drop them into memory rather than have them get pulled 1129;; into registers. 1130(define_predicate "cmp_fp_expander_operand" 1131 (ior (match_code "const_double") 1132 (match_operand 0 "general_operand"))) 1133 1134;; Return true if this is a valid binary floating-point operation. 1135(define_predicate "binary_fp_operator" 1136 (match_code "plus,minus,mult,div")) 1137 1138;; Return true if this is a multiply operation. 1139(define_predicate "mult_operator" 1140 (match_code "mult")) 1141 1142;; Return true if this is a division operation. 1143(define_predicate "div_operator" 1144 (match_code "div")) 1145 1146;; Return true if this is a plus, minus, and, ior or xor operation. 1147(define_predicate "plusminuslogic_operator" 1148 (match_code "plus,minus,and,ior,xor")) 1149 1150;; Return true if this is a float extend operation. 1151(define_predicate "float_operator" 1152 (match_code "float")) 1153 1154;; Return true for ARITHMETIC_P. 1155(define_predicate "arith_or_logical_operator" 1156 (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div, 1157 mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert")) 1158 1159;; Return true for COMMUTATIVE_P. 1160(define_predicate "commutative_operator" 1161 (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax")) 1162 1163;; Return true if OP is a binary operator that can be promoted to wider mode. 1164(define_predicate "promotable_binary_operator" 1165 (ior (match_code "plus,minus,and,ior,xor,ashift") 1166 (and (match_code "mult") 1167 (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL")))) 1168 1169(define_predicate "compare_operator" 1170 (match_code "compare")) 1171 1172(define_predicate "absneg_operator" 1173 (match_code "abs,neg")) 1174 1175;; Return true if OP is misaligned memory operand 1176(define_predicate "misaligned_operand" 1177 (and (match_code "mem") 1178 (match_test "MEM_ALIGN (op) < GET_MODE_ALIGNMENT (mode)"))) 1179 1180;; Return true if OP is a emms operation, known to be a PARALLEL. 1181(define_predicate "emms_operation" 1182 (match_code "parallel") 1183{ 1184 unsigned i; 1185 1186 if (XVECLEN (op, 0) != 17) 1187 return false; 1188 1189 for (i = 0; i < 8; i++) 1190 { 1191 rtx elt = XVECEXP (op, 0, i+1); 1192 1193 if (GET_CODE (elt) != CLOBBER 1194 || GET_CODE (SET_DEST (elt)) != REG 1195 || GET_MODE (SET_DEST (elt)) != XFmode 1196 || REGNO (SET_DEST (elt)) != FIRST_STACK_REG + i) 1197 return false; 1198 1199 elt = XVECEXP (op, 0, i+9); 1200 1201 if (GET_CODE (elt) != CLOBBER 1202 || GET_CODE (SET_DEST (elt)) != REG 1203 || GET_MODE (SET_DEST (elt)) != DImode 1204 || REGNO (SET_DEST (elt)) != FIRST_MMX_REG + i) 1205 return false; 1206 } 1207 return true; 1208}) 1209 1210;; Return true if OP is a vzeroall operation, known to be a PARALLEL. 1211(define_predicate "vzeroall_operation" 1212 (match_code "parallel") 1213{ 1214 unsigned i, nregs = TARGET_64BIT ? 16 : 8; 1215 1216 if ((unsigned) XVECLEN (op, 0) != 1 + nregs) 1217 return false; 1218 1219 for (i = 0; i < nregs; i++) 1220 { 1221 rtx elt = XVECEXP (op, 0, i+1); 1222 1223 if (GET_CODE (elt) != SET 1224 || GET_CODE (SET_DEST (elt)) != REG 1225 || GET_MODE (SET_DEST (elt)) != V8SImode 1226 || REGNO (SET_DEST (elt)) != SSE_REGNO (i) 1227 || SET_SRC (elt) != CONST0_RTX (V8SImode)) 1228 return false; 1229 } 1230 return true; 1231}) 1232 1233;; Return true if OP is a parallel for a vbroadcast permute. 1234 1235(define_predicate "avx_vbroadcast_operand" 1236 (and (match_code "parallel") 1237 (match_code "const_int" "a")) 1238{ 1239 rtx elt = XVECEXP (op, 0, 0); 1240 int i, nelt = XVECLEN (op, 0); 1241 1242 /* Don't bother checking there are the right number of operands, 1243 merely that they're all identical. */ 1244 for (i = 1; i < nelt; ++i) 1245 if (XVECEXP (op, 0, i) != elt) 1246 return false; 1247 return true; 1248}) 1249 1250;; Return true if OP is a proper third operand to vpblendw256. 1251(define_predicate "avx2_pblendw_operand" 1252 (match_code "const_int") 1253{ 1254 HOST_WIDE_INT val = INTVAL (op); 1255 HOST_WIDE_INT low = val & 0xff; 1256 return val == ((low << 8) | low); 1257}) 1258