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