1;; Predicate definitions for DEC Alpha. 2;; Copyright (C) 2004-2019 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;; Return 1 if OP is the zero constant for MODE. 21(define_predicate "const0_operand" 22 (and (match_code "const_int,const_wide_int,const_double,const_vector") 23 (match_test "op == CONST0_RTX (mode)"))) 24 25;; Returns true if OP is either the constant zero or a register. 26(define_predicate "reg_or_0_operand" 27 (ior (match_operand 0 "register_operand") 28 (match_operand 0 "const0_operand"))) 29 30;; Return 1 if OP is a constant in the range of 0-63 (for a shift) or 31;; any register. 32(define_predicate "reg_or_6bit_operand" 33 (if_then_else (match_code "const_int") 34 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 64") 35 (match_operand 0 "register_operand"))) 36 37;; Return 1 if OP is an 8-bit constant. 38(define_predicate "cint8_operand" 39 (and (match_code "const_int") 40 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 256"))) 41 42;; Return 1 if OP is an 8-bit constant or any register. 43(define_predicate "reg_or_8bit_operand" 44 (if_then_else (match_code "const_int") 45 (match_test "INTVAL (op) >= 0 && INTVAL (op) < 256") 46 (match_operand 0 "register_operand"))) 47 48;; Return 1 if OP is a constant or any register. 49(define_predicate "reg_or_cint_operand" 50 (ior (match_operand 0 "register_operand") 51 (match_operand 0 "const_int_operand"))) 52 53;; Return 1 if the operand is a valid second operand to an add insn. 54(define_predicate "add_operand" 55 (if_then_else (match_code "const_int") 56 (match_test "satisfies_constraint_K (op) || satisfies_constraint_L (op)") 57 (match_operand 0 "register_operand"))) 58 59;; Return 1 if the operand is a valid second operand to a 60;; sign-extending add insn. 61(define_predicate "sext_add_operand" 62 (if_then_else (match_code "const_int") 63 (match_test "satisfies_constraint_I (op) || satisfies_constraint_O (op)") 64 (match_operand 0 "register_operand"))) 65 66;; Return 1 if the operand is a non-symbolic constant operand that 67;; does not satisfy add_operand. 68(define_predicate "non_add_const_operand" 69 (and (match_code "const_int,const_wide_int,const_double,const_vector") 70 (not (match_operand 0 "add_operand")))) 71 72;; Return 1 if the operand is a non-symbolic, nonzero constant operand. 73(define_predicate "non_zero_const_operand" 74 (and (match_code "const_int,const_wide_int,const_double,const_vector") 75 (not (match_test "op == CONST0_RTX (mode)")))) 76 77;; Return 1 if OP is the constant 1, 2 or 3. 78(define_predicate "const123_operand" 79 (and (match_code "const_int") 80 (match_test "IN_RANGE (INTVAL (op), 1, 3)"))) 81 82;; Return 1 if OP is the constant 2 or 3. 83(define_predicate "const23_operand" 84 (and (match_code "const_int") 85 (match_test "INTVAL (op) == 2 || INTVAL (op) == 3"))) 86 87;; Return 1 if OP is the constant 4 or 8. 88(define_predicate "const48_operand" 89 (and (match_code "const_int") 90 (match_test "INTVAL (op) == 4 || INTVAL (op) == 8"))) 91 92;; Return 1 if OP is a valid first operand to an AND insn. 93(define_predicate "and_operand" 94 (if_then_else (match_code "const_int") 95 (match_test "(unsigned HOST_WIDE_INT) INTVAL (op) < 0x100 96 || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100 97 || zap_mask (INTVAL (op))") 98 (match_operand 0 "register_operand"))) 99 100;; Return 1 if OP is a valid first operand to an IOR or XOR insn. 101(define_predicate "or_operand" 102 (if_then_else (match_code "const_int") 103 (match_test "(unsigned HOST_WIDE_INT) INTVAL (op) < 0x100 104 || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100") 105 (match_operand 0 "register_operand"))) 106 107;; Return 1 if OP is a constant that is the width, in bits, of an integral 108;; mode not larger than DImode. 109(define_predicate "mode_width_operand" 110 (match_code "const_int") 111{ 112 HOST_WIDE_INT i = INTVAL (op); 113 return i == 8 || i == 16 || i == 32 || i == 64; 114}) 115 116;; Return 1 if OP is a constant that is a mask of ones of width of an 117;; integral machine mode not larger than DImode. 118(define_predicate "mode_mask_operand" 119 (match_code "const_int") 120{ 121 HOST_WIDE_INT value = INTVAL (op); 122 123 if (value == 0xff) 124 return 1; 125 if (value == 0xffff) 126 return 1; 127 if (value == 0xffffffff) 128 return 1; 129 if (value == -1) 130 return 1; 131 132 return 0; 133}) 134 135;; Return 1 if OP is a multiple of 8 less than 64. 136(define_predicate "mul8_operand" 137 (match_code "const_int") 138{ 139 unsigned HOST_WIDE_INT i = INTVAL (op); 140 return i < 64 && i % 8 == 0; 141}) 142 143;; Return 1 if OP is a hard floating-point register. 144(define_predicate "hard_fp_register_operand" 145 (match_operand 0 "register_operand") 146{ 147 if (SUBREG_P (op)) 148 op = SUBREG_REG (op); 149 return REGNO_REG_CLASS (REGNO (op)) == FLOAT_REGS; 150}) 151 152;; Return 1 if OP is a hard general register. 153(define_predicate "hard_int_register_operand" 154 (match_operand 0 "register_operand") 155{ 156 if (SUBREG_P (op)) 157 op = SUBREG_REG (op); 158 return REGNO_REG_CLASS (REGNO (op)) == GENERAL_REGS; 159}) 160 161;; Return 1 if OP is a valid operand for the source of a move insn. 162(define_predicate "input_operand" 163 (match_operand 0 "general_operand") 164{ 165 switch (GET_CODE (op)) 166 { 167 case LABEL_REF: 168 case SYMBOL_REF: 169 case CONST: 170 if (TARGET_EXPLICIT_RELOCS) 171 { 172 /* We don't split symbolic operands into something unintelligable 173 until after reload, but we do not wish non-small, non-global 174 symbolic operands to be reconstructed from their high/lo_sum 175 form. */ 176 return (small_symbolic_operand (op, mode) 177 || global_symbolic_operand (op, mode) 178 || gotdtp_symbolic_operand (op, mode) 179 || gottp_symbolic_operand (op, mode)); 180 } 181 /* VMS still has a 32-bit mode. */ 182 return mode == ptr_mode || mode == Pmode; 183 184 case HIGH: 185 return (TARGET_EXPLICIT_RELOCS 186 && local_symbolic_operand (XEXP (op, 0), mode)); 187 188 case REG: 189 return 1; 190 191 case SUBREG: 192 if (register_operand (op, mode)) 193 return 1; 194 /* fall through */ 195 case MEM: 196 return ((TARGET_BWX || (mode != HImode && mode != QImode)) 197 && general_operand (op, mode)); 198 199 case CONST_WIDE_INT: 200 case CONST_DOUBLE: 201 return op == CONST0_RTX (mode); 202 203 case CONST_VECTOR: 204 if (reload_in_progress || reload_completed) 205 return alpha_legitimate_constant_p (mode, op); 206 return op == CONST0_RTX (mode); 207 208 case CONST_INT: 209 if (mode == QImode || mode == HImode) 210 return true; 211 if (reload_in_progress || reload_completed) 212 return alpha_legitimate_constant_p (mode, op); 213 return add_operand (op, mode); 214 215 default: 216 gcc_unreachable (); 217 } 218 return 0; 219}) 220 221;; Return 1 if OP is a SYMBOL_REF for a function known to be in this 222;; file, and in the same section as the current function. 223 224(define_predicate "samegp_function_operand" 225 (match_code "symbol_ref") 226{ 227 /* Easy test for recursion. */ 228 if (op == XEXP (DECL_RTL (current_function_decl), 0)) 229 return true; 230 231 /* Functions that are not local can be overridden, and thus may 232 not share the same gp. */ 233 if (! SYMBOL_REF_LOCAL_P (op)) 234 return false; 235 236 /* If -msmall-data is in effect, assume that there is only one GP 237 for the module, and so any local symbol has this property. We 238 need explicit relocations to be able to enforce this for symbols 239 not defined in this unit of translation, however. */ 240 if (TARGET_EXPLICIT_RELOCS && TARGET_SMALL_DATA) 241 return true; 242 243 /* Functions that are not external are defined in this UoT, 244 and thus must share the same gp. */ 245 return ! SYMBOL_REF_EXTERNAL_P (op); 246}) 247 248;; Return 1 if OP is a SYMBOL_REF for which we can make a call via bsr. 249(define_predicate "direct_call_operand" 250 (match_operand 0 "samegp_function_operand") 251{ 252 /* If profiling is implemented via linker tricks, we can't jump 253 to the nogp alternate entry point. Note that crtl->profile 254 would not be correct, since that doesn't indicate if the target 255 function uses profiling. */ 256 /* ??? TARGET_PROFILING_NEEDS_GP isn't really the right test, 257 but is approximately correct for the OSF ABIs. Don't know 258 what to do for VMS, NT, or UMK. */ 259 if (!TARGET_PROFILING_NEEDS_GP && profile_flag) 260 return false; 261 262 /* Must be a function. In some cases folks create thunks in static 263 data structures and then make calls to them. If we allow the 264 direct call, we'll get an error from the linker about !samegp reloc 265 against a symbol without a .prologue directive. */ 266 if (!SYMBOL_REF_FUNCTION_P (op)) 267 return false; 268 269 /* Must be "near" so that the branch is assumed to reach. With 270 -msmall-text, this is assumed true of all local symbols. Since 271 we've already checked samegp, locality is already assured. */ 272 if (TARGET_SMALL_TEXT) 273 return true; 274 275 return false; 276}) 277 278;; Return 1 if OP is a valid operand for the MEM of a CALL insn. 279;; 280;; For TARGET_ABI_OSF, we want to restrict to R27 or a pseudo. 281 282(define_predicate "call_operand" 283 (ior (match_code "symbol_ref") 284 (and (match_code "reg") 285 (ior (not (match_test "TARGET_ABI_OSF")) 286 (not (match_test "HARD_REGISTER_P (op)")) 287 (match_test "REGNO (op) == R27_REG"))))) 288 289;; Return true if OP is a LABEL_REF, or SYMBOL_REF or CONST referencing 290;; a (non-tls) variable known to be defined in this file. 291(define_predicate "local_symbolic_operand" 292 (match_code "label_ref,const,symbol_ref") 293{ 294 if (GET_CODE (op) == CONST 295 && GET_CODE (XEXP (op, 0)) == PLUS 296 && CONST_INT_P (XEXP (XEXP (op, 0), 1))) 297 op = XEXP (XEXP (op, 0), 0); 298 299 if (GET_CODE (op) == LABEL_REF) 300 return 1; 301 302 if (GET_CODE (op) != SYMBOL_REF) 303 return 0; 304 305 return (SYMBOL_REF_LOCAL_P (op) 306 && !SYMBOL_REF_WEAK (op) 307 && !SYMBOL_REF_TLS_MODEL (op)); 308}) 309 310;; Return true if OP is a SYMBOL_REF or CONST referencing a variable 311;; known to be defined in this file in the small data area. 312(define_predicate "small_symbolic_operand" 313 (match_code "const,symbol_ref") 314{ 315 HOST_WIDE_INT ofs = 0, max_ofs = 0; 316 317 if (! TARGET_SMALL_DATA) 318 return false; 319 320 if (GET_CODE (op) == CONST 321 && GET_CODE (XEXP (op, 0)) == PLUS 322 && CONST_INT_P (XEXP (XEXP (op, 0), 1))) 323 { 324 ofs = INTVAL (XEXP (XEXP (op, 0), 1)); 325 op = XEXP (XEXP (op, 0), 0); 326 } 327 328 if (GET_CODE (op) != SYMBOL_REF) 329 return false; 330 331 /* ??? There's no encode_section_info equivalent for the rtl 332 constant pool, so SYMBOL_FLAG_SMALL never gets set. */ 333 if (CONSTANT_POOL_ADDRESS_P (op)) 334 { 335 max_ofs = GET_MODE_SIZE (get_pool_mode (op)); 336 if (max_ofs > g_switch_value) 337 return false; 338 } 339 else if (SYMBOL_REF_LOCAL_P (op) 340 && SYMBOL_REF_SMALL_P (op) 341 && !SYMBOL_REF_WEAK (op) 342 && !SYMBOL_REF_TLS_MODEL (op)) 343 { 344 if (SYMBOL_REF_DECL (op)) 345 max_ofs = tree_to_uhwi (DECL_SIZE_UNIT (SYMBOL_REF_DECL (op))); 346 } 347 else 348 return false; 349 350 /* Given that we know that the GP is always 8 byte aligned, we can 351 always adjust by 7 without overflowing. */ 352 if (max_ofs < 8) 353 max_ofs = 8; 354 355 /* Since we know this is an object in a small data section, we know the 356 entire section is addressable via GP. We don't know where the section 357 boundaries are, but we know the entire object is within. */ 358 return IN_RANGE (ofs, 0, max_ofs - 1); 359}) 360 361;; Return true if OP is a SYMBOL_REF or CONST referencing a variable 362;; not known (or known not) to be defined in this file. 363(define_predicate "global_symbolic_operand" 364 (match_code "const,symbol_ref") 365{ 366 if (GET_CODE (op) == CONST 367 && GET_CODE (XEXP (op, 0)) == PLUS 368 && CONST_INT_P (XEXP (XEXP (op, 0), 1))) 369 op = XEXP (XEXP (op, 0), 0); 370 371 if (GET_CODE (op) != SYMBOL_REF) 372 return 0; 373 374 return ((!SYMBOL_REF_LOCAL_P (op) || SYMBOL_REF_WEAK (op)) 375 && !SYMBOL_REF_TLS_MODEL (op)); 376}) 377 378;; Returns 1 if OP is a symbolic operand, i.e. a symbol_ref or a label_ref, 379;; possibly with an offset. 380(define_predicate "symbolic_operand" 381 (ior (match_code "symbol_ref,label_ref") 382 (and (match_code "const") 383 (match_code "plus" "0") 384 (match_code "symbol_ref,label_ref" "00") 385 (match_code "const_int" "01")))) 386 387;; Return true if OP is valid for 16-bit DTP relative relocations. 388(define_predicate "dtp16_symbolic_operand" 389 (and (match_code "const") 390 (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_DTPREL)"))) 391 392;; Return true if OP is valid for 32-bit DTP relative relocations. 393(define_predicate "dtp32_symbolic_operand" 394 (and (match_code "const") 395 (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_DTPREL)"))) 396 397;; Return true if OP is valid for 64-bit DTP relative relocations. 398(define_predicate "gotdtp_symbolic_operand" 399 (and (match_code "const") 400 (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_DTPREL)"))) 401 402;; Return true if OP is valid for 16-bit TP relative relocations. 403(define_predicate "tp16_symbolic_operand" 404 (and (match_code "const") 405 (match_test "tls_symbolic_operand_1 (op, 16, UNSPEC_TPREL)"))) 406 407;; Return true if OP is valid for 32-bit TP relative relocations. 408(define_predicate "tp32_symbolic_operand" 409 (and (match_code "const") 410 (match_test "tls_symbolic_operand_1 (op, 32, UNSPEC_TPREL)"))) 411 412;; Return true if OP is valid for 64-bit TP relative relocations. 413(define_predicate "gottp_symbolic_operand" 414 (and (match_code "const") 415 (match_test "tls_symbolic_operand_1 (op, 64, UNSPEC_TPREL)"))) 416 417;; Return 1 if this memory address is a known aligned register plus 418;; a constant. It must be a valid address. This means that we can do 419;; this as an aligned reference plus some offset. 420;; 421;; Take into account what reload will do. Oh god this is awful. 422;; The horrible comma-operator construct below is to prevent genrecog 423;; from thinking that this predicate accepts REG and SUBREG. We don't 424;; use recog during reload, so pretending these codes are accepted 425;; pessimizes things a tad. 426 427(define_special_predicate "aligned_memory_operand" 428 (ior (match_test "op = resolve_reload_operand (op), 0") 429 (match_code "mem")) 430{ 431 rtx base; 432 int offset; 433 434 if (MEM_ALIGN (op) >= 32) 435 return 1; 436 437 op = XEXP (op, 0); 438 439 /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo) 440 sorts of constructs. Dig for the real base register. */ 441 if (reload_in_progress 442 && GET_CODE (op) == PLUS 443 && GET_CODE (XEXP (op, 0)) == PLUS) 444 { 445 base = XEXP (XEXP (op, 0), 0); 446 offset = INTVAL (XEXP (op, 1)); 447 } 448 else 449 { 450 if (! memory_address_p (mode, op)) 451 return 0; 452 if (GET_CODE (op) == PLUS) 453 { 454 base = XEXP (op, 0); 455 offset = INTVAL (XEXP (op, 1)); 456 } 457 else 458 { 459 base = op; 460 offset = 0; 461 } 462 } 463 464 if (offset % GET_MODE_SIZE (mode)) 465 return 0; 466 467 return (REG_P (base) && REGNO_POINTER_ALIGN (REGNO (base)) >= 32); 468}) 469 470;; Similar, but return 1 if OP is a MEM which is not alignable. 471 472(define_special_predicate "unaligned_memory_operand" 473 (ior (match_test "op = resolve_reload_operand (op), 0") 474 (match_code "mem")) 475{ 476 rtx base; 477 int offset; 478 479 if (MEM_ALIGN (op) >= 32) 480 return 0; 481 482 op = XEXP (op, 0); 483 484 /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo) 485 sorts of constructs. Dig for the real base register. */ 486 if (reload_in_progress 487 && GET_CODE (op) == PLUS 488 && GET_CODE (XEXP (op, 0)) == PLUS) 489 { 490 base = XEXP (XEXP (op, 0), 0); 491 offset = INTVAL (XEXP (op, 1)); 492 } 493 else 494 { 495 if (! memory_address_p (mode, op)) 496 return 0; 497 if (GET_CODE (op) == PLUS) 498 { 499 base = XEXP (op, 0); 500 offset = INTVAL (XEXP (op, 1)); 501 } 502 else 503 { 504 base = op; 505 offset = 0; 506 } 507 } 508 509 if (offset % GET_MODE_SIZE (mode)) 510 return 1; 511 512 return (REG_P (base) && REGNO_POINTER_ALIGN (REGNO (base)) < 32); 513}) 514 515;; Return 1 if OP is any memory location. During reload a pseudo matches. 516(define_special_predicate "any_memory_operand" 517 (match_code "mem,reg,subreg") 518{ 519 if (SUBREG_P (op)) 520 op = SUBREG_REG (op); 521 522 if (MEM_P (op)) 523 return true; 524 if (reload_in_progress && REG_P (op)) 525 { 526 unsigned regno = REGNO (op); 527 if (HARD_REGISTER_NUM_P (regno)) 528 return false; 529 else 530 return reg_renumber[regno] < 0; 531 } 532 533 return false; 534}) 535 536;; Returns 1 if OP is not an eliminable register. 537;; 538;; This exists to cure a pathological failure in the s8addq (et al) patterns, 539;; 540;; long foo () { long t; bar(); return (long) &t * 26107; } 541;; 542;; which run afoul of a hack in reload to cure a (presumably) similar 543;; problem with lea-type instructions on other targets. But there is 544;; one of us and many of them, so work around the problem by selectively 545;; preventing combine from making the optimization. 546 547(define_predicate "reg_not_elim_operand" 548 (match_operand 0 "register_operand") 549{ 550 if (SUBREG_P (op)) 551 op = SUBREG_REG (op); 552 return op != frame_pointer_rtx && op != arg_pointer_rtx; 553}) 554 555;; Accept a register, but not a subreg of any kind. This allows us to 556;; avoid pathological cases in reload wrt data movement common in 557;; int->fp conversion. */ 558(define_predicate "reg_no_subreg_operand" 559 (and (match_code "reg") 560 (match_operand 0 "register_operand"))) 561 562;; Return 1 if OP is a valid Alpha comparison operator for "cbranch" 563;; instructions. 564(define_predicate "alpha_cbranch_operator" 565 (ior (match_operand 0 "ordered_comparison_operator") 566 (match_code "ordered,unordered"))) 567 568;; Return 1 if OP is a valid Alpha comparison operator for "cmp" style 569;; instructions. 570(define_predicate "alpha_comparison_operator" 571 (match_code "eq,le,lt,leu,ltu")) 572 573;; Similarly, but with swapped operands. 574(define_predicate "alpha_swapped_comparison_operator" 575 (match_code "eq,ge,gt,gtu")) 576 577;; Return 1 if OP is a valid Alpha comparison operator against zero 578;; for "bcc" style instructions. 579(define_predicate "alpha_zero_comparison_operator" 580 (match_code "eq,ne,le,lt,leu,ltu")) 581 582;; Return 1 if OP is a signed comparison operation. 583(define_predicate "signed_comparison_operator" 584 (match_code "eq,ne,le,lt,ge,gt")) 585 586;; Return 1 if OP is a valid Alpha floating point comparison operator. 587(define_predicate "alpha_fp_comparison_operator" 588 (match_code "eq,le,lt,unordered")) 589 590;; Return 1 if this is a divide or modulus operator. 591(define_predicate "divmod_operator" 592 (match_code "div,mod,udiv,umod")) 593 594;; Return 1 if this is a float->int conversion operator. 595(define_predicate "fix_operator" 596 (match_code "fix,unsigned_fix")) 597 598;; Recognize an addition operation that includes a constant. Used to 599;; convince reload to canonize (plus (plus reg c1) c2) during register 600;; elimination. 601 602(define_predicate "addition_operation" 603 (and (match_code "plus") 604 (match_test "register_operand (XEXP (op, 0), mode) 605 && satisfies_constraint_K (XEXP (op, 1))"))) 606 607;; For TARGET_EXPLICIT_RELOCS, we don't obfuscate a SYMBOL_REF to a 608;; small symbolic operand until after reload. At which point we need 609;; to replace (mem (symbol_ref)) with (mem (lo_sum $29 symbol_ref)) 610;; so that sched2 has the proper dependency information. */ 611(define_predicate "some_small_symbolic_operand" 612 (match_code "set,parallel,prefetch,unspec,unspec_volatile") 613{ 614 /* Avoid search unless necessary. */ 615 if (!TARGET_EXPLICIT_RELOCS || !reload_completed) 616 return false; 617 return some_small_symbolic_operand_int (op); 618}) 619 620;; Accept a register, or a memory if BWX is enabled. 621(define_predicate "reg_or_bwx_memory_operand" 622 (ior (match_operand 0 "register_operand") 623 (and (match_test "TARGET_BWX") 624 (match_operand 0 "memory_operand")))) 625 626;; Accept a memory whose address is only a register. 627(define_predicate "mem_noofs_operand" 628 (and (match_code "mem") 629 (match_code "reg" "0"))) 630