1 /* Subroutines for manipulating rtx's in semantically interesting ways. 2 Copyright (C) 1987-2018 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 it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 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 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "target.h" 25 #include "function.h" 26 #include "rtl.h" 27 #include "tree.h" 28 #include "memmodel.h" 29 #include "tm_p.h" 30 #include "expmed.h" 31 #include "profile-count.h" 32 #include "optabs.h" 33 #include "emit-rtl.h" 34 #include "recog.h" 35 #include "diagnostic-core.h" 36 #include "stor-layout.h" 37 #include "except.h" 38 #include "dojump.h" 39 #include "explow.h" 40 #include "expr.h" 41 #include "common/common-target.h" 42 #include "output.h" 43 #include "params.h" 44 45 static rtx break_out_memory_refs (rtx); 46 static void anti_adjust_stack_and_probe_stack_clash (rtx); 47 48 49 /* Truncate and perhaps sign-extend C as appropriate for MODE. */ 50 51 HOST_WIDE_INT 52 trunc_int_for_mode (HOST_WIDE_INT c, machine_mode mode) 53 { 54 /* Not scalar_int_mode because we also allow pointer bound modes. */ 55 scalar_mode smode = as_a <scalar_mode> (mode); 56 int width = GET_MODE_PRECISION (smode); 57 58 /* You want to truncate to a _what_? */ 59 gcc_assert (SCALAR_INT_MODE_P (mode) 60 || POINTER_BOUNDS_MODE_P (mode)); 61 62 /* Canonicalize BImode to 0 and STORE_FLAG_VALUE. */ 63 if (smode == BImode) 64 return c & 1 ? STORE_FLAG_VALUE : 0; 65 66 /* Sign-extend for the requested mode. */ 67 68 if (width < HOST_BITS_PER_WIDE_INT) 69 { 70 HOST_WIDE_INT sign = 1; 71 sign <<= width - 1; 72 c &= (sign << 1) - 1; 73 c ^= sign; 74 c -= sign; 75 } 76 77 return c; 78 } 79 80 /* Likewise for polynomial values, using the sign-extended representation 81 for each individual coefficient. */ 82 83 poly_int64 84 trunc_int_for_mode (poly_int64 x, machine_mode mode) 85 { 86 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i) 87 x.coeffs[i] = trunc_int_for_mode (x.coeffs[i], mode); 88 return x; 89 } 90 91 /* Return an rtx for the sum of X and the integer C, given that X has 92 mode MODE. INPLACE is true if X can be modified inplace or false 93 if it must be treated as immutable. */ 94 95 rtx 96 plus_constant (machine_mode mode, rtx x, poly_int64 c, bool inplace) 97 { 98 RTX_CODE code; 99 rtx y; 100 rtx tem; 101 int all_constant = 0; 102 103 gcc_assert (GET_MODE (x) == VOIDmode || GET_MODE (x) == mode); 104 105 if (known_eq (c, 0)) 106 return x; 107 108 restart: 109 110 code = GET_CODE (x); 111 y = x; 112 113 switch (code) 114 { 115 CASE_CONST_SCALAR_INT: 116 return immed_wide_int_const (wi::add (rtx_mode_t (x, mode), c), mode); 117 case MEM: 118 /* If this is a reference to the constant pool, try replacing it with 119 a reference to a new constant. If the resulting address isn't 120 valid, don't return it because we have no way to validize it. */ 121 if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF 122 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0))) 123 { 124 rtx cst = get_pool_constant (XEXP (x, 0)); 125 126 if (GET_CODE (cst) == CONST_VECTOR 127 && GET_MODE_INNER (GET_MODE (cst)) == mode) 128 { 129 cst = gen_lowpart (mode, cst); 130 gcc_assert (cst); 131 } 132 if (GET_MODE (cst) == VOIDmode || GET_MODE (cst) == mode) 133 { 134 tem = plus_constant (mode, cst, c); 135 tem = force_const_mem (GET_MODE (x), tem); 136 /* Targets may disallow some constants in the constant pool, thus 137 force_const_mem may return NULL_RTX. */ 138 if (tem && memory_address_p (GET_MODE (tem), XEXP (tem, 0))) 139 return tem; 140 } 141 } 142 break; 143 144 case CONST: 145 /* If adding to something entirely constant, set a flag 146 so that we can add a CONST around the result. */ 147 if (inplace && shared_const_p (x)) 148 inplace = false; 149 x = XEXP (x, 0); 150 all_constant = 1; 151 goto restart; 152 153 case SYMBOL_REF: 154 case LABEL_REF: 155 all_constant = 1; 156 break; 157 158 case PLUS: 159 /* The interesting case is adding the integer to a sum. Look 160 for constant term in the sum and combine with C. For an 161 integer constant term or a constant term that is not an 162 explicit integer, we combine or group them together anyway. 163 164 We may not immediately return from the recursive call here, lest 165 all_constant gets lost. */ 166 167 if (CONSTANT_P (XEXP (x, 1))) 168 { 169 rtx term = plus_constant (mode, XEXP (x, 1), c, inplace); 170 if (term == const0_rtx) 171 x = XEXP (x, 0); 172 else if (inplace) 173 XEXP (x, 1) = term; 174 else 175 x = gen_rtx_PLUS (mode, XEXP (x, 0), term); 176 c = 0; 177 } 178 else if (rtx *const_loc = find_constant_term_loc (&y)) 179 { 180 if (!inplace) 181 { 182 /* We need to be careful since X may be shared and we can't 183 modify it in place. */ 184 x = copy_rtx (x); 185 const_loc = find_constant_term_loc (&x); 186 } 187 *const_loc = plus_constant (mode, *const_loc, c, true); 188 c = 0; 189 } 190 break; 191 192 default: 193 if (CONST_POLY_INT_P (x)) 194 return immed_wide_int_const (const_poly_int_value (x) + c, mode); 195 break; 196 } 197 198 if (maybe_ne (c, 0)) 199 x = gen_rtx_PLUS (mode, x, gen_int_mode (c, mode)); 200 201 if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF) 202 return x; 203 else if (all_constant) 204 return gen_rtx_CONST (mode, x); 205 else 206 return x; 207 } 208 209 /* If X is a sum, return a new sum like X but lacking any constant terms. 210 Add all the removed constant terms into *CONSTPTR. 211 X itself is not altered. The result != X if and only if 212 it is not isomorphic to X. */ 213 214 rtx 215 eliminate_constant_term (rtx x, rtx *constptr) 216 { 217 rtx x0, x1; 218 rtx tem; 219 220 if (GET_CODE (x) != PLUS) 221 return x; 222 223 /* First handle constants appearing at this level explicitly. */ 224 if (CONST_INT_P (XEXP (x, 1)) 225 && (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr, 226 XEXP (x, 1))) != 0 227 && CONST_INT_P (tem)) 228 { 229 *constptr = tem; 230 return eliminate_constant_term (XEXP (x, 0), constptr); 231 } 232 233 tem = const0_rtx; 234 x0 = eliminate_constant_term (XEXP (x, 0), &tem); 235 x1 = eliminate_constant_term (XEXP (x, 1), &tem); 236 if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0)) 237 && (tem = simplify_binary_operation (PLUS, GET_MODE (x), 238 *constptr, tem)) != 0 239 && CONST_INT_P (tem)) 240 { 241 *constptr = tem; 242 return gen_rtx_PLUS (GET_MODE (x), x0, x1); 243 } 244 245 return x; 246 } 247 248 249 /* Return a copy of X in which all memory references 250 and all constants that involve symbol refs 251 have been replaced with new temporary registers. 252 Also emit code to load the memory locations and constants 253 into those registers. 254 255 If X contains no such constants or memory references, 256 X itself (not a copy) is returned. 257 258 If a constant is found in the address that is not a legitimate constant 259 in an insn, it is left alone in the hope that it might be valid in the 260 address. 261 262 X may contain no arithmetic except addition, subtraction and multiplication. 263 Values returned by expand_expr with 1 for sum_ok fit this constraint. */ 264 265 static rtx 266 break_out_memory_refs (rtx x) 267 { 268 if (MEM_P (x) 269 || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x) 270 && GET_MODE (x) != VOIDmode)) 271 x = force_reg (GET_MODE (x), x); 272 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS 273 || GET_CODE (x) == MULT) 274 { 275 rtx op0 = break_out_memory_refs (XEXP (x, 0)); 276 rtx op1 = break_out_memory_refs (XEXP (x, 1)); 277 278 if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1)) 279 x = simplify_gen_binary (GET_CODE (x), GET_MODE (x), op0, op1); 280 } 281 282 return x; 283 } 284 285 /* Given X, a memory address in address space AS' pointer mode, convert it to 286 an address in the address space's address mode, or vice versa (TO_MODE says 287 which way). We take advantage of the fact that pointers are not allowed to 288 overflow by commuting arithmetic operations over conversions so that address 289 arithmetic insns can be used. IN_CONST is true if this conversion is inside 290 a CONST. NO_EMIT is true if no insns should be emitted, and instead 291 it should return NULL if it can't be simplified without emitting insns. */ 292 293 rtx 294 convert_memory_address_addr_space_1 (scalar_int_mode to_mode ATTRIBUTE_UNUSED, 295 rtx x, addr_space_t as ATTRIBUTE_UNUSED, 296 bool in_const ATTRIBUTE_UNUSED, 297 bool no_emit ATTRIBUTE_UNUSED) 298 { 299 #ifndef POINTERS_EXTEND_UNSIGNED 300 gcc_assert (GET_MODE (x) == to_mode || GET_MODE (x) == VOIDmode); 301 return x; 302 #else /* defined(POINTERS_EXTEND_UNSIGNED) */ 303 scalar_int_mode pointer_mode, address_mode, from_mode; 304 rtx temp; 305 enum rtx_code code; 306 307 /* If X already has the right mode, just return it. */ 308 if (GET_MODE (x) == to_mode) 309 return x; 310 311 pointer_mode = targetm.addr_space.pointer_mode (as); 312 address_mode = targetm.addr_space.address_mode (as); 313 from_mode = to_mode == pointer_mode ? address_mode : pointer_mode; 314 315 /* Here we handle some special cases. If none of them apply, fall through 316 to the default case. */ 317 switch (GET_CODE (x)) 318 { 319 CASE_CONST_SCALAR_INT: 320 if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)) 321 code = TRUNCATE; 322 else if (POINTERS_EXTEND_UNSIGNED < 0) 323 break; 324 else if (POINTERS_EXTEND_UNSIGNED > 0) 325 code = ZERO_EXTEND; 326 else 327 code = SIGN_EXTEND; 328 temp = simplify_unary_operation (code, to_mode, x, from_mode); 329 if (temp) 330 return temp; 331 break; 332 333 case SUBREG: 334 if ((SUBREG_PROMOTED_VAR_P (x) || REG_POINTER (SUBREG_REG (x))) 335 && GET_MODE (SUBREG_REG (x)) == to_mode) 336 return SUBREG_REG (x); 337 break; 338 339 case LABEL_REF: 340 temp = gen_rtx_LABEL_REF (to_mode, label_ref_label (x)); 341 LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x); 342 return temp; 343 344 case SYMBOL_REF: 345 temp = shallow_copy_rtx (x); 346 PUT_MODE (temp, to_mode); 347 return temp; 348 349 case CONST: 350 temp = convert_memory_address_addr_space_1 (to_mode, XEXP (x, 0), as, 351 true, no_emit); 352 return temp ? gen_rtx_CONST (to_mode, temp) : temp; 353 354 case PLUS: 355 case MULT: 356 /* For addition we can safely permute the conversion and addition 357 operation if one operand is a constant and converting the constant 358 does not change it or if one operand is a constant and we are 359 using a ptr_extend instruction (POINTERS_EXTEND_UNSIGNED < 0). 360 We can always safely permute them if we are making the address 361 narrower. Inside a CONST RTL, this is safe for both pointers 362 zero or sign extended as pointers cannot wrap. */ 363 if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode) 364 || (GET_CODE (x) == PLUS 365 && CONST_INT_P (XEXP (x, 1)) 366 && ((in_const && POINTERS_EXTEND_UNSIGNED != 0) 367 || XEXP (x, 1) == convert_memory_address_addr_space_1 368 (to_mode, XEXP (x, 1), as, in_const, 369 no_emit) 370 || POINTERS_EXTEND_UNSIGNED < 0))) 371 { 372 temp = convert_memory_address_addr_space_1 (to_mode, XEXP (x, 0), 373 as, in_const, no_emit); 374 return (temp ? gen_rtx_fmt_ee (GET_CODE (x), to_mode, 375 temp, XEXP (x, 1)) 376 : temp); 377 } 378 break; 379 380 default: 381 break; 382 } 383 384 if (no_emit) 385 return NULL_RTX; 386 387 return convert_modes (to_mode, from_mode, 388 x, POINTERS_EXTEND_UNSIGNED); 389 #endif /* defined(POINTERS_EXTEND_UNSIGNED) */ 390 } 391 392 /* Given X, a memory address in address space AS' pointer mode, convert it to 393 an address in the address space's address mode, or vice versa (TO_MODE says 394 which way). We take advantage of the fact that pointers are not allowed to 395 overflow by commuting arithmetic operations over conversions so that address 396 arithmetic insns can be used. */ 397 398 rtx 399 convert_memory_address_addr_space (scalar_int_mode to_mode, rtx x, 400 addr_space_t as) 401 { 402 return convert_memory_address_addr_space_1 (to_mode, x, as, false, false); 403 } 404 405 406 /* Return something equivalent to X but valid as a memory address for something 407 of mode MODE in the named address space AS. When X is not itself valid, 408 this works by copying X or subexpressions of it into registers. */ 409 410 rtx 411 memory_address_addr_space (machine_mode mode, rtx x, addr_space_t as) 412 { 413 rtx oldx = x; 414 scalar_int_mode address_mode = targetm.addr_space.address_mode (as); 415 416 x = convert_memory_address_addr_space (address_mode, x, as); 417 418 /* By passing constant addresses through registers 419 we get a chance to cse them. */ 420 if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)) 421 x = force_reg (address_mode, x); 422 423 /* We get better cse by rejecting indirect addressing at this stage. 424 Let the combiner create indirect addresses where appropriate. 425 For now, generate the code so that the subexpressions useful to share 426 are visible. But not if cse won't be done! */ 427 else 428 { 429 if (! cse_not_expected && !REG_P (x)) 430 x = break_out_memory_refs (x); 431 432 /* At this point, any valid address is accepted. */ 433 if (memory_address_addr_space_p (mode, x, as)) 434 goto done; 435 436 /* If it was valid before but breaking out memory refs invalidated it, 437 use it the old way. */ 438 if (memory_address_addr_space_p (mode, oldx, as)) 439 { 440 x = oldx; 441 goto done; 442 } 443 444 /* Perform machine-dependent transformations on X 445 in certain cases. This is not necessary since the code 446 below can handle all possible cases, but machine-dependent 447 transformations can make better code. */ 448 { 449 rtx orig_x = x; 450 x = targetm.addr_space.legitimize_address (x, oldx, mode, as); 451 if (orig_x != x && memory_address_addr_space_p (mode, x, as)) 452 goto done; 453 } 454 455 /* PLUS and MULT can appear in special ways 456 as the result of attempts to make an address usable for indexing. 457 Usually they are dealt with by calling force_operand, below. 458 But a sum containing constant terms is special 459 if removing them makes the sum a valid address: 460 then we generate that address in a register 461 and index off of it. We do this because it often makes 462 shorter code, and because the addresses thus generated 463 in registers often become common subexpressions. */ 464 if (GET_CODE (x) == PLUS) 465 { 466 rtx constant_term = const0_rtx; 467 rtx y = eliminate_constant_term (x, &constant_term); 468 if (constant_term == const0_rtx 469 || ! memory_address_addr_space_p (mode, y, as)) 470 x = force_operand (x, NULL_RTX); 471 else 472 { 473 y = gen_rtx_PLUS (GET_MODE (x), copy_to_reg (y), constant_term); 474 if (! memory_address_addr_space_p (mode, y, as)) 475 x = force_operand (x, NULL_RTX); 476 else 477 x = y; 478 } 479 } 480 481 else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS) 482 x = force_operand (x, NULL_RTX); 483 484 /* If we have a register that's an invalid address, 485 it must be a hard reg of the wrong class. Copy it to a pseudo. */ 486 else if (REG_P (x)) 487 x = copy_to_reg (x); 488 489 /* Last resort: copy the value to a register, since 490 the register is a valid address. */ 491 else 492 x = force_reg (address_mode, x); 493 } 494 495 done: 496 497 gcc_assert (memory_address_addr_space_p (mode, x, as)); 498 /* If we didn't change the address, we are done. Otherwise, mark 499 a reg as a pointer if we have REG or REG + CONST_INT. */ 500 if (oldx == x) 501 return x; 502 else if (REG_P (x)) 503 mark_reg_pointer (x, BITS_PER_UNIT); 504 else if (GET_CODE (x) == PLUS 505 && REG_P (XEXP (x, 0)) 506 && CONST_INT_P (XEXP (x, 1))) 507 mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT); 508 509 /* OLDX may have been the address on a temporary. Update the address 510 to indicate that X is now used. */ 511 update_temp_slot_address (oldx, x); 512 513 return x; 514 } 515 516 /* Convert a mem ref into one with a valid memory address. 517 Pass through anything else unchanged. */ 518 519 rtx 520 validize_mem (rtx ref) 521 { 522 if (!MEM_P (ref)) 523 return ref; 524 ref = use_anchored_address (ref); 525 if (memory_address_addr_space_p (GET_MODE (ref), XEXP (ref, 0), 526 MEM_ADDR_SPACE (ref))) 527 return ref; 528 529 /* Don't alter REF itself, since that is probably a stack slot. */ 530 return replace_equiv_address (ref, XEXP (ref, 0)); 531 } 532 533 /* If X is a memory reference to a member of an object block, try rewriting 534 it to use an anchor instead. Return the new memory reference on success 535 and the old one on failure. */ 536 537 rtx 538 use_anchored_address (rtx x) 539 { 540 rtx base; 541 HOST_WIDE_INT offset; 542 machine_mode mode; 543 544 if (!flag_section_anchors) 545 return x; 546 547 if (!MEM_P (x)) 548 return x; 549 550 /* Split the address into a base and offset. */ 551 base = XEXP (x, 0); 552 offset = 0; 553 if (GET_CODE (base) == CONST 554 && GET_CODE (XEXP (base, 0)) == PLUS 555 && CONST_INT_P (XEXP (XEXP (base, 0), 1))) 556 { 557 offset += INTVAL (XEXP (XEXP (base, 0), 1)); 558 base = XEXP (XEXP (base, 0), 0); 559 } 560 561 /* Check whether BASE is suitable for anchors. */ 562 if (GET_CODE (base) != SYMBOL_REF 563 || !SYMBOL_REF_HAS_BLOCK_INFO_P (base) 564 || SYMBOL_REF_ANCHOR_P (base) 565 || SYMBOL_REF_BLOCK (base) == NULL 566 || !targetm.use_anchors_for_symbol_p (base)) 567 return x; 568 569 /* Decide where BASE is going to be. */ 570 place_block_symbol (base); 571 572 /* Get the anchor we need to use. */ 573 offset += SYMBOL_REF_BLOCK_OFFSET (base); 574 base = get_section_anchor (SYMBOL_REF_BLOCK (base), offset, 575 SYMBOL_REF_TLS_MODEL (base)); 576 577 /* Work out the offset from the anchor. */ 578 offset -= SYMBOL_REF_BLOCK_OFFSET (base); 579 580 /* If we're going to run a CSE pass, force the anchor into a register. 581 We will then be able to reuse registers for several accesses, if the 582 target costs say that that's worthwhile. */ 583 mode = GET_MODE (base); 584 if (!cse_not_expected) 585 base = force_reg (mode, base); 586 587 return replace_equiv_address (x, plus_constant (mode, base, offset)); 588 } 589 590 /* Copy the value or contents of X to a new temp reg and return that reg. */ 591 592 rtx 593 copy_to_reg (rtx x) 594 { 595 rtx temp = gen_reg_rtx (GET_MODE (x)); 596 597 /* If not an operand, must be an address with PLUS and MULT so 598 do the computation. */ 599 if (! general_operand (x, VOIDmode)) 600 x = force_operand (x, temp); 601 602 if (x != temp) 603 emit_move_insn (temp, x); 604 605 return temp; 606 } 607 608 /* Like copy_to_reg but always give the new register mode Pmode 609 in case X is a constant. */ 610 611 rtx 612 copy_addr_to_reg (rtx x) 613 { 614 return copy_to_mode_reg (Pmode, x); 615 } 616 617 /* Like copy_to_reg but always give the new register mode MODE 618 in case X is a constant. */ 619 620 rtx 621 copy_to_mode_reg (machine_mode mode, rtx x) 622 { 623 rtx temp = gen_reg_rtx (mode); 624 625 /* If not an operand, must be an address with PLUS and MULT so 626 do the computation. */ 627 if (! general_operand (x, VOIDmode)) 628 x = force_operand (x, temp); 629 630 gcc_assert (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode); 631 if (x != temp) 632 emit_move_insn (temp, x); 633 return temp; 634 } 635 636 /* Load X into a register if it is not already one. 637 Use mode MODE for the register. 638 X should be valid for mode MODE, but it may be a constant which 639 is valid for all integer modes; that's why caller must specify MODE. 640 641 The caller must not alter the value in the register we return, 642 since we mark it as a "constant" register. */ 643 644 rtx 645 force_reg (machine_mode mode, rtx x) 646 { 647 rtx temp, set; 648 rtx_insn *insn; 649 650 if (REG_P (x)) 651 return x; 652 653 if (general_operand (x, mode)) 654 { 655 temp = gen_reg_rtx (mode); 656 insn = emit_move_insn (temp, x); 657 } 658 else 659 { 660 temp = force_operand (x, NULL_RTX); 661 if (REG_P (temp)) 662 insn = get_last_insn (); 663 else 664 { 665 rtx temp2 = gen_reg_rtx (mode); 666 insn = emit_move_insn (temp2, temp); 667 temp = temp2; 668 } 669 } 670 671 /* Let optimizers know that TEMP's value never changes 672 and that X can be substituted for it. Don't get confused 673 if INSN set something else (such as a SUBREG of TEMP). */ 674 if (CONSTANT_P (x) 675 && (set = single_set (insn)) != 0 676 && SET_DEST (set) == temp 677 && ! rtx_equal_p (x, SET_SRC (set))) 678 set_unique_reg_note (insn, REG_EQUAL, x); 679 680 /* Let optimizers know that TEMP is a pointer, and if so, the 681 known alignment of that pointer. */ 682 { 683 unsigned align = 0; 684 if (GET_CODE (x) == SYMBOL_REF) 685 { 686 align = BITS_PER_UNIT; 687 if (SYMBOL_REF_DECL (x) && DECL_P (SYMBOL_REF_DECL (x))) 688 align = DECL_ALIGN (SYMBOL_REF_DECL (x)); 689 } 690 else if (GET_CODE (x) == LABEL_REF) 691 align = BITS_PER_UNIT; 692 else if (GET_CODE (x) == CONST 693 && GET_CODE (XEXP (x, 0)) == PLUS 694 && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF 695 && CONST_INT_P (XEXP (XEXP (x, 0), 1))) 696 { 697 rtx s = XEXP (XEXP (x, 0), 0); 698 rtx c = XEXP (XEXP (x, 0), 1); 699 unsigned sa, ca; 700 701 sa = BITS_PER_UNIT; 702 if (SYMBOL_REF_DECL (s) && DECL_P (SYMBOL_REF_DECL (s))) 703 sa = DECL_ALIGN (SYMBOL_REF_DECL (s)); 704 705 if (INTVAL (c) == 0) 706 align = sa; 707 else 708 { 709 ca = ctz_hwi (INTVAL (c)) * BITS_PER_UNIT; 710 align = MIN (sa, ca); 711 } 712 } 713 714 if (align || (MEM_P (x) && MEM_POINTER (x))) 715 mark_reg_pointer (temp, align); 716 } 717 718 return temp; 719 } 720 721 /* If X is a memory ref, copy its contents to a new temp reg and return 722 that reg. Otherwise, return X. */ 723 724 rtx 725 force_not_mem (rtx x) 726 { 727 rtx temp; 728 729 if (!MEM_P (x) || GET_MODE (x) == BLKmode) 730 return x; 731 732 temp = gen_reg_rtx (GET_MODE (x)); 733 734 if (MEM_POINTER (x)) 735 REG_POINTER (temp) = 1; 736 737 emit_move_insn (temp, x); 738 return temp; 739 } 740 741 /* Copy X to TARGET (if it's nonzero and a reg) 742 or to a new temp reg and return that reg. 743 MODE is the mode to use for X in case it is a constant. */ 744 745 rtx 746 copy_to_suggested_reg (rtx x, rtx target, machine_mode mode) 747 { 748 rtx temp; 749 750 if (target && REG_P (target)) 751 temp = target; 752 else 753 temp = gen_reg_rtx (mode); 754 755 emit_move_insn (temp, x); 756 return temp; 757 } 758 759 /* Return the mode to use to pass or return a scalar of TYPE and MODE. 760 PUNSIGNEDP points to the signedness of the type and may be adjusted 761 to show what signedness to use on extension operations. 762 763 FOR_RETURN is nonzero if the caller is promoting the return value 764 of FNDECL, else it is for promoting args. */ 765 766 machine_mode 767 promote_function_mode (const_tree type, machine_mode mode, int *punsignedp, 768 const_tree funtype, int for_return) 769 { 770 /* Called without a type node for a libcall. */ 771 if (type == NULL_TREE) 772 { 773 if (INTEGRAL_MODE_P (mode)) 774 return targetm.calls.promote_function_mode (NULL_TREE, mode, 775 punsignedp, funtype, 776 for_return); 777 else 778 return mode; 779 } 780 781 switch (TREE_CODE (type)) 782 { 783 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: 784 case REAL_TYPE: case OFFSET_TYPE: case FIXED_POINT_TYPE: 785 case POINTER_TYPE: case REFERENCE_TYPE: 786 return targetm.calls.promote_function_mode (type, mode, punsignedp, funtype, 787 for_return); 788 789 default: 790 return mode; 791 } 792 } 793 /* Return the mode to use to store a scalar of TYPE and MODE. 794 PUNSIGNEDP points to the signedness of the type and may be adjusted 795 to show what signedness to use on extension operations. */ 796 797 machine_mode 798 promote_mode (const_tree type ATTRIBUTE_UNUSED, machine_mode mode, 799 int *punsignedp ATTRIBUTE_UNUSED) 800 { 801 #ifdef PROMOTE_MODE 802 enum tree_code code; 803 int unsignedp; 804 scalar_mode smode; 805 #endif 806 807 /* For libcalls this is invoked without TYPE from the backends 808 TARGET_PROMOTE_FUNCTION_MODE hooks. Don't do anything in that 809 case. */ 810 if (type == NULL_TREE) 811 return mode; 812 813 /* FIXME: this is the same logic that was there until GCC 4.4, but we 814 probably want to test POINTERS_EXTEND_UNSIGNED even if PROMOTE_MODE 815 is not defined. The affected targets are M32C, S390, SPARC. */ 816 #ifdef PROMOTE_MODE 817 code = TREE_CODE (type); 818 unsignedp = *punsignedp; 819 820 switch (code) 821 { 822 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: 823 case REAL_TYPE: case OFFSET_TYPE: case FIXED_POINT_TYPE: 824 /* Values of these types always have scalar mode. */ 825 smode = as_a <scalar_mode> (mode); 826 PROMOTE_MODE (smode, unsignedp, type); 827 *punsignedp = unsignedp; 828 return smode; 829 830 #ifdef POINTERS_EXTEND_UNSIGNED 831 case REFERENCE_TYPE: 832 case POINTER_TYPE: 833 *punsignedp = POINTERS_EXTEND_UNSIGNED; 834 return targetm.addr_space.address_mode 835 (TYPE_ADDR_SPACE (TREE_TYPE (type))); 836 #endif 837 838 default: 839 return mode; 840 } 841 #else 842 return mode; 843 #endif 844 } 845 846 847 /* Use one of promote_mode or promote_function_mode to find the promoted 848 mode of DECL. If PUNSIGNEDP is not NULL, store there the unsignedness 849 of DECL after promotion. */ 850 851 machine_mode 852 promote_decl_mode (const_tree decl, int *punsignedp) 853 { 854 tree type = TREE_TYPE (decl); 855 int unsignedp = TYPE_UNSIGNED (type); 856 machine_mode mode = DECL_MODE (decl); 857 machine_mode pmode; 858 859 if (TREE_CODE (decl) == RESULT_DECL && !DECL_BY_REFERENCE (decl)) 860 pmode = promote_function_mode (type, mode, &unsignedp, 861 TREE_TYPE (current_function_decl), 1); 862 else if (TREE_CODE (decl) == RESULT_DECL || TREE_CODE (decl) == PARM_DECL) 863 pmode = promote_function_mode (type, mode, &unsignedp, 864 TREE_TYPE (current_function_decl), 2); 865 else 866 pmode = promote_mode (type, mode, &unsignedp); 867 868 if (punsignedp) 869 *punsignedp = unsignedp; 870 return pmode; 871 } 872 873 /* Return the promoted mode for name. If it is a named SSA_NAME, it 874 is the same as promote_decl_mode. Otherwise, it is the promoted 875 mode of a temp decl of same type as the SSA_NAME, if we had created 876 one. */ 877 878 machine_mode 879 promote_ssa_mode (const_tree name, int *punsignedp) 880 { 881 gcc_assert (TREE_CODE (name) == SSA_NAME); 882 883 /* Partitions holding parms and results must be promoted as expected 884 by function.c. */ 885 if (SSA_NAME_VAR (name) 886 && (TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL 887 || TREE_CODE (SSA_NAME_VAR (name)) == RESULT_DECL)) 888 { 889 machine_mode mode = promote_decl_mode (SSA_NAME_VAR (name), punsignedp); 890 if (mode != BLKmode) 891 return mode; 892 } 893 894 tree type = TREE_TYPE (name); 895 int unsignedp = TYPE_UNSIGNED (type); 896 machine_mode mode = TYPE_MODE (type); 897 898 /* Bypass TYPE_MODE when it maps vector modes to BLKmode. */ 899 if (mode == BLKmode) 900 { 901 gcc_assert (VECTOR_TYPE_P (type)); 902 mode = type->type_common.mode; 903 } 904 905 machine_mode pmode = promote_mode (type, mode, &unsignedp); 906 if (punsignedp) 907 *punsignedp = unsignedp; 908 909 return pmode; 910 } 911 912 913 914 /* Controls the behavior of {anti_,}adjust_stack. */ 915 static bool suppress_reg_args_size; 916 917 /* A helper for adjust_stack and anti_adjust_stack. */ 918 919 static void 920 adjust_stack_1 (rtx adjust, bool anti_p) 921 { 922 rtx temp; 923 rtx_insn *insn; 924 925 /* Hereafter anti_p means subtract_p. */ 926 if (!STACK_GROWS_DOWNWARD) 927 anti_p = !anti_p; 928 929 temp = expand_binop (Pmode, 930 anti_p ? sub_optab : add_optab, 931 stack_pointer_rtx, adjust, stack_pointer_rtx, 0, 932 OPTAB_LIB_WIDEN); 933 934 if (temp != stack_pointer_rtx) 935 insn = emit_move_insn (stack_pointer_rtx, temp); 936 else 937 { 938 insn = get_last_insn (); 939 temp = single_set (insn); 940 gcc_assert (temp != NULL && SET_DEST (temp) == stack_pointer_rtx); 941 } 942 943 if (!suppress_reg_args_size) 944 add_args_size_note (insn, stack_pointer_delta); 945 } 946 947 /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes). 948 This pops when ADJUST is positive. ADJUST need not be constant. */ 949 950 void 951 adjust_stack (rtx adjust) 952 { 953 if (adjust == const0_rtx) 954 return; 955 956 /* We expect all variable sized adjustments to be multiple of 957 PREFERRED_STACK_BOUNDARY. */ 958 if (CONST_INT_P (adjust)) 959 stack_pointer_delta -= INTVAL (adjust); 960 961 adjust_stack_1 (adjust, false); 962 } 963 964 /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes). 965 This pushes when ADJUST is positive. ADJUST need not be constant. */ 966 967 void 968 anti_adjust_stack (rtx adjust) 969 { 970 if (adjust == const0_rtx) 971 return; 972 973 /* We expect all variable sized adjustments to be multiple of 974 PREFERRED_STACK_BOUNDARY. */ 975 if (CONST_INT_P (adjust)) 976 stack_pointer_delta += INTVAL (adjust); 977 978 adjust_stack_1 (adjust, true); 979 } 980 981 /* Round the size of a block to be pushed up to the boundary required 982 by this machine. SIZE is the desired size, which need not be constant. */ 983 984 static rtx 985 round_push (rtx size) 986 { 987 rtx align_rtx, alignm1_rtx; 988 989 if (!SUPPORTS_STACK_ALIGNMENT 990 || crtl->preferred_stack_boundary == MAX_SUPPORTED_STACK_ALIGNMENT) 991 { 992 int align = crtl->preferred_stack_boundary / BITS_PER_UNIT; 993 994 if (align == 1) 995 return size; 996 997 if (CONST_INT_P (size)) 998 { 999 HOST_WIDE_INT new_size = (INTVAL (size) + align - 1) / align * align; 1000 1001 if (INTVAL (size) != new_size) 1002 size = GEN_INT (new_size); 1003 return size; 1004 } 1005 1006 align_rtx = GEN_INT (align); 1007 alignm1_rtx = GEN_INT (align - 1); 1008 } 1009 else 1010 { 1011 /* If crtl->preferred_stack_boundary might still grow, use 1012 virtual_preferred_stack_boundary_rtx instead. This will be 1013 substituted by the right value in vregs pass and optimized 1014 during combine. */ 1015 align_rtx = virtual_preferred_stack_boundary_rtx; 1016 alignm1_rtx = force_operand (plus_constant (Pmode, align_rtx, -1), 1017 NULL_RTX); 1018 } 1019 1020 /* CEIL_DIV_EXPR needs to worry about the addition overflowing, 1021 but we know it can't. So add ourselves and then do 1022 TRUNC_DIV_EXPR. */ 1023 size = expand_binop (Pmode, add_optab, size, alignm1_rtx, 1024 NULL_RTX, 1, OPTAB_LIB_WIDEN); 1025 size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, align_rtx, 1026 NULL_RTX, 1); 1027 size = expand_mult (Pmode, size, align_rtx, NULL_RTX, 1); 1028 1029 return size; 1030 } 1031 1032 /* Save the stack pointer for the purpose in SAVE_LEVEL. PSAVE is a pointer 1033 to a previously-created save area. If no save area has been allocated, 1034 this function will allocate one. If a save area is specified, it 1035 must be of the proper mode. */ 1036 1037 void 1038 emit_stack_save (enum save_level save_level, rtx *psave) 1039 { 1040 rtx sa = *psave; 1041 /* The default is that we use a move insn and save in a Pmode object. */ 1042 rtx_insn *(*fcn) (rtx, rtx) = gen_move_insn; 1043 machine_mode mode = STACK_SAVEAREA_MODE (save_level); 1044 1045 /* See if this machine has anything special to do for this kind of save. */ 1046 switch (save_level) 1047 { 1048 case SAVE_BLOCK: 1049 if (targetm.have_save_stack_block ()) 1050 fcn = targetm.gen_save_stack_block; 1051 break; 1052 case SAVE_FUNCTION: 1053 if (targetm.have_save_stack_function ()) 1054 fcn = targetm.gen_save_stack_function; 1055 break; 1056 case SAVE_NONLOCAL: 1057 if (targetm.have_save_stack_nonlocal ()) 1058 fcn = targetm.gen_save_stack_nonlocal; 1059 break; 1060 default: 1061 break; 1062 } 1063 1064 /* If there is no save area and we have to allocate one, do so. Otherwise 1065 verify the save area is the proper mode. */ 1066 1067 if (sa == 0) 1068 { 1069 if (mode != VOIDmode) 1070 { 1071 if (save_level == SAVE_NONLOCAL) 1072 *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0); 1073 else 1074 *psave = sa = gen_reg_rtx (mode); 1075 } 1076 } 1077 1078 do_pending_stack_adjust (); 1079 if (sa != 0) 1080 sa = validize_mem (sa); 1081 emit_insn (fcn (sa, stack_pointer_rtx)); 1082 } 1083 1084 /* Restore the stack pointer for the purpose in SAVE_LEVEL. SA is the save 1085 area made by emit_stack_save. If it is zero, we have nothing to do. */ 1086 1087 void 1088 emit_stack_restore (enum save_level save_level, rtx sa) 1089 { 1090 /* The default is that we use a move insn. */ 1091 rtx_insn *(*fcn) (rtx, rtx) = gen_move_insn; 1092 1093 /* If stack_realign_drap, the x86 backend emits a prologue that aligns both 1094 STACK_POINTER and HARD_FRAME_POINTER. 1095 If stack_realign_fp, the x86 backend emits a prologue that aligns only 1096 STACK_POINTER. This renders the HARD_FRAME_POINTER unusable for accessing 1097 aligned variables, which is reflected in ix86_can_eliminate. 1098 We normally still have the realigned STACK_POINTER that we can use. 1099 But if there is a stack restore still present at reload, it can trigger 1100 mark_not_eliminable for the STACK_POINTER, leaving no way to eliminate 1101 FRAME_POINTER into a hard reg. 1102 To prevent this situation, we force need_drap if we emit a stack 1103 restore. */ 1104 if (SUPPORTS_STACK_ALIGNMENT) 1105 crtl->need_drap = true; 1106 1107 /* See if this machine has anything special to do for this kind of save. */ 1108 switch (save_level) 1109 { 1110 case SAVE_BLOCK: 1111 if (targetm.have_restore_stack_block ()) 1112 fcn = targetm.gen_restore_stack_block; 1113 break; 1114 case SAVE_FUNCTION: 1115 if (targetm.have_restore_stack_function ()) 1116 fcn = targetm.gen_restore_stack_function; 1117 break; 1118 case SAVE_NONLOCAL: 1119 if (targetm.have_restore_stack_nonlocal ()) 1120 fcn = targetm.gen_restore_stack_nonlocal; 1121 break; 1122 default: 1123 break; 1124 } 1125 1126 if (sa != 0) 1127 { 1128 sa = validize_mem (sa); 1129 /* These clobbers prevent the scheduler from moving 1130 references to variable arrays below the code 1131 that deletes (pops) the arrays. */ 1132 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode))); 1133 emit_clobber (gen_rtx_MEM (BLKmode, stack_pointer_rtx)); 1134 } 1135 1136 discard_pending_stack_adjust (); 1137 1138 emit_insn (fcn (stack_pointer_rtx, sa)); 1139 } 1140 1141 /* Invoke emit_stack_save on the nonlocal_goto_save_area for the current 1142 function. This should be called whenever we allocate or deallocate 1143 dynamic stack space. */ 1144 1145 void 1146 update_nonlocal_goto_save_area (void) 1147 { 1148 tree t_save; 1149 rtx r_save; 1150 1151 /* The nonlocal_goto_save_area object is an array of N pointers. The 1152 first one is used for the frame pointer save; the rest are sized by 1153 STACK_SAVEAREA_MODE. Create a reference to array index 1, the first 1154 of the stack save area slots. */ 1155 t_save = build4 (ARRAY_REF, 1156 TREE_TYPE (TREE_TYPE (cfun->nonlocal_goto_save_area)), 1157 cfun->nonlocal_goto_save_area, 1158 integer_one_node, NULL_TREE, NULL_TREE); 1159 r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE); 1160 1161 emit_stack_save (SAVE_NONLOCAL, &r_save); 1162 } 1163 1164 /* Record a new stack level for the current function. This should be called 1165 whenever we allocate or deallocate dynamic stack space. */ 1166 1167 void 1168 record_new_stack_level (void) 1169 { 1170 /* Record the new stack level for nonlocal gotos. */ 1171 if (cfun->nonlocal_goto_save_area) 1172 update_nonlocal_goto_save_area (); 1173 1174 /* Record the new stack level for SJLJ exceptions. */ 1175 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 1176 update_sjlj_context (); 1177 } 1178 1179 /* Return an rtx doing runtime alignment to REQUIRED_ALIGN on TARGET. */ 1180 static rtx 1181 align_dynamic_address (rtx target, unsigned required_align) 1182 { 1183 /* CEIL_DIV_EXPR needs to worry about the addition overflowing, 1184 but we know it can't. So add ourselves and then do 1185 TRUNC_DIV_EXPR. */ 1186 target = expand_binop (Pmode, add_optab, target, 1187 gen_int_mode (required_align / BITS_PER_UNIT - 1, 1188 Pmode), 1189 NULL_RTX, 1, OPTAB_LIB_WIDEN); 1190 target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target, 1191 gen_int_mode (required_align / BITS_PER_UNIT, 1192 Pmode), 1193 NULL_RTX, 1); 1194 target = expand_mult (Pmode, target, 1195 gen_int_mode (required_align / BITS_PER_UNIT, 1196 Pmode), 1197 NULL_RTX, 1); 1198 1199 return target; 1200 } 1201 1202 /* Return an rtx through *PSIZE, representing the size of an area of memory to 1203 be dynamically pushed on the stack. 1204 1205 *PSIZE is an rtx representing the size of the area. 1206 1207 SIZE_ALIGN is the alignment (in bits) that we know SIZE has. This 1208 parameter may be zero. If so, a proper value will be extracted 1209 from SIZE if it is constant, otherwise BITS_PER_UNIT will be assumed. 1210 1211 REQUIRED_ALIGN is the alignment (in bits) required for the region 1212 of memory. 1213 1214 If PSTACK_USAGE_SIZE is not NULL it points to a value that is increased for 1215 the additional size returned. */ 1216 void 1217 get_dynamic_stack_size (rtx *psize, unsigned size_align, 1218 unsigned required_align, 1219 HOST_WIDE_INT *pstack_usage_size) 1220 { 1221 rtx size = *psize; 1222 1223 /* Ensure the size is in the proper mode. */ 1224 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode) 1225 size = convert_to_mode (Pmode, size, 1); 1226 1227 if (CONST_INT_P (size)) 1228 { 1229 unsigned HOST_WIDE_INT lsb; 1230 1231 lsb = INTVAL (size); 1232 lsb &= -lsb; 1233 1234 /* Watch out for overflow truncating to "unsigned". */ 1235 if (lsb > UINT_MAX / BITS_PER_UNIT) 1236 size_align = 1u << (HOST_BITS_PER_INT - 1); 1237 else 1238 size_align = (unsigned)lsb * BITS_PER_UNIT; 1239 } 1240 else if (size_align < BITS_PER_UNIT) 1241 size_align = BITS_PER_UNIT; 1242 1243 /* We can't attempt to minimize alignment necessary, because we don't 1244 know the final value of preferred_stack_boundary yet while executing 1245 this code. */ 1246 if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY) 1247 crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY; 1248 1249 /* We will need to ensure that the address we return is aligned to 1250 REQUIRED_ALIGN. At this point in the compilation, we don't always 1251 know the final value of the STACK_DYNAMIC_OFFSET used in function.c 1252 (it might depend on the size of the outgoing parameter lists, for 1253 example), so we must preventively align the value. We leave space 1254 in SIZE for the hole that might result from the alignment operation. */ 1255 1256 unsigned known_align = REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM); 1257 if (known_align == 0) 1258 known_align = BITS_PER_UNIT; 1259 if (required_align > known_align) 1260 { 1261 unsigned extra = (required_align - known_align) / BITS_PER_UNIT; 1262 size = plus_constant (Pmode, size, extra); 1263 size = force_operand (size, NULL_RTX); 1264 if (size_align > known_align) 1265 size_align = known_align; 1266 1267 if (flag_stack_usage_info && pstack_usage_size) 1268 *pstack_usage_size += extra; 1269 } 1270 1271 /* Round the size to a multiple of the required stack alignment. 1272 Since the stack is presumed to be rounded before this allocation, 1273 this will maintain the required alignment. 1274 1275 If the stack grows downward, we could save an insn by subtracting 1276 SIZE from the stack pointer and then aligning the stack pointer. 1277 The problem with this is that the stack pointer may be unaligned 1278 between the execution of the subtraction and alignment insns and 1279 some machines do not allow this. Even on those that do, some 1280 signal handlers malfunction if a signal should occur between those 1281 insns. Since this is an extremely rare event, we have no reliable 1282 way of knowing which systems have this problem. So we avoid even 1283 momentarily mis-aligning the stack. */ 1284 if (size_align % MAX_SUPPORTED_STACK_ALIGNMENT != 0) 1285 { 1286 size = round_push (size); 1287 1288 if (flag_stack_usage_info && pstack_usage_size) 1289 { 1290 int align = crtl->preferred_stack_boundary / BITS_PER_UNIT; 1291 *pstack_usage_size = 1292 (*pstack_usage_size + align - 1) / align * align; 1293 } 1294 } 1295 1296 *psize = size; 1297 } 1298 1299 /* Return the number of bytes to "protect" on the stack for -fstack-check. 1300 1301 "protect" in the context of -fstack-check means how many bytes we 1302 should always ensure are available on the stack. More importantly 1303 this is how many bytes are skipped when probing the stack. 1304 1305 On some targets we want to reuse the -fstack-check prologue support 1306 to give a degree of protection against stack clashing style attacks. 1307 1308 In that scenario we do not want to skip bytes before probing as that 1309 would render the stack clash protections useless. 1310 1311 So we never use STACK_CHECK_PROTECT directly. Instead we indirect though 1312 this helper which allows us to provide different values for 1313 -fstack-check and -fstack-clash-protection. */ 1314 HOST_WIDE_INT 1315 get_stack_check_protect (void) 1316 { 1317 if (flag_stack_clash_protection) 1318 return 0; 1319 return STACK_CHECK_PROTECT; 1320 } 1321 1322 /* Return an rtx representing the address of an area of memory dynamically 1323 pushed on the stack. 1324 1325 Any required stack pointer alignment is preserved. 1326 1327 SIZE is an rtx representing the size of the area. 1328 1329 SIZE_ALIGN is the alignment (in bits) that we know SIZE has. This 1330 parameter may be zero. If so, a proper value will be extracted 1331 from SIZE if it is constant, otherwise BITS_PER_UNIT will be assumed. 1332 1333 REQUIRED_ALIGN is the alignment (in bits) required for the region 1334 of memory. 1335 1336 MAX_SIZE is an upper bound for SIZE, if SIZE is not constant, or -1 if 1337 no such upper bound is known. 1338 1339 If CANNOT_ACCUMULATE is set to TRUE, the caller guarantees that the 1340 stack space allocated by the generated code cannot be added with itself 1341 in the course of the execution of the function. It is always safe to 1342 pass FALSE here and the following criterion is sufficient in order to 1343 pass TRUE: every path in the CFG that starts at the allocation point and 1344 loops to it executes the associated deallocation code. */ 1345 1346 rtx 1347 allocate_dynamic_stack_space (rtx size, unsigned size_align, 1348 unsigned required_align, 1349 HOST_WIDE_INT max_size, 1350 bool cannot_accumulate) 1351 { 1352 HOST_WIDE_INT stack_usage_size = -1; 1353 rtx_code_label *final_label; 1354 rtx final_target, target; 1355 1356 /* If we're asking for zero bytes, it doesn't matter what we point 1357 to since we can't dereference it. But return a reasonable 1358 address anyway. */ 1359 if (size == const0_rtx) 1360 return virtual_stack_dynamic_rtx; 1361 1362 /* Otherwise, show we're calling alloca or equivalent. */ 1363 cfun->calls_alloca = 1; 1364 1365 /* If stack usage info is requested, look into the size we are passed. 1366 We need to do so this early to avoid the obfuscation that may be 1367 introduced later by the various alignment operations. */ 1368 if (flag_stack_usage_info) 1369 { 1370 if (CONST_INT_P (size)) 1371 stack_usage_size = INTVAL (size); 1372 else if (REG_P (size)) 1373 { 1374 /* Look into the last emitted insn and see if we can deduce 1375 something for the register. */ 1376 rtx_insn *insn; 1377 rtx set, note; 1378 insn = get_last_insn (); 1379 if ((set = single_set (insn)) && rtx_equal_p (SET_DEST (set), size)) 1380 { 1381 if (CONST_INT_P (SET_SRC (set))) 1382 stack_usage_size = INTVAL (SET_SRC (set)); 1383 else if ((note = find_reg_equal_equiv_note (insn)) 1384 && CONST_INT_P (XEXP (note, 0))) 1385 stack_usage_size = INTVAL (XEXP (note, 0)); 1386 } 1387 } 1388 1389 /* If the size is not constant, try the maximum size. */ 1390 if (stack_usage_size < 0) 1391 stack_usage_size = max_size; 1392 1393 /* If the size is still not constant, we can't say anything. */ 1394 if (stack_usage_size < 0) 1395 { 1396 current_function_has_unbounded_dynamic_stack_size = 1; 1397 stack_usage_size = 0; 1398 } 1399 } 1400 1401 get_dynamic_stack_size (&size, size_align, required_align, &stack_usage_size); 1402 1403 target = gen_reg_rtx (Pmode); 1404 1405 /* The size is supposed to be fully adjusted at this point so record it 1406 if stack usage info is requested. */ 1407 if (flag_stack_usage_info) 1408 { 1409 current_function_dynamic_stack_size += stack_usage_size; 1410 1411 /* ??? This is gross but the only safe stance in the absence 1412 of stack usage oriented flow analysis. */ 1413 if (!cannot_accumulate) 1414 current_function_has_unbounded_dynamic_stack_size = 1; 1415 } 1416 1417 do_pending_stack_adjust (); 1418 1419 final_label = NULL; 1420 final_target = NULL_RTX; 1421 1422 /* If we are splitting the stack, we need to ask the backend whether 1423 there is enough room on the current stack. If there isn't, or if 1424 the backend doesn't know how to tell is, then we need to call a 1425 function to allocate memory in some other way. This memory will 1426 be released when we release the current stack segment. The 1427 effect is that stack allocation becomes less efficient, but at 1428 least it doesn't cause a stack overflow. */ 1429 if (flag_split_stack) 1430 { 1431 rtx_code_label *available_label; 1432 rtx ask, space, func; 1433 1434 available_label = NULL; 1435 1436 if (targetm.have_split_stack_space_check ()) 1437 { 1438 available_label = gen_label_rtx (); 1439 1440 /* This instruction will branch to AVAILABLE_LABEL if there 1441 are SIZE bytes available on the stack. */ 1442 emit_insn (targetm.gen_split_stack_space_check 1443 (size, available_label)); 1444 } 1445 1446 /* The __morestack_allocate_stack_space function will allocate 1447 memory using malloc. If the alignment of the memory returned 1448 by malloc does not meet REQUIRED_ALIGN, we increase SIZE to 1449 make sure we allocate enough space. */ 1450 if (MALLOC_ABI_ALIGNMENT >= required_align) 1451 ask = size; 1452 else 1453 ask = expand_binop (Pmode, add_optab, size, 1454 gen_int_mode (required_align / BITS_PER_UNIT - 1, 1455 Pmode), 1456 NULL_RTX, 1, OPTAB_LIB_WIDEN); 1457 1458 func = init_one_libfunc ("__morestack_allocate_stack_space"); 1459 1460 space = emit_library_call_value (func, target, LCT_NORMAL, Pmode, 1461 ask, Pmode); 1462 1463 if (available_label == NULL_RTX) 1464 return space; 1465 1466 final_target = gen_reg_rtx (Pmode); 1467 1468 emit_move_insn (final_target, space); 1469 1470 final_label = gen_label_rtx (); 1471 emit_jump (final_label); 1472 1473 emit_label (available_label); 1474 } 1475 1476 /* We ought to be called always on the toplevel and stack ought to be aligned 1477 properly. */ 1478 gcc_assert (multiple_p (stack_pointer_delta, 1479 PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)); 1480 1481 /* If needed, check that we have the required amount of stack. Take into 1482 account what has already been checked. */ 1483 if (STACK_CHECK_MOVING_SP) 1484 ; 1485 else if (flag_stack_check == GENERIC_STACK_CHECK) 1486 probe_stack_range (STACK_OLD_CHECK_PROTECT + STACK_CHECK_MAX_FRAME_SIZE, 1487 size); 1488 else if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK) 1489 probe_stack_range (get_stack_check_protect (), size); 1490 1491 /* Don't let anti_adjust_stack emit notes. */ 1492 suppress_reg_args_size = true; 1493 1494 /* Perform the required allocation from the stack. Some systems do 1495 this differently than simply incrementing/decrementing from the 1496 stack pointer, such as acquiring the space by calling malloc(). */ 1497 if (targetm.have_allocate_stack ()) 1498 { 1499 struct expand_operand ops[2]; 1500 /* We don't have to check against the predicate for operand 0 since 1501 TARGET is known to be a pseudo of the proper mode, which must 1502 be valid for the operand. */ 1503 create_fixed_operand (&ops[0], target); 1504 create_convert_operand_to (&ops[1], size, STACK_SIZE_MODE, true); 1505 expand_insn (targetm.code_for_allocate_stack, 2, ops); 1506 } 1507 else 1508 { 1509 poly_int64 saved_stack_pointer_delta; 1510 1511 if (!STACK_GROWS_DOWNWARD) 1512 emit_move_insn (target, virtual_stack_dynamic_rtx); 1513 1514 /* Check stack bounds if necessary. */ 1515 if (crtl->limit_stack) 1516 { 1517 rtx available; 1518 rtx_code_label *space_available = gen_label_rtx (); 1519 if (STACK_GROWS_DOWNWARD) 1520 available = expand_binop (Pmode, sub_optab, 1521 stack_pointer_rtx, stack_limit_rtx, 1522 NULL_RTX, 1, OPTAB_WIDEN); 1523 else 1524 available = expand_binop (Pmode, sub_optab, 1525 stack_limit_rtx, stack_pointer_rtx, 1526 NULL_RTX, 1, OPTAB_WIDEN); 1527 1528 emit_cmp_and_jump_insns (available, size, GEU, NULL_RTX, Pmode, 1, 1529 space_available); 1530 if (targetm.have_trap ()) 1531 emit_insn (targetm.gen_trap ()); 1532 else 1533 error ("stack limits not supported on this target"); 1534 emit_barrier (); 1535 emit_label (space_available); 1536 } 1537 1538 saved_stack_pointer_delta = stack_pointer_delta; 1539 1540 if (flag_stack_check && STACK_CHECK_MOVING_SP) 1541 anti_adjust_stack_and_probe (size, false); 1542 else if (flag_stack_clash_protection) 1543 anti_adjust_stack_and_probe_stack_clash (size); 1544 else 1545 anti_adjust_stack (size); 1546 1547 /* Even if size is constant, don't modify stack_pointer_delta. 1548 The constant size alloca should preserve 1549 crtl->preferred_stack_boundary alignment. */ 1550 stack_pointer_delta = saved_stack_pointer_delta; 1551 1552 if (STACK_GROWS_DOWNWARD) 1553 emit_move_insn (target, virtual_stack_dynamic_rtx); 1554 } 1555 1556 suppress_reg_args_size = false; 1557 1558 /* Finish up the split stack handling. */ 1559 if (final_label != NULL_RTX) 1560 { 1561 gcc_assert (flag_split_stack); 1562 emit_move_insn (final_target, target); 1563 emit_label (final_label); 1564 target = final_target; 1565 } 1566 1567 target = align_dynamic_address (target, required_align); 1568 1569 /* Now that we've committed to a return value, mark its alignment. */ 1570 mark_reg_pointer (target, required_align); 1571 1572 /* Record the new stack level. */ 1573 record_new_stack_level (); 1574 1575 return target; 1576 } 1577 1578 /* Return an rtx representing the address of an area of memory already 1579 statically pushed onto the stack in the virtual stack vars area. (It is 1580 assumed that the area is allocated in the function prologue.) 1581 1582 Any required stack pointer alignment is preserved. 1583 1584 OFFSET is the offset of the area into the virtual stack vars area. 1585 1586 REQUIRED_ALIGN is the alignment (in bits) required for the region 1587 of memory. */ 1588 1589 rtx 1590 get_dynamic_stack_base (poly_int64 offset, unsigned required_align) 1591 { 1592 rtx target; 1593 1594 if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY) 1595 crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY; 1596 1597 target = gen_reg_rtx (Pmode); 1598 emit_move_insn (target, virtual_stack_vars_rtx); 1599 target = expand_binop (Pmode, add_optab, target, 1600 gen_int_mode (offset, Pmode), 1601 NULL_RTX, 1, OPTAB_LIB_WIDEN); 1602 target = align_dynamic_address (target, required_align); 1603 1604 /* Now that we've committed to a return value, mark its alignment. */ 1605 mark_reg_pointer (target, required_align); 1606 1607 return target; 1608 } 1609 1610 /* A front end may want to override GCC's stack checking by providing a 1611 run-time routine to call to check the stack, so provide a mechanism for 1612 calling that routine. */ 1613 1614 static GTY(()) rtx stack_check_libfunc; 1615 1616 void 1617 set_stack_check_libfunc (const char *libfunc_name) 1618 { 1619 gcc_assert (stack_check_libfunc == NULL_RTX); 1620 stack_check_libfunc = gen_rtx_SYMBOL_REF (Pmode, libfunc_name); 1621 } 1622 1623 /* Emit one stack probe at ADDRESS, an address within the stack. */ 1624 1625 void 1626 emit_stack_probe (rtx address) 1627 { 1628 if (targetm.have_probe_stack_address ()) 1629 { 1630 struct expand_operand ops[1]; 1631 insn_code icode = targetm.code_for_probe_stack_address; 1632 create_address_operand (ops, address); 1633 maybe_legitimize_operands (icode, 0, 1, ops); 1634 expand_insn (icode, 1, ops); 1635 } 1636 else 1637 { 1638 rtx memref = gen_rtx_MEM (word_mode, address); 1639 1640 MEM_VOLATILE_P (memref) = 1; 1641 memref = validize_mem (memref); 1642 1643 /* See if we have an insn to probe the stack. */ 1644 if (targetm.have_probe_stack ()) 1645 emit_insn (targetm.gen_probe_stack (memref)); 1646 else 1647 emit_move_insn (memref, const0_rtx); 1648 } 1649 } 1650 1651 /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 1652 FIRST is a constant and size is a Pmode RTX. These are offsets from 1653 the current stack pointer. STACK_GROWS_DOWNWARD says whether to add 1654 or subtract them from the stack pointer. */ 1655 1656 #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP) 1657 1658 #if STACK_GROWS_DOWNWARD 1659 #define STACK_GROW_OP MINUS 1660 #define STACK_GROW_OPTAB sub_optab 1661 #define STACK_GROW_OFF(off) -(off) 1662 #else 1663 #define STACK_GROW_OP PLUS 1664 #define STACK_GROW_OPTAB add_optab 1665 #define STACK_GROW_OFF(off) (off) 1666 #endif 1667 1668 void 1669 probe_stack_range (HOST_WIDE_INT first, rtx size) 1670 { 1671 /* First ensure SIZE is Pmode. */ 1672 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode) 1673 size = convert_to_mode (Pmode, size, 1); 1674 1675 /* Next see if we have a function to check the stack. */ 1676 if (stack_check_libfunc) 1677 { 1678 rtx addr = memory_address (Pmode, 1679 gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1680 stack_pointer_rtx, 1681 plus_constant (Pmode, 1682 size, first))); 1683 emit_library_call (stack_check_libfunc, LCT_THROW, VOIDmode, 1684 addr, Pmode); 1685 } 1686 1687 /* Next see if we have an insn to check the stack. */ 1688 else if (targetm.have_check_stack ()) 1689 { 1690 struct expand_operand ops[1]; 1691 rtx addr = memory_address (Pmode, 1692 gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1693 stack_pointer_rtx, 1694 plus_constant (Pmode, 1695 size, first))); 1696 bool success; 1697 create_input_operand (&ops[0], addr, Pmode); 1698 success = maybe_expand_insn (targetm.code_for_check_stack, 1, ops); 1699 gcc_assert (success); 1700 } 1701 1702 /* Otherwise we have to generate explicit probes. If we have a constant 1703 small number of them to generate, that's the easy case. */ 1704 else if (CONST_INT_P (size) && INTVAL (size) < 7 * PROBE_INTERVAL) 1705 { 1706 HOST_WIDE_INT isize = INTVAL (size), i; 1707 rtx addr; 1708 1709 /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 1 until 1710 it exceeds SIZE. If only one probe is needed, this will not 1711 generate any code. Then probe at FIRST + SIZE. */ 1712 for (i = PROBE_INTERVAL; i < isize; i += PROBE_INTERVAL) 1713 { 1714 addr = memory_address (Pmode, 1715 plus_constant (Pmode, stack_pointer_rtx, 1716 STACK_GROW_OFF (first + i))); 1717 emit_stack_probe (addr); 1718 } 1719 1720 addr = memory_address (Pmode, 1721 plus_constant (Pmode, stack_pointer_rtx, 1722 STACK_GROW_OFF (first + isize))); 1723 emit_stack_probe (addr); 1724 } 1725 1726 /* In the variable case, do the same as above, but in a loop. Note that we 1727 must be extra careful with variables wrapping around because we might be 1728 at the very top (or the very bottom) of the address space and we have to 1729 be able to handle this case properly; in particular, we use an equality 1730 test for the loop condition. */ 1731 else 1732 { 1733 rtx rounded_size, rounded_size_op, test_addr, last_addr, temp; 1734 rtx_code_label *loop_lab = gen_label_rtx (); 1735 rtx_code_label *end_lab = gen_label_rtx (); 1736 1737 /* Step 1: round SIZE to the previous multiple of the interval. */ 1738 1739 /* ROUNDED_SIZE = SIZE & -PROBE_INTERVAL */ 1740 rounded_size 1741 = simplify_gen_binary (AND, Pmode, size, 1742 gen_int_mode (-PROBE_INTERVAL, Pmode)); 1743 rounded_size_op = force_operand (rounded_size, NULL_RTX); 1744 1745 1746 /* Step 2: compute initial and final value of the loop counter. */ 1747 1748 /* TEST_ADDR = SP + FIRST. */ 1749 test_addr = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1750 stack_pointer_rtx, 1751 gen_int_mode (first, Pmode)), 1752 NULL_RTX); 1753 1754 /* LAST_ADDR = SP + FIRST + ROUNDED_SIZE. */ 1755 last_addr = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1756 test_addr, 1757 rounded_size_op), NULL_RTX); 1758 1759 1760 /* Step 3: the loop 1761 1762 while (TEST_ADDR != LAST_ADDR) 1763 { 1764 TEST_ADDR = TEST_ADDR + PROBE_INTERVAL 1765 probe at TEST_ADDR 1766 } 1767 1768 probes at FIRST + N * PROBE_INTERVAL for values of N from 1 1769 until it is equal to ROUNDED_SIZE. */ 1770 1771 emit_label (loop_lab); 1772 1773 /* Jump to END_LAB if TEST_ADDR == LAST_ADDR. */ 1774 emit_cmp_and_jump_insns (test_addr, last_addr, EQ, NULL_RTX, Pmode, 1, 1775 end_lab); 1776 1777 /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL. */ 1778 temp = expand_binop (Pmode, STACK_GROW_OPTAB, test_addr, 1779 gen_int_mode (PROBE_INTERVAL, Pmode), test_addr, 1780 1, OPTAB_WIDEN); 1781 1782 gcc_assert (temp == test_addr); 1783 1784 /* Probe at TEST_ADDR. */ 1785 emit_stack_probe (test_addr); 1786 1787 emit_jump (loop_lab); 1788 1789 emit_label (end_lab); 1790 1791 1792 /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time 1793 that SIZE is equal to ROUNDED_SIZE. */ 1794 1795 /* TEMP = SIZE - ROUNDED_SIZE. */ 1796 temp = simplify_gen_binary (MINUS, Pmode, size, rounded_size); 1797 if (temp != const0_rtx) 1798 { 1799 rtx addr; 1800 1801 if (CONST_INT_P (temp)) 1802 { 1803 /* Use [base + disp} addressing mode if supported. */ 1804 HOST_WIDE_INT offset = INTVAL (temp); 1805 addr = memory_address (Pmode, 1806 plus_constant (Pmode, last_addr, 1807 STACK_GROW_OFF (offset))); 1808 } 1809 else 1810 { 1811 /* Manual CSE if the difference is not known at compile-time. */ 1812 temp = gen_rtx_MINUS (Pmode, size, rounded_size_op); 1813 addr = memory_address (Pmode, 1814 gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1815 last_addr, temp)); 1816 } 1817 1818 emit_stack_probe (addr); 1819 } 1820 } 1821 1822 /* Make sure nothing is scheduled before we are done. */ 1823 emit_insn (gen_blockage ()); 1824 } 1825 1826 /* Compute parameters for stack clash probing a dynamic stack 1827 allocation of SIZE bytes. 1828 1829 We compute ROUNDED_SIZE, LAST_ADDR, RESIDUAL and PROBE_INTERVAL. 1830 1831 Additionally we conditionally dump the type of probing that will 1832 be needed given the values computed. */ 1833 1834 void 1835 compute_stack_clash_protection_loop_data (rtx *rounded_size, rtx *last_addr, 1836 rtx *residual, 1837 HOST_WIDE_INT *probe_interval, 1838 rtx size) 1839 { 1840 /* Round SIZE down to STACK_CLASH_PROTECTION_PROBE_INTERVAL */ 1841 *probe_interval 1842 = 1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL); 1843 *rounded_size = simplify_gen_binary (AND, Pmode, size, 1844 GEN_INT (-*probe_interval)); 1845 1846 /* Compute the value of the stack pointer for the last iteration. 1847 It's just SP + ROUNDED_SIZE. */ 1848 rtx rounded_size_op = force_operand (*rounded_size, NULL_RTX); 1849 *last_addr = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1850 stack_pointer_rtx, 1851 rounded_size_op), 1852 NULL_RTX); 1853 1854 /* Compute any residuals not allocated by the loop above. Residuals 1855 are just the ROUNDED_SIZE - SIZE. */ 1856 *residual = simplify_gen_binary (MINUS, Pmode, size, *rounded_size); 1857 1858 /* Dump key information to make writing tests easy. */ 1859 if (dump_file) 1860 { 1861 if (*rounded_size == CONST0_RTX (Pmode)) 1862 fprintf (dump_file, 1863 "Stack clash skipped dynamic allocation and probing loop.\n"); 1864 else if (CONST_INT_P (*rounded_size) 1865 && INTVAL (*rounded_size) <= 4 * *probe_interval) 1866 fprintf (dump_file, 1867 "Stack clash dynamic allocation and probing inline.\n"); 1868 else if (CONST_INT_P (*rounded_size)) 1869 fprintf (dump_file, 1870 "Stack clash dynamic allocation and probing in " 1871 "rotated loop.\n"); 1872 else 1873 fprintf (dump_file, 1874 "Stack clash dynamic allocation and probing in loop.\n"); 1875 1876 if (*residual != CONST0_RTX (Pmode)) 1877 fprintf (dump_file, 1878 "Stack clash dynamic allocation and probing residuals.\n"); 1879 else 1880 fprintf (dump_file, 1881 "Stack clash skipped dynamic allocation and " 1882 "probing residuals.\n"); 1883 } 1884 } 1885 1886 /* Emit the start of an allocate/probe loop for stack 1887 clash protection. 1888 1889 LOOP_LAB and END_LAB are returned for use when we emit the 1890 end of the loop. 1891 1892 LAST addr is the value for SP which stops the loop. */ 1893 void 1894 emit_stack_clash_protection_probe_loop_start (rtx *loop_lab, 1895 rtx *end_lab, 1896 rtx last_addr, 1897 bool rotated) 1898 { 1899 /* Essentially we want to emit any setup code, the top of loop 1900 label and the comparison at the top of the loop. */ 1901 *loop_lab = gen_label_rtx (); 1902 *end_lab = gen_label_rtx (); 1903 1904 emit_label (*loop_lab); 1905 if (!rotated) 1906 emit_cmp_and_jump_insns (stack_pointer_rtx, last_addr, EQ, NULL_RTX, 1907 Pmode, 1, *end_lab); 1908 } 1909 1910 /* Emit the end of a stack clash probing loop. 1911 1912 This consists of just the jump back to LOOP_LAB and 1913 emitting END_LOOP after the loop. */ 1914 1915 void 1916 emit_stack_clash_protection_probe_loop_end (rtx loop_lab, rtx end_loop, 1917 rtx last_addr, bool rotated) 1918 { 1919 if (rotated) 1920 emit_cmp_and_jump_insns (stack_pointer_rtx, last_addr, NE, NULL_RTX, 1921 Pmode, 1, loop_lab); 1922 else 1923 emit_jump (loop_lab); 1924 1925 emit_label (end_loop); 1926 1927 } 1928 1929 /* Adjust the stack pointer by minus SIZE (an rtx for a number of bytes) 1930 while probing it. This pushes when SIZE is positive. SIZE need not 1931 be constant. 1932 1933 This is subtly different than anti_adjust_stack_and_probe to try and 1934 prevent stack-clash attacks 1935 1936 1. It must assume no knowledge of the probing state, any allocation 1937 must probe. 1938 1939 Consider the case of a 1 byte alloca in a loop. If the sum of the 1940 allocations is large, then this could be used to jump the guard if 1941 probes were not emitted. 1942 1943 2. It never skips probes, whereas anti_adjust_stack_and_probe will 1944 skip probes on the first couple PROBE_INTERVALs on the assumption 1945 they're done elsewhere. 1946 1947 3. It only allocates and probes SIZE bytes, it does not need to 1948 allocate/probe beyond that because this probing style does not 1949 guarantee signal handling capability if the guard is hit. */ 1950 1951 static void 1952 anti_adjust_stack_and_probe_stack_clash (rtx size) 1953 { 1954 /* First ensure SIZE is Pmode. */ 1955 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode) 1956 size = convert_to_mode (Pmode, size, 1); 1957 1958 /* We can get here with a constant size on some targets. */ 1959 rtx rounded_size, last_addr, residual; 1960 HOST_WIDE_INT probe_interval; 1961 compute_stack_clash_protection_loop_data (&rounded_size, &last_addr, 1962 &residual, &probe_interval, size); 1963 1964 if (rounded_size != CONST0_RTX (Pmode)) 1965 { 1966 if (CONST_INT_P (rounded_size) 1967 && INTVAL (rounded_size) <= 4 * probe_interval) 1968 { 1969 for (HOST_WIDE_INT i = 0; 1970 i < INTVAL (rounded_size); 1971 i += probe_interval) 1972 { 1973 anti_adjust_stack (GEN_INT (probe_interval)); 1974 1975 /* The prologue does not probe residuals. Thus the offset 1976 here to probe just beyond what the prologue had already 1977 allocated. */ 1978 emit_stack_probe (plus_constant (Pmode, stack_pointer_rtx, 1979 (probe_interval 1980 - GET_MODE_SIZE (word_mode)))); 1981 emit_insn (gen_blockage ()); 1982 } 1983 } 1984 else 1985 { 1986 rtx loop_lab, end_loop; 1987 bool rotate_loop = CONST_INT_P (rounded_size); 1988 emit_stack_clash_protection_probe_loop_start (&loop_lab, &end_loop, 1989 last_addr, rotate_loop); 1990 1991 anti_adjust_stack (GEN_INT (probe_interval)); 1992 1993 /* The prologue does not probe residuals. Thus the offset here 1994 to probe just beyond what the prologue had already allocated. */ 1995 emit_stack_probe (plus_constant (Pmode, stack_pointer_rtx, 1996 (probe_interval 1997 - GET_MODE_SIZE (word_mode)))); 1998 1999 emit_stack_clash_protection_probe_loop_end (loop_lab, end_loop, 2000 last_addr, rotate_loop); 2001 emit_insn (gen_blockage ()); 2002 } 2003 } 2004 2005 if (residual != CONST0_RTX (Pmode)) 2006 { 2007 rtx label = NULL_RTX; 2008 /* RESIDUAL could be zero at runtime and in that case *sp could 2009 hold live data. Furthermore, we do not want to probe into the 2010 red zone. 2011 2012 Go ahead and just guard the probe at *sp on RESIDUAL != 0 at 2013 runtime if RESIDUAL is not a compile time constant. */ 2014 if (!CONST_INT_P (residual)) 2015 { 2016 label = gen_label_rtx (); 2017 emit_cmp_and_jump_insns (residual, CONST0_RTX (GET_MODE (residual)), 2018 EQ, NULL_RTX, Pmode, 1, label); 2019 } 2020 2021 rtx x = force_reg (Pmode, plus_constant (Pmode, residual, 2022 -GET_MODE_SIZE (word_mode))); 2023 anti_adjust_stack (residual); 2024 emit_stack_probe (gen_rtx_PLUS (Pmode, stack_pointer_rtx, x)); 2025 emit_insn (gen_blockage ()); 2026 if (!CONST_INT_P (residual)) 2027 emit_label (label); 2028 } 2029 2030 /* Some targets make optimistic assumptions in their prologues about 2031 how the caller may have probed the stack. Make sure we honor 2032 those assumptions when needed. */ 2033 if (size != CONST0_RTX (Pmode) 2034 && targetm.stack_clash_protection_final_dynamic_probe (residual)) 2035 { 2036 /* SIZE could be zero at runtime and in that case *sp could hold 2037 live data. Furthermore, we don't want to probe into the red 2038 zone. 2039 2040 Go ahead and just guard the probe at *sp on SIZE != 0 at runtime 2041 if SIZE is not a compile time constant. */ 2042 rtx label = NULL_RTX; 2043 if (!CONST_INT_P (size)) 2044 { 2045 label = gen_label_rtx (); 2046 emit_cmp_and_jump_insns (size, CONST0_RTX (GET_MODE (size)), 2047 EQ, NULL_RTX, Pmode, 1, label); 2048 } 2049 2050 emit_stack_probe (stack_pointer_rtx); 2051 emit_insn (gen_blockage ()); 2052 if (!CONST_INT_P (size)) 2053 emit_label (label); 2054 } 2055 } 2056 2057 2058 /* Adjust the stack pointer by minus SIZE (an rtx for a number of bytes) 2059 while probing it. This pushes when SIZE is positive. SIZE need not 2060 be constant. If ADJUST_BACK is true, adjust back the stack pointer 2061 by plus SIZE at the end. */ 2062 2063 void 2064 anti_adjust_stack_and_probe (rtx size, bool adjust_back) 2065 { 2066 /* We skip the probe for the first interval + a small dope of 4 words and 2067 probe that many bytes past the specified size to maintain a protection 2068 area at the botton of the stack. */ 2069 const int dope = 4 * UNITS_PER_WORD; 2070 2071 /* First ensure SIZE is Pmode. */ 2072 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode) 2073 size = convert_to_mode (Pmode, size, 1); 2074 2075 /* If we have a constant small number of probes to generate, that's the 2076 easy case. */ 2077 if (CONST_INT_P (size) && INTVAL (size) < 7 * PROBE_INTERVAL) 2078 { 2079 HOST_WIDE_INT isize = INTVAL (size), i; 2080 bool first_probe = true; 2081 2082 /* Adjust SP and probe at PROBE_INTERVAL + N * PROBE_INTERVAL for 2083 values of N from 1 until it exceeds SIZE. If only one probe is 2084 needed, this will not generate any code. Then adjust and probe 2085 to PROBE_INTERVAL + SIZE. */ 2086 for (i = PROBE_INTERVAL; i < isize; i += PROBE_INTERVAL) 2087 { 2088 if (first_probe) 2089 { 2090 anti_adjust_stack (GEN_INT (2 * PROBE_INTERVAL + dope)); 2091 first_probe = false; 2092 } 2093 else 2094 anti_adjust_stack (GEN_INT (PROBE_INTERVAL)); 2095 emit_stack_probe (stack_pointer_rtx); 2096 } 2097 2098 if (first_probe) 2099 anti_adjust_stack (plus_constant (Pmode, size, PROBE_INTERVAL + dope)); 2100 else 2101 anti_adjust_stack (plus_constant (Pmode, size, PROBE_INTERVAL - i)); 2102 emit_stack_probe (stack_pointer_rtx); 2103 } 2104 2105 /* In the variable case, do the same as above, but in a loop. Note that we 2106 must be extra careful with variables wrapping around because we might be 2107 at the very top (or the very bottom) of the address space and we have to 2108 be able to handle this case properly; in particular, we use an equality 2109 test for the loop condition. */ 2110 else 2111 { 2112 rtx rounded_size, rounded_size_op, last_addr, temp; 2113 rtx_code_label *loop_lab = gen_label_rtx (); 2114 rtx_code_label *end_lab = gen_label_rtx (); 2115 2116 2117 /* Step 1: round SIZE to the previous multiple of the interval. */ 2118 2119 /* ROUNDED_SIZE = SIZE & -PROBE_INTERVAL */ 2120 rounded_size 2121 = simplify_gen_binary (AND, Pmode, size, 2122 gen_int_mode (-PROBE_INTERVAL, Pmode)); 2123 rounded_size_op = force_operand (rounded_size, NULL_RTX); 2124 2125 2126 /* Step 2: compute initial and final value of the loop counter. */ 2127 2128 /* SP = SP_0 + PROBE_INTERVAL. */ 2129 anti_adjust_stack (GEN_INT (PROBE_INTERVAL + dope)); 2130 2131 /* LAST_ADDR = SP_0 + PROBE_INTERVAL + ROUNDED_SIZE. */ 2132 last_addr = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 2133 stack_pointer_rtx, 2134 rounded_size_op), NULL_RTX); 2135 2136 2137 /* Step 3: the loop 2138 2139 while (SP != LAST_ADDR) 2140 { 2141 SP = SP + PROBE_INTERVAL 2142 probe at SP 2143 } 2144 2145 adjusts SP and probes at PROBE_INTERVAL + N * PROBE_INTERVAL for 2146 values of N from 1 until it is equal to ROUNDED_SIZE. */ 2147 2148 emit_label (loop_lab); 2149 2150 /* Jump to END_LAB if SP == LAST_ADDR. */ 2151 emit_cmp_and_jump_insns (stack_pointer_rtx, last_addr, EQ, NULL_RTX, 2152 Pmode, 1, end_lab); 2153 2154 /* SP = SP + PROBE_INTERVAL and probe at SP. */ 2155 anti_adjust_stack (GEN_INT (PROBE_INTERVAL)); 2156 emit_stack_probe (stack_pointer_rtx); 2157 2158 emit_jump (loop_lab); 2159 2160 emit_label (end_lab); 2161 2162 2163 /* Step 4: adjust SP and probe at PROBE_INTERVAL + SIZE if we cannot 2164 assert at compile-time that SIZE is equal to ROUNDED_SIZE. */ 2165 2166 /* TEMP = SIZE - ROUNDED_SIZE. */ 2167 temp = simplify_gen_binary (MINUS, Pmode, size, rounded_size); 2168 if (temp != const0_rtx) 2169 { 2170 /* Manual CSE if the difference is not known at compile-time. */ 2171 if (GET_CODE (temp) != CONST_INT) 2172 temp = gen_rtx_MINUS (Pmode, size, rounded_size_op); 2173 anti_adjust_stack (temp); 2174 emit_stack_probe (stack_pointer_rtx); 2175 } 2176 } 2177 2178 /* Adjust back and account for the additional first interval. */ 2179 if (adjust_back) 2180 adjust_stack (plus_constant (Pmode, size, PROBE_INTERVAL + dope)); 2181 else 2182 adjust_stack (GEN_INT (PROBE_INTERVAL + dope)); 2183 } 2184 2185 /* Return an rtx representing the register or memory location 2186 in which a scalar value of data type VALTYPE 2187 was returned by a function call to function FUNC. 2188 FUNC is a FUNCTION_DECL, FNTYPE a FUNCTION_TYPE node if the precise 2189 function is known, otherwise 0. 2190 OUTGOING is 1 if on a machine with register windows this function 2191 should return the register in which the function will put its result 2192 and 0 otherwise. */ 2193 2194 rtx 2195 hard_function_value (const_tree valtype, const_tree func, const_tree fntype, 2196 int outgoing ATTRIBUTE_UNUSED) 2197 { 2198 rtx val; 2199 2200 val = targetm.calls.function_value (valtype, func ? func : fntype, outgoing); 2201 2202 if (REG_P (val) 2203 && GET_MODE (val) == BLKmode) 2204 { 2205 unsigned HOST_WIDE_INT bytes = arg_int_size_in_bytes (valtype); 2206 opt_scalar_int_mode tmpmode; 2207 2208 /* int_size_in_bytes can return -1. We don't need a check here 2209 since the value of bytes will then be large enough that no 2210 mode will match anyway. */ 2211 2212 FOR_EACH_MODE_IN_CLASS (tmpmode, MODE_INT) 2213 { 2214 /* Have we found a large enough mode? */ 2215 if (GET_MODE_SIZE (tmpmode.require ()) >= bytes) 2216 break; 2217 } 2218 2219 PUT_MODE (val, tmpmode.require ()); 2220 } 2221 return val; 2222 } 2223 2224 /* Return an rtx representing the register or memory location 2225 in which a scalar value of mode MODE was returned by a library call. */ 2226 2227 rtx 2228 hard_libcall_value (machine_mode mode, rtx fun) 2229 { 2230 return targetm.calls.libcall_value (mode, fun); 2231 } 2232 2233 /* Look up the tree code for a given rtx code 2234 to provide the arithmetic operation for real_arithmetic. 2235 The function returns an int because the caller may not know 2236 what `enum tree_code' means. */ 2237 2238 int 2239 rtx_to_tree_code (enum rtx_code code) 2240 { 2241 enum tree_code tcode; 2242 2243 switch (code) 2244 { 2245 case PLUS: 2246 tcode = PLUS_EXPR; 2247 break; 2248 case MINUS: 2249 tcode = MINUS_EXPR; 2250 break; 2251 case MULT: 2252 tcode = MULT_EXPR; 2253 break; 2254 case DIV: 2255 tcode = RDIV_EXPR; 2256 break; 2257 case SMIN: 2258 tcode = MIN_EXPR; 2259 break; 2260 case SMAX: 2261 tcode = MAX_EXPR; 2262 break; 2263 default: 2264 tcode = LAST_AND_UNUSED_TREE_CODE; 2265 break; 2266 } 2267 return ((int) tcode); 2268 } 2269 2270 #include "gt-explow.h" 2271