explow.c revision 132718
1/* Subroutines for manipulating rtx's in semantically interesting ways. 2 Copyright (C) 1987, 1991, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2002111-1307, USA. */ 21 22 23#include "config.h" 24#include "system.h" 25#include "coretypes.h" 26#include "tm.h" 27#include "toplev.h" 28#include "rtl.h" 29#include "tree.h" 30#include "tm_p.h" 31#include "flags.h" 32#include "function.h" 33#include "expr.h" 34#include "optabs.h" 35#include "hard-reg-set.h" 36#include "insn-config.h" 37#include "ggc.h" 38#include "recog.h" 39#include "langhooks.h" 40 41static rtx break_out_memory_refs (rtx); 42static void emit_stack_probe (rtx); 43 44 45/* Truncate and perhaps sign-extend C as appropriate for MODE. */ 46 47HOST_WIDE_INT 48trunc_int_for_mode (HOST_WIDE_INT c, enum machine_mode mode) 49{ 50 int width = GET_MODE_BITSIZE (mode); 51 52 /* You want to truncate to a _what_? */ 53 if (! SCALAR_INT_MODE_P (mode)) 54 abort (); 55 56 /* Canonicalize BImode to 0 and STORE_FLAG_VALUE. */ 57 if (mode == BImode) 58 return c & 1 ? STORE_FLAG_VALUE : 0; 59 60 /* Sign-extend for the requested mode. */ 61 62 if (width < HOST_BITS_PER_WIDE_INT) 63 { 64 HOST_WIDE_INT sign = 1; 65 sign <<= width - 1; 66 c &= (sign << 1) - 1; 67 c ^= sign; 68 c -= sign; 69 } 70 71 return c; 72} 73 74/* Return an rtx for the sum of X and the integer C. 75 76 This function should be used via the `plus_constant' macro. */ 77 78rtx 79plus_constant_wide (rtx x, HOST_WIDE_INT c) 80{ 81 RTX_CODE code; 82 rtx y; 83 enum machine_mode mode; 84 rtx tem; 85 int all_constant = 0; 86 87 if (c == 0) 88 return x; 89 90 restart: 91 92 code = GET_CODE (x); 93 mode = GET_MODE (x); 94 y = x; 95 96 switch (code) 97 { 98 case CONST_INT: 99 return GEN_INT (INTVAL (x) + c); 100 101 case CONST_DOUBLE: 102 { 103 unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x); 104 HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x); 105 unsigned HOST_WIDE_INT l2 = c; 106 HOST_WIDE_INT h2 = c < 0 ? ~0 : 0; 107 unsigned HOST_WIDE_INT lv; 108 HOST_WIDE_INT hv; 109 110 add_double (l1, h1, l2, h2, &lv, &hv); 111 112 return immed_double_const (lv, hv, VOIDmode); 113 } 114 115 case MEM: 116 /* If this is a reference to the constant pool, try replacing it with 117 a reference to a new constant. If the resulting address isn't 118 valid, don't return it because we have no way to validize it. */ 119 if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF 120 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0))) 121 { 122 tem 123 = force_const_mem (GET_MODE (x), 124 plus_constant (get_pool_constant (XEXP (x, 0)), 125 c)); 126 if (memory_address_p (GET_MODE (tem), XEXP (tem, 0))) 127 return tem; 128 } 129 break; 130 131 case CONST: 132 /* If adding to something entirely constant, set a flag 133 so that we can add a CONST around the result. */ 134 x = XEXP (x, 0); 135 all_constant = 1; 136 goto restart; 137 138 case SYMBOL_REF: 139 case LABEL_REF: 140 all_constant = 1; 141 break; 142 143 case PLUS: 144 /* The interesting case is adding the integer to a sum. 145 Look for constant term in the sum and combine 146 with C. For an integer constant term, we make a combined 147 integer. For a constant term that is not an explicit integer, 148 we cannot really combine, but group them together anyway. 149 150 Restart or use a recursive call in case the remaining operand is 151 something that we handle specially, such as a SYMBOL_REF. 152 153 We may not immediately return from the recursive call here, lest 154 all_constant gets lost. */ 155 156 if (GET_CODE (XEXP (x, 1)) == CONST_INT) 157 { 158 c += INTVAL (XEXP (x, 1)); 159 160 if (GET_MODE (x) != VOIDmode) 161 c = trunc_int_for_mode (c, GET_MODE (x)); 162 163 x = XEXP (x, 0); 164 goto restart; 165 } 166 else if (CONSTANT_P (XEXP (x, 1))) 167 { 168 x = gen_rtx_PLUS (mode, XEXP (x, 0), plus_constant (XEXP (x, 1), c)); 169 c = 0; 170 } 171 else if (find_constant_term_loc (&y)) 172 { 173 /* We need to be careful since X may be shared and we can't 174 modify it in place. */ 175 rtx copy = copy_rtx (x); 176 rtx *const_loc = find_constant_term_loc (©); 177 178 *const_loc = plus_constant (*const_loc, c); 179 x = copy; 180 c = 0; 181 } 182 break; 183 184 default: 185 break; 186 } 187 188 if (c != 0) 189 x = gen_rtx_PLUS (mode, x, GEN_INT (c)); 190 191 if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF) 192 return x; 193 else if (all_constant) 194 return gen_rtx_CONST (mode, x); 195 else 196 return x; 197} 198 199/* If X is a sum, return a new sum like X but lacking any constant terms. 200 Add all the removed constant terms into *CONSTPTR. 201 X itself is not altered. The result != X if and only if 202 it is not isomorphic to X. */ 203 204rtx 205eliminate_constant_term (rtx x, rtx *constptr) 206{ 207 rtx x0, x1; 208 rtx tem; 209 210 if (GET_CODE (x) != PLUS) 211 return x; 212 213 /* First handle constants appearing at this level explicitly. */ 214 if (GET_CODE (XEXP (x, 1)) == CONST_INT 215 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr, 216 XEXP (x, 1))) 217 && GET_CODE (tem) == CONST_INT) 218 { 219 *constptr = tem; 220 return eliminate_constant_term (XEXP (x, 0), constptr); 221 } 222 223 tem = const0_rtx; 224 x0 = eliminate_constant_term (XEXP (x, 0), &tem); 225 x1 = eliminate_constant_term (XEXP (x, 1), &tem); 226 if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0)) 227 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), 228 *constptr, tem)) 229 && GET_CODE (tem) == CONST_INT) 230 { 231 *constptr = tem; 232 return gen_rtx_PLUS (GET_MODE (x), x0, x1); 233 } 234 235 return x; 236} 237 238/* Return an rtx for the size in bytes of the value of EXP. */ 239 240rtx 241expr_size (tree exp) 242{ 243 tree size = (*lang_hooks.expr_size) (exp); 244 245 if (CONTAINS_PLACEHOLDER_P (size)) 246 size = build (WITH_RECORD_EXPR, sizetype, size, exp); 247 248 return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), 0); 249} 250 251/* Return a wide integer for the size in bytes of the value of EXP, or -1 252 if the size can vary or is larger than an integer. */ 253 254HOST_WIDE_INT 255int_expr_size (tree exp) 256{ 257 tree t = (*lang_hooks.expr_size) (exp); 258 259 if (t == 0 260 || TREE_CODE (t) != INTEGER_CST 261 || TREE_OVERFLOW (t) 262 || TREE_INT_CST_HIGH (t) != 0 263 /* If the result would appear negative, it's too big to represent. */ 264 || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0) 265 return -1; 266 267 return TREE_INT_CST_LOW (t); 268} 269 270/* Return a copy of X in which all memory references 271 and all constants that involve symbol refs 272 have been replaced with new temporary registers. 273 Also emit code to load the memory locations and constants 274 into those registers. 275 276 If X contains no such constants or memory references, 277 X itself (not a copy) is returned. 278 279 If a constant is found in the address that is not a legitimate constant 280 in an insn, it is left alone in the hope that it might be valid in the 281 address. 282 283 X may contain no arithmetic except addition, subtraction and multiplication. 284 Values returned by expand_expr with 1 for sum_ok fit this constraint. */ 285 286static rtx 287break_out_memory_refs (rtx x) 288{ 289 if (GET_CODE (x) == MEM 290 || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x) 291 && GET_MODE (x) != VOIDmode)) 292 x = force_reg (GET_MODE (x), x); 293 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS 294 || GET_CODE (x) == MULT) 295 { 296 rtx op0 = break_out_memory_refs (XEXP (x, 0)); 297 rtx op1 = break_out_memory_refs (XEXP (x, 1)); 298 299 if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1)) 300 x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1); 301 } 302 303 return x; 304} 305 306/* Given X, a memory address in ptr_mode, convert it to an address 307 in Pmode, or vice versa (TO_MODE says which way). We take advantage of 308 the fact that pointers are not allowed to overflow by commuting arithmetic 309 operations over conversions so that address arithmetic insns can be 310 used. */ 311 312rtx 313convert_memory_address (enum machine_mode to_mode ATTRIBUTE_UNUSED, 314 rtx x) 315{ 316#ifndef POINTERS_EXTEND_UNSIGNED 317 return x; 318#else /* defined(POINTERS_EXTEND_UNSIGNED) */ 319 enum machine_mode from_mode; 320 rtx temp; 321 enum rtx_code code; 322 323 /* If X already has the right mode, just return it. */ 324 if (GET_MODE (x) == to_mode) 325 return x; 326 327 from_mode = to_mode == ptr_mode ? Pmode : ptr_mode; 328 329 /* Here we handle some special cases. If none of them apply, fall through 330 to the default case. */ 331 switch (GET_CODE (x)) 332 { 333 case CONST_INT: 334 case CONST_DOUBLE: 335 if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)) 336 code = TRUNCATE; 337 else if (POINTERS_EXTEND_UNSIGNED < 0) 338 break; 339 else if (POINTERS_EXTEND_UNSIGNED > 0) 340 code = ZERO_EXTEND; 341 else 342 code = SIGN_EXTEND; 343 temp = simplify_unary_operation (code, to_mode, x, from_mode); 344 if (temp) 345 return temp; 346 break; 347 348 case SUBREG: 349 if ((SUBREG_PROMOTED_VAR_P (x) || REG_POINTER (SUBREG_REG (x))) 350 && GET_MODE (SUBREG_REG (x)) == to_mode) 351 return SUBREG_REG (x); 352 break; 353 354 case LABEL_REF: 355 temp = gen_rtx_LABEL_REF (to_mode, XEXP (x, 0)); 356 LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x); 357 return temp; 358 break; 359 360 case SYMBOL_REF: 361 temp = shallow_copy_rtx (x); 362 PUT_MODE (temp, to_mode); 363 return temp; 364 break; 365 366 case CONST: 367 return gen_rtx_CONST (to_mode, 368 convert_memory_address (to_mode, XEXP (x, 0))); 369 break; 370 371 case PLUS: 372 case MULT: 373 /* For addition we can safely permute the conversion and addition 374 operation if one operand is a constant and converting the constant 375 does not change it. We can always safely permute them if we are 376 making the address narrower. */ 377 if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode) 378 || (GET_CODE (x) == PLUS 379 && GET_CODE (XEXP (x, 1)) == CONST_INT 380 && XEXP (x, 1) == convert_memory_address (to_mode, XEXP (x, 1)))) 381 return gen_rtx_fmt_ee (GET_CODE (x), to_mode, 382 convert_memory_address (to_mode, XEXP (x, 0)), 383 XEXP (x, 1)); 384 break; 385 386 default: 387 break; 388 } 389 390 return convert_modes (to_mode, from_mode, 391 x, POINTERS_EXTEND_UNSIGNED); 392#endif /* defined(POINTERS_EXTEND_UNSIGNED) */ 393} 394 395/* Given a memory address or facsimile X, construct a new address, 396 currently equivalent, that is stable: future stores won't change it. 397 398 X must be composed of constants, register and memory references 399 combined with addition, subtraction and multiplication: 400 in other words, just what you can get from expand_expr if sum_ok is 1. 401 402 Works by making copies of all regs and memory locations used 403 by X and combining them the same way X does. 404 You could also stabilize the reference to this address 405 by copying the address to a register with copy_to_reg; 406 but then you wouldn't get indexed addressing in the reference. */ 407 408rtx 409copy_all_regs (rtx x) 410{ 411 if (GET_CODE (x) == REG) 412 { 413 if (REGNO (x) != FRAME_POINTER_REGNUM 414#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM 415 && REGNO (x) != HARD_FRAME_POINTER_REGNUM 416#endif 417 ) 418 x = copy_to_reg (x); 419 } 420 else if (GET_CODE (x) == MEM) 421 x = copy_to_reg (x); 422 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS 423 || GET_CODE (x) == MULT) 424 { 425 rtx op0 = copy_all_regs (XEXP (x, 0)); 426 rtx op1 = copy_all_regs (XEXP (x, 1)); 427 if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1)) 428 x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1); 429 } 430 return x; 431} 432 433/* Return something equivalent to X but valid as a memory address 434 for something of mode MODE. When X is not itself valid, this 435 works by copying X or subexpressions of it into registers. */ 436 437rtx 438memory_address (enum machine_mode mode, rtx x) 439{ 440 rtx oldx = x; 441 442 if (GET_CODE (x) == ADDRESSOF) 443 return x; 444 445 x = convert_memory_address (Pmode, x); 446 447 /* By passing constant addresses through registers 448 we get a chance to cse them. */ 449 if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)) 450 x = force_reg (Pmode, x); 451 452 /* Accept a QUEUED that refers to a REG 453 even though that isn't a valid address. 454 On attempting to put this in an insn we will call protect_from_queue 455 which will turn it into a REG, which is valid. */ 456 else if (GET_CODE (x) == QUEUED 457 && GET_CODE (QUEUED_VAR (x)) == REG) 458 ; 459 460 /* We get better cse by rejecting indirect addressing at this stage. 461 Let the combiner create indirect addresses where appropriate. 462 For now, generate the code so that the subexpressions useful to share 463 are visible. But not if cse won't be done! */ 464 else 465 { 466 if (! cse_not_expected && GET_CODE (x) != REG) 467 x = break_out_memory_refs (x); 468 469 /* At this point, any valid address is accepted. */ 470 GO_IF_LEGITIMATE_ADDRESS (mode, x, win); 471 472 /* If it was valid before but breaking out memory refs invalidated it, 473 use it the old way. */ 474 if (memory_address_p (mode, oldx)) 475 goto win2; 476 477 /* Perform machine-dependent transformations on X 478 in certain cases. This is not necessary since the code 479 below can handle all possible cases, but machine-dependent 480 transformations can make better code. */ 481 LEGITIMIZE_ADDRESS (x, oldx, mode, win); 482 483 /* PLUS and MULT can appear in special ways 484 as the result of attempts to make an address usable for indexing. 485 Usually they are dealt with by calling force_operand, below. 486 But a sum containing constant terms is special 487 if removing them makes the sum a valid address: 488 then we generate that address in a register 489 and index off of it. We do this because it often makes 490 shorter code, and because the addresses thus generated 491 in registers often become common subexpressions. */ 492 if (GET_CODE (x) == PLUS) 493 { 494 rtx constant_term = const0_rtx; 495 rtx y = eliminate_constant_term (x, &constant_term); 496 if (constant_term == const0_rtx 497 || ! memory_address_p (mode, y)) 498 x = force_operand (x, NULL_RTX); 499 else 500 { 501 y = gen_rtx_PLUS (GET_MODE (x), copy_to_reg (y), constant_term); 502 if (! memory_address_p (mode, y)) 503 x = force_operand (x, NULL_RTX); 504 else 505 x = y; 506 } 507 } 508 509 else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS) 510 x = force_operand (x, NULL_RTX); 511 512 /* If we have a register that's an invalid address, 513 it must be a hard reg of the wrong class. Copy it to a pseudo. */ 514 else if (GET_CODE (x) == REG) 515 x = copy_to_reg (x); 516 517 /* Last resort: copy the value to a register, since 518 the register is a valid address. */ 519 else 520 x = force_reg (Pmode, x); 521 522 goto done; 523 524 win2: 525 x = oldx; 526 win: 527 if (flag_force_addr && ! cse_not_expected && GET_CODE (x) != REG 528 /* Don't copy an addr via a reg if it is one of our stack slots. */ 529 && ! (GET_CODE (x) == PLUS 530 && (XEXP (x, 0) == virtual_stack_vars_rtx 531 || XEXP (x, 0) == virtual_incoming_args_rtx))) 532 { 533 if (general_operand (x, Pmode)) 534 x = force_reg (Pmode, x); 535 else 536 x = force_operand (x, NULL_RTX); 537 } 538 } 539 540 done: 541 542 /* If we didn't change the address, we are done. Otherwise, mark 543 a reg as a pointer if we have REG or REG + CONST_INT. */ 544 if (oldx == x) 545 return x; 546 else if (GET_CODE (x) == REG) 547 mark_reg_pointer (x, BITS_PER_UNIT); 548 else if (GET_CODE (x) == PLUS 549 && GET_CODE (XEXP (x, 0)) == REG 550 && GET_CODE (XEXP (x, 1)) == CONST_INT) 551 mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT); 552 553 /* OLDX may have been the address on a temporary. Update the address 554 to indicate that X is now used. */ 555 update_temp_slot_address (oldx, x); 556 557 return x; 558} 559 560/* Like `memory_address' but pretend `flag_force_addr' is 0. */ 561 562rtx 563memory_address_noforce (enum machine_mode mode, rtx x) 564{ 565 int ambient_force_addr = flag_force_addr; 566 rtx val; 567 568 flag_force_addr = 0; 569 val = memory_address (mode, x); 570 flag_force_addr = ambient_force_addr; 571 return val; 572} 573 574/* Convert a mem ref into one with a valid memory address. 575 Pass through anything else unchanged. */ 576 577rtx 578validize_mem (rtx ref) 579{ 580 if (GET_CODE (ref) != MEM) 581 return ref; 582 if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0))) 583 && memory_address_p (GET_MODE (ref), XEXP (ref, 0))) 584 return ref; 585 586 /* Don't alter REF itself, since that is probably a stack slot. */ 587 return replace_equiv_address (ref, XEXP (ref, 0)); 588} 589 590/* Given REF, either a MEM or a REG, and T, either the type of X or 591 the expression corresponding to REF, set RTX_UNCHANGING_P if 592 appropriate. */ 593 594void 595maybe_set_unchanging (rtx ref, tree t) 596{ 597 /* We can set RTX_UNCHANGING_P from TREE_READONLY for decls whose 598 initialization is only executed once, or whose initializer always 599 has the same value. Currently we simplify this to PARM_DECLs in the 600 first case, and decls with TREE_CONSTANT initializers in the second. */ 601 602 if ((TREE_READONLY (t) && DECL_P (t) 603 && (DECL_EXTERNAL (t) 604 || TREE_CODE (t) == PARM_DECL 605 || (DECL_INITIAL (t) && TREE_CONSTANT (DECL_INITIAL (t))))) 606 || TREE_CODE_CLASS (TREE_CODE (t)) == 'c') 607 RTX_UNCHANGING_P (ref) = 1; 608} 609 610/* Return a modified copy of X with its memory address copied 611 into a temporary register to protect it from side effects. 612 If X is not a MEM, it is returned unchanged (and not copied). 613 Perhaps even if it is a MEM, if there is no need to change it. */ 614 615rtx 616stabilize (rtx x) 617{ 618 if (GET_CODE (x) != MEM 619 || ! rtx_unstable_p (XEXP (x, 0))) 620 return x; 621 622 return 623 replace_equiv_address (x, force_reg (Pmode, copy_all_regs (XEXP (x, 0)))); 624} 625 626/* Copy the value or contents of X to a new temp reg and return that reg. */ 627 628rtx 629copy_to_reg (rtx x) 630{ 631 rtx temp = gen_reg_rtx (GET_MODE (x)); 632 633 /* If not an operand, must be an address with PLUS and MULT so 634 do the computation. */ 635 if (! general_operand (x, VOIDmode)) 636 x = force_operand (x, temp); 637 638 if (x != temp) 639 emit_move_insn (temp, x); 640 641 return temp; 642} 643 644/* Like copy_to_reg but always give the new register mode Pmode 645 in case X is a constant. */ 646 647rtx 648copy_addr_to_reg (rtx x) 649{ 650 return copy_to_mode_reg (Pmode, x); 651} 652 653/* Like copy_to_reg but always give the new register mode MODE 654 in case X is a constant. */ 655 656rtx 657copy_to_mode_reg (enum machine_mode mode, rtx x) 658{ 659 rtx temp = gen_reg_rtx (mode); 660 661 /* If not an operand, must be an address with PLUS and MULT so 662 do the computation. */ 663 if (! general_operand (x, VOIDmode)) 664 x = force_operand (x, temp); 665 666 if (GET_MODE (x) != mode && GET_MODE (x) != VOIDmode) 667 abort (); 668 if (x != temp) 669 emit_move_insn (temp, x); 670 return temp; 671} 672 673/* Load X into a register if it is not already one. 674 Use mode MODE for the register. 675 X should be valid for mode MODE, but it may be a constant which 676 is valid for all integer modes; that's why caller must specify MODE. 677 678 The caller must not alter the value in the register we return, 679 since we mark it as a "constant" register. */ 680 681rtx 682force_reg (enum machine_mode mode, rtx x) 683{ 684 rtx temp, insn, set; 685 686 if (GET_CODE (x) == REG) 687 return x; 688 689 if (general_operand (x, mode)) 690 { 691 temp = gen_reg_rtx (mode); 692 insn = emit_move_insn (temp, x); 693 } 694 else 695 { 696 temp = force_operand (x, NULL_RTX); 697 if (GET_CODE (temp) == REG) 698 insn = get_last_insn (); 699 else 700 { 701 rtx temp2 = gen_reg_rtx (mode); 702 insn = emit_move_insn (temp2, temp); 703 temp = temp2; 704 } 705 } 706 707 /* Let optimizers know that TEMP's value never changes 708 and that X can be substituted for it. Don't get confused 709 if INSN set something else (such as a SUBREG of TEMP). */ 710 if (CONSTANT_P (x) 711 && (set = single_set (insn)) != 0 712 && SET_DEST (set) == temp 713 && ! rtx_equal_p (x, SET_SRC (set))) 714 set_unique_reg_note (insn, REG_EQUAL, x); 715 716 return temp; 717} 718 719/* If X is a memory ref, copy its contents to a new temp reg and return 720 that reg. Otherwise, return X. */ 721 722rtx 723force_not_mem (rtx x) 724{ 725 rtx temp; 726 727 if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode) 728 return x; 729 730 temp = gen_reg_rtx (GET_MODE (x)); 731 emit_move_insn (temp, x); 732 return temp; 733} 734 735/* Copy X to TARGET (if it's nonzero and a reg) 736 or to a new temp reg and return that reg. 737 MODE is the mode to use for X in case it is a constant. */ 738 739rtx 740copy_to_suggested_reg (rtx x, rtx target, enum machine_mode mode) 741{ 742 rtx temp; 743 744 if (target && GET_CODE (target) == REG) 745 temp = target; 746 else 747 temp = gen_reg_rtx (mode); 748 749 emit_move_insn (temp, x); 750 return temp; 751} 752 753/* Return the mode to use to store a scalar of TYPE and MODE. 754 PUNSIGNEDP points to the signedness of the type and may be adjusted 755 to show what signedness to use on extension operations. 756 757 FOR_CALL is nonzero if this call is promoting args for a call. */ 758 759enum machine_mode 760promote_mode (tree type, enum machine_mode mode, int *punsignedp, 761 int for_call ATTRIBUTE_UNUSED) 762{ 763 enum tree_code code = TREE_CODE (type); 764 int unsignedp = *punsignedp; 765 766#ifdef PROMOTE_FOR_CALL_ONLY 767 if (! for_call) 768 return mode; 769#endif 770 771 switch (code) 772 { 773#ifdef PROMOTE_MODE 774 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: 775 case CHAR_TYPE: case REAL_TYPE: case OFFSET_TYPE: 776 PROMOTE_MODE (mode, unsignedp, type); 777 break; 778#endif 779 780#ifdef POINTERS_EXTEND_UNSIGNED 781 case REFERENCE_TYPE: 782 case POINTER_TYPE: 783 mode = Pmode; 784 unsignedp = POINTERS_EXTEND_UNSIGNED; 785 break; 786#endif 787 788 default: 789 break; 790 } 791 792 *punsignedp = unsignedp; 793 return mode; 794} 795 796/* Adjust the stack pointer by ADJUST (an rtx for a number of bytes). 797 This pops when ADJUST is positive. ADJUST need not be constant. */ 798 799void 800adjust_stack (rtx adjust) 801{ 802 rtx temp; 803 adjust = protect_from_queue (adjust, 0); 804 805 if (adjust == const0_rtx) 806 return; 807 808 /* We expect all variable sized adjustments to be multiple of 809 PREFERRED_STACK_BOUNDARY. */ 810 if (GET_CODE (adjust) == CONST_INT) 811 stack_pointer_delta -= INTVAL (adjust); 812 813 temp = expand_binop (Pmode, 814#ifdef STACK_GROWS_DOWNWARD 815 add_optab, 816#else 817 sub_optab, 818#endif 819 stack_pointer_rtx, adjust, stack_pointer_rtx, 0, 820 OPTAB_LIB_WIDEN); 821 822 if (temp != stack_pointer_rtx) 823 emit_move_insn (stack_pointer_rtx, temp); 824} 825 826/* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes). 827 This pushes when ADJUST is positive. ADJUST need not be constant. */ 828 829void 830anti_adjust_stack (rtx adjust) 831{ 832 rtx temp; 833 adjust = protect_from_queue (adjust, 0); 834 835 if (adjust == const0_rtx) 836 return; 837 838 /* We expect all variable sized adjustments to be multiple of 839 PREFERRED_STACK_BOUNDARY. */ 840 if (GET_CODE (adjust) == CONST_INT) 841 stack_pointer_delta += INTVAL (adjust); 842 843 temp = expand_binop (Pmode, 844#ifdef STACK_GROWS_DOWNWARD 845 sub_optab, 846#else 847 add_optab, 848#endif 849 stack_pointer_rtx, adjust, stack_pointer_rtx, 0, 850 OPTAB_LIB_WIDEN); 851 852 if (temp != stack_pointer_rtx) 853 emit_move_insn (stack_pointer_rtx, temp); 854} 855 856/* Round the size of a block to be pushed up to the boundary required 857 by this machine. SIZE is the desired size, which need not be constant. */ 858 859rtx 860round_push (rtx size) 861{ 862 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; 863 864 if (align == 1) 865 return size; 866 867 if (GET_CODE (size) == CONST_INT) 868 { 869 HOST_WIDE_INT new = (INTVAL (size) + align - 1) / align * align; 870 871 if (INTVAL (size) != new) 872 size = GEN_INT (new); 873 } 874 else 875 { 876 /* CEIL_DIV_EXPR needs to worry about the addition overflowing, 877 but we know it can't. So add ourselves and then do 878 TRUNC_DIV_EXPR. */ 879 size = expand_binop (Pmode, add_optab, size, GEN_INT (align - 1), 880 NULL_RTX, 1, OPTAB_LIB_WIDEN); 881 size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, GEN_INT (align), 882 NULL_RTX, 1); 883 size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1); 884 } 885 886 return size; 887} 888 889/* Save the stack pointer for the purpose in SAVE_LEVEL. PSAVE is a pointer 890 to a previously-created save area. If no save area has been allocated, 891 this function will allocate one. If a save area is specified, it 892 must be of the proper mode. 893 894 The insns are emitted after insn AFTER, if nonzero, otherwise the insns 895 are emitted at the current position. */ 896 897void 898emit_stack_save (enum save_level save_level, rtx *psave, rtx after) 899{ 900 rtx sa = *psave; 901 /* The default is that we use a move insn and save in a Pmode object. */ 902 rtx (*fcn) (rtx, rtx) = gen_move_insn; 903 enum machine_mode mode = STACK_SAVEAREA_MODE (save_level); 904 905 /* See if this machine has anything special to do for this kind of save. */ 906 switch (save_level) 907 { 908#ifdef HAVE_save_stack_block 909 case SAVE_BLOCK: 910 if (HAVE_save_stack_block) 911 fcn = gen_save_stack_block; 912 break; 913#endif 914#ifdef HAVE_save_stack_function 915 case SAVE_FUNCTION: 916 if (HAVE_save_stack_function) 917 fcn = gen_save_stack_function; 918 break; 919#endif 920#ifdef HAVE_save_stack_nonlocal 921 case SAVE_NONLOCAL: 922 if (HAVE_save_stack_nonlocal) 923 fcn = gen_save_stack_nonlocal; 924 break; 925#endif 926 default: 927 break; 928 } 929 930 /* If there is no save area and we have to allocate one, do so. Otherwise 931 verify the save area is the proper mode. */ 932 933 if (sa == 0) 934 { 935 if (mode != VOIDmode) 936 { 937 if (save_level == SAVE_NONLOCAL) 938 *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0); 939 else 940 *psave = sa = gen_reg_rtx (mode); 941 } 942 } 943 else 944 { 945 if (mode == VOIDmode || GET_MODE (sa) != mode) 946 abort (); 947 } 948 949 if (after) 950 { 951 rtx seq; 952 953 start_sequence (); 954 /* We must validize inside the sequence, to ensure that any instructions 955 created by the validize call also get moved to the right place. */ 956 if (sa != 0) 957 sa = validize_mem (sa); 958 emit_insn (fcn (sa, stack_pointer_rtx)); 959 seq = get_insns (); 960 end_sequence (); 961 emit_insn_after (seq, after); 962 } 963 else 964 { 965 if (sa != 0) 966 sa = validize_mem (sa); 967 emit_insn (fcn (sa, stack_pointer_rtx)); 968 } 969} 970 971/* Restore the stack pointer for the purpose in SAVE_LEVEL. SA is the save 972 area made by emit_stack_save. If it is zero, we have nothing to do. 973 974 Put any emitted insns after insn AFTER, if nonzero, otherwise at 975 current position. */ 976 977void 978emit_stack_restore (enum save_level save_level, rtx sa, rtx after) 979{ 980 /* The default is that we use a move insn. */ 981 rtx (*fcn) (rtx, rtx) = gen_move_insn; 982 983 /* See if this machine has anything special to do for this kind of save. */ 984 switch (save_level) 985 { 986#ifdef HAVE_restore_stack_block 987 case SAVE_BLOCK: 988 if (HAVE_restore_stack_block) 989 fcn = gen_restore_stack_block; 990 break; 991#endif 992#ifdef HAVE_restore_stack_function 993 case SAVE_FUNCTION: 994 if (HAVE_restore_stack_function) 995 fcn = gen_restore_stack_function; 996 break; 997#endif 998#ifdef HAVE_restore_stack_nonlocal 999 case SAVE_NONLOCAL: 1000 if (HAVE_restore_stack_nonlocal) 1001 fcn = gen_restore_stack_nonlocal; 1002 break; 1003#endif 1004 default: 1005 break; 1006 } 1007 1008 if (sa != 0) 1009 { 1010 sa = validize_mem (sa); 1011 /* These clobbers prevent the scheduler from moving 1012 references to variable arrays below the code 1013 that deletes (pops) the arrays. */ 1014 emit_insn (gen_rtx_CLOBBER (VOIDmode, 1015 gen_rtx_MEM (BLKmode, 1016 gen_rtx_SCRATCH (VOIDmode)))); 1017 emit_insn (gen_rtx_CLOBBER (VOIDmode, 1018 gen_rtx_MEM (BLKmode, stack_pointer_rtx))); 1019 } 1020 1021 if (after) 1022 { 1023 rtx seq; 1024 1025 start_sequence (); 1026 emit_insn (fcn (stack_pointer_rtx, sa)); 1027 seq = get_insns (); 1028 end_sequence (); 1029 emit_insn_after (seq, after); 1030 } 1031 else 1032 emit_insn (fcn (stack_pointer_rtx, sa)); 1033} 1034 1035#ifdef SETJMP_VIA_SAVE_AREA 1036/* Optimize RTL generated by allocate_dynamic_stack_space for targets 1037 where SETJMP_VIA_SAVE_AREA is true. The problem is that on these 1038 platforms, the dynamic stack space used can corrupt the original 1039 frame, thus causing a crash if a longjmp unwinds to it. */ 1040 1041void 1042optimize_save_area_alloca (rtx insns) 1043{ 1044 rtx insn; 1045 1046 for (insn = insns; insn; insn = NEXT_INSN(insn)) 1047 { 1048 rtx note; 1049 1050 if (GET_CODE (insn) != INSN) 1051 continue; 1052 1053 for (note = REG_NOTES (insn); note; note = XEXP (note, 1)) 1054 { 1055 if (REG_NOTE_KIND (note) != REG_SAVE_AREA) 1056 continue; 1057 1058 if (!current_function_calls_setjmp) 1059 { 1060 rtx pat = PATTERN (insn); 1061 1062 /* If we do not see the note in a pattern matching 1063 these precise characteristics, we did something 1064 entirely wrong in allocate_dynamic_stack_space. 1065 1066 Note, one way this could happen is if SETJMP_VIA_SAVE_AREA 1067 was defined on a machine where stacks grow towards higher 1068 addresses. 1069 1070 Right now only supported port with stack that grow upward 1071 is the HPPA and it does not define SETJMP_VIA_SAVE_AREA. */ 1072 if (GET_CODE (pat) != SET 1073 || SET_DEST (pat) != stack_pointer_rtx 1074 || GET_CODE (SET_SRC (pat)) != MINUS 1075 || XEXP (SET_SRC (pat), 0) != stack_pointer_rtx) 1076 abort (); 1077 1078 /* This will now be transformed into a (set REG REG) 1079 so we can just blow away all the other notes. */ 1080 XEXP (SET_SRC (pat), 1) = XEXP (note, 0); 1081 REG_NOTES (insn) = NULL_RTX; 1082 } 1083 else 1084 { 1085 /* setjmp was called, we must remove the REG_SAVE_AREA 1086 note so that later passes do not get confused by its 1087 presence. */ 1088 if (note == REG_NOTES (insn)) 1089 { 1090 REG_NOTES (insn) = XEXP (note, 1); 1091 } 1092 else 1093 { 1094 rtx srch; 1095 1096 for (srch = REG_NOTES (insn); srch; srch = XEXP (srch, 1)) 1097 if (XEXP (srch, 1) == note) 1098 break; 1099 1100 if (srch == NULL_RTX) 1101 abort (); 1102 1103 XEXP (srch, 1) = XEXP (note, 1); 1104 } 1105 } 1106 /* Once we've seen the note of interest, we need not look at 1107 the rest of them. */ 1108 break; 1109 } 1110 } 1111} 1112#endif /* SETJMP_VIA_SAVE_AREA */ 1113 1114/* Return an rtx representing the address of an area of memory dynamically 1115 pushed on the stack. This region of memory is always aligned to 1116 a multiple of BIGGEST_ALIGNMENT. 1117 1118 Any required stack pointer alignment is preserved. 1119 1120 SIZE is an rtx representing the size of the area. 1121 TARGET is a place in which the address can be placed. 1122 1123 KNOWN_ALIGN is the alignment (in bits) that we know SIZE has. */ 1124 1125rtx 1126allocate_dynamic_stack_space (rtx size, rtx target, int known_align) 1127{ 1128#ifdef SETJMP_VIA_SAVE_AREA 1129 rtx setjmpless_size = NULL_RTX; 1130#endif 1131 1132 /* If we're asking for zero bytes, it doesn't matter what we point 1133 to since we can't dereference it. But return a reasonable 1134 address anyway. */ 1135 if (size == const0_rtx) 1136 return virtual_stack_dynamic_rtx; 1137 1138 /* Otherwise, show we're calling alloca or equivalent. */ 1139 current_function_calls_alloca = 1; 1140 1141 /* Ensure the size is in the proper mode. */ 1142 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode) 1143 size = convert_to_mode (Pmode, size, 1); 1144 1145 /* We can't attempt to minimize alignment necessary, because we don't 1146 know the final value of preferred_stack_boundary yet while executing 1147 this code. */ 1148 cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY; 1149 1150 /* We will need to ensure that the address we return is aligned to 1151 BIGGEST_ALIGNMENT. If STACK_DYNAMIC_OFFSET is defined, we don't 1152 always know its final value at this point in the compilation (it 1153 might depend on the size of the outgoing parameter lists, for 1154 example), so we must align the value to be returned in that case. 1155 (Note that STACK_DYNAMIC_OFFSET will have a default nonzero value if 1156 STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined). 1157 We must also do an alignment operation on the returned value if 1158 the stack pointer alignment is less strict that BIGGEST_ALIGNMENT. 1159 1160 If we have to align, we must leave space in SIZE for the hole 1161 that might result from the alignment operation. */ 1162 1163#if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET) 1164#define MUST_ALIGN 1 1165#else 1166#define MUST_ALIGN (PREFERRED_STACK_BOUNDARY < BIGGEST_ALIGNMENT) 1167#endif 1168 1169 if (MUST_ALIGN) 1170 size 1171 = force_operand (plus_constant (size, 1172 BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1), 1173 NULL_RTX); 1174 1175#ifdef SETJMP_VIA_SAVE_AREA 1176 /* If setjmp restores regs from a save area in the stack frame, 1177 avoid clobbering the reg save area. Note that the offset of 1178 virtual_incoming_args_rtx includes the preallocated stack args space. 1179 It would be no problem to clobber that, but it's on the wrong side 1180 of the old save area. */ 1181 { 1182 rtx dynamic_offset 1183 = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx, 1184 stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN); 1185 1186 if (!current_function_calls_setjmp) 1187 { 1188 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; 1189 1190 /* See optimize_save_area_alloca to understand what is being 1191 set up here. */ 1192 1193 /* ??? Code below assumes that the save area needs maximal 1194 alignment. This constraint may be too strong. */ 1195 if (PREFERRED_STACK_BOUNDARY != BIGGEST_ALIGNMENT) 1196 abort (); 1197 1198 if (GET_CODE (size) == CONST_INT) 1199 { 1200 HOST_WIDE_INT new = INTVAL (size) / align * align; 1201 1202 if (INTVAL (size) != new) 1203 setjmpless_size = GEN_INT (new); 1204 else 1205 setjmpless_size = size; 1206 } 1207 else 1208 { 1209 /* Since we know overflow is not possible, we avoid using 1210 CEIL_DIV_EXPR and use TRUNC_DIV_EXPR instead. */ 1211 setjmpless_size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, 1212 GEN_INT (align), NULL_RTX, 1); 1213 setjmpless_size = expand_mult (Pmode, setjmpless_size, 1214 GEN_INT (align), NULL_RTX, 1); 1215 } 1216 /* Our optimization works based upon being able to perform a simple 1217 transformation of this RTL into a (set REG REG) so make sure things 1218 did in fact end up in a REG. */ 1219 if (!register_operand (setjmpless_size, Pmode)) 1220 setjmpless_size = force_reg (Pmode, setjmpless_size); 1221 } 1222 1223 size = expand_binop (Pmode, add_optab, size, dynamic_offset, 1224 NULL_RTX, 1, OPTAB_LIB_WIDEN); 1225 } 1226#endif /* SETJMP_VIA_SAVE_AREA */ 1227 1228 /* Round the size to a multiple of the required stack alignment. 1229 Since the stack if presumed to be rounded before this allocation, 1230 this will maintain the required alignment. 1231 1232 If the stack grows downward, we could save an insn by subtracting 1233 SIZE from the stack pointer and then aligning the stack pointer. 1234 The problem with this is that the stack pointer may be unaligned 1235 between the execution of the subtraction and alignment insns and 1236 some machines do not allow this. Even on those that do, some 1237 signal handlers malfunction if a signal should occur between those 1238 insns. Since this is an extremely rare event, we have no reliable 1239 way of knowing which systems have this problem. So we avoid even 1240 momentarily mis-aligning the stack. */ 1241 1242 /* If we added a variable amount to SIZE, 1243 we can no longer assume it is aligned. */ 1244#if !defined (SETJMP_VIA_SAVE_AREA) 1245 if (MUST_ALIGN || known_align % PREFERRED_STACK_BOUNDARY != 0) 1246#endif 1247 size = round_push (size); 1248 1249 do_pending_stack_adjust (); 1250 1251 /* We ought to be called always on the toplevel and stack ought to be aligned 1252 properly. */ 1253 if (stack_pointer_delta % (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)) 1254 abort (); 1255 1256 /* If needed, check that we have the required amount of stack. Take into 1257 account what has already been checked. */ 1258 if (flag_stack_check && ! STACK_CHECK_BUILTIN) 1259 probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size); 1260 1261 /* Don't use a TARGET that isn't a pseudo or is the wrong mode. */ 1262 if (target == 0 || GET_CODE (target) != REG 1263 || REGNO (target) < FIRST_PSEUDO_REGISTER 1264 || GET_MODE (target) != Pmode) 1265 target = gen_reg_rtx (Pmode); 1266 1267 mark_reg_pointer (target, known_align); 1268 1269 /* Perform the required allocation from the stack. Some systems do 1270 this differently than simply incrementing/decrementing from the 1271 stack pointer, such as acquiring the space by calling malloc(). */ 1272#ifdef HAVE_allocate_stack 1273 if (HAVE_allocate_stack) 1274 { 1275 enum machine_mode mode = STACK_SIZE_MODE; 1276 insn_operand_predicate_fn pred; 1277 1278 /* We don't have to check against the predicate for operand 0 since 1279 TARGET is known to be a pseudo of the proper mode, which must 1280 be valid for the operand. For operand 1, convert to the 1281 proper mode and validate. */ 1282 if (mode == VOIDmode) 1283 mode = insn_data[(int) CODE_FOR_allocate_stack].operand[1].mode; 1284 1285 pred = insn_data[(int) CODE_FOR_allocate_stack].operand[1].predicate; 1286 if (pred && ! ((*pred) (size, mode))) 1287 size = copy_to_mode_reg (mode, convert_to_mode (mode, size, 1)); 1288 1289 emit_insn (gen_allocate_stack (target, size)); 1290 } 1291 else 1292#endif 1293 { 1294#ifndef STACK_GROWS_DOWNWARD 1295 emit_move_insn (target, virtual_stack_dynamic_rtx); 1296#endif 1297 1298 /* Check stack bounds if necessary. */ 1299 if (current_function_limit_stack) 1300 { 1301 rtx available; 1302 rtx space_available = gen_label_rtx (); 1303#ifdef STACK_GROWS_DOWNWARD 1304 available = expand_binop (Pmode, sub_optab, 1305 stack_pointer_rtx, stack_limit_rtx, 1306 NULL_RTX, 1, OPTAB_WIDEN); 1307#else 1308 available = expand_binop (Pmode, sub_optab, 1309 stack_limit_rtx, stack_pointer_rtx, 1310 NULL_RTX, 1, OPTAB_WIDEN); 1311#endif 1312 emit_cmp_and_jump_insns (available, size, GEU, NULL_RTX, Pmode, 1, 1313 space_available); 1314#ifdef HAVE_trap 1315 if (HAVE_trap) 1316 emit_insn (gen_trap ()); 1317 else 1318#endif 1319 error ("stack limits not supported on this target"); 1320 emit_barrier (); 1321 emit_label (space_available); 1322 } 1323 1324 anti_adjust_stack (size); 1325#ifdef SETJMP_VIA_SAVE_AREA 1326 if (setjmpless_size != NULL_RTX) 1327 { 1328 rtx note_target = get_last_insn (); 1329 1330 REG_NOTES (note_target) 1331 = gen_rtx_EXPR_LIST (REG_SAVE_AREA, setjmpless_size, 1332 REG_NOTES (note_target)); 1333 } 1334#endif /* SETJMP_VIA_SAVE_AREA */ 1335 1336#ifdef STACK_GROWS_DOWNWARD 1337 emit_move_insn (target, virtual_stack_dynamic_rtx); 1338#endif 1339 } 1340 1341 if (MUST_ALIGN) 1342 { 1343 /* CEIL_DIV_EXPR needs to worry about the addition overflowing, 1344 but we know it can't. So add ourselves and then do 1345 TRUNC_DIV_EXPR. */ 1346 target = expand_binop (Pmode, add_optab, target, 1347 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1), 1348 NULL_RTX, 1, OPTAB_LIB_WIDEN); 1349 target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target, 1350 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT), 1351 NULL_RTX, 1); 1352 target = expand_mult (Pmode, target, 1353 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT), 1354 NULL_RTX, 1); 1355 } 1356 1357 /* Record the new stack level for nonlocal gotos. */ 1358 if (nonlocal_goto_handler_slots != 0) 1359 emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX); 1360 1361 return target; 1362} 1363 1364/* A front end may want to override GCC's stack checking by providing a 1365 run-time routine to call to check the stack, so provide a mechanism for 1366 calling that routine. */ 1367 1368static GTY(()) rtx stack_check_libfunc; 1369 1370void 1371set_stack_check_libfunc (rtx libfunc) 1372{ 1373 stack_check_libfunc = libfunc; 1374} 1375 1376/* Emit one stack probe at ADDRESS, an address within the stack. */ 1377 1378static void 1379emit_stack_probe (rtx address) 1380{ 1381 rtx memref = gen_rtx_MEM (word_mode, address); 1382 1383 MEM_VOLATILE_P (memref) = 1; 1384 1385 if (STACK_CHECK_PROBE_LOAD) 1386 emit_move_insn (gen_reg_rtx (word_mode), memref); 1387 else 1388 emit_move_insn (memref, const0_rtx); 1389} 1390 1391/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 1392 FIRST is a constant and size is a Pmode RTX. These are offsets from the 1393 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or 1394 subtract from the stack. If SIZE is constant, this is done 1395 with a fixed number of probes. Otherwise, we must make a loop. */ 1396 1397#ifdef STACK_GROWS_DOWNWARD 1398#define STACK_GROW_OP MINUS 1399#else 1400#define STACK_GROW_OP PLUS 1401#endif 1402 1403void 1404probe_stack_range (HOST_WIDE_INT first, rtx size) 1405{ 1406 /* First ensure SIZE is Pmode. */ 1407 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode) 1408 size = convert_to_mode (Pmode, size, 1); 1409 1410 /* Next see if the front end has set up a function for us to call to 1411 check the stack. */ 1412 if (stack_check_libfunc != 0) 1413 { 1414 rtx addr = memory_address (QImode, 1415 gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1416 stack_pointer_rtx, 1417 plus_constant (size, first))); 1418 1419 addr = convert_memory_address (ptr_mode, addr); 1420 emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr, 1421 ptr_mode); 1422 } 1423 1424 /* Next see if we have an insn to check the stack. Use it if so. */ 1425#ifdef HAVE_check_stack 1426 else if (HAVE_check_stack) 1427 { 1428 insn_operand_predicate_fn pred; 1429 rtx last_addr 1430 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1431 stack_pointer_rtx, 1432 plus_constant (size, first)), 1433 NULL_RTX); 1434 1435 pred = insn_data[(int) CODE_FOR_check_stack].operand[0].predicate; 1436 if (pred && ! ((*pred) (last_addr, Pmode))) 1437 last_addr = copy_to_mode_reg (Pmode, last_addr); 1438 1439 emit_insn (gen_check_stack (last_addr)); 1440 } 1441#endif 1442 1443 /* If we have to generate explicit probes, see if we have a constant 1444 small number of them to generate. If so, that's the easy case. */ 1445 else if (GET_CODE (size) == CONST_INT 1446 && INTVAL (size) < 10 * STACK_CHECK_PROBE_INTERVAL) 1447 { 1448 HOST_WIDE_INT offset; 1449 1450 /* Start probing at FIRST + N * STACK_CHECK_PROBE_INTERVAL 1451 for values of N from 1 until it exceeds LAST. If only one 1452 probe is needed, this will not generate any code. Then probe 1453 at LAST. */ 1454 for (offset = first + STACK_CHECK_PROBE_INTERVAL; 1455 offset < INTVAL (size); 1456 offset = offset + STACK_CHECK_PROBE_INTERVAL) 1457 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1458 stack_pointer_rtx, 1459 GEN_INT (offset))); 1460 1461 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1462 stack_pointer_rtx, 1463 plus_constant (size, first))); 1464 } 1465 1466 /* In the variable case, do the same as above, but in a loop. We emit loop 1467 notes so that loop optimization can be done. */ 1468 else 1469 { 1470 rtx test_addr 1471 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1472 stack_pointer_rtx, 1473 GEN_INT (first + STACK_CHECK_PROBE_INTERVAL)), 1474 NULL_RTX); 1475 rtx last_addr 1476 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1477 stack_pointer_rtx, 1478 plus_constant (size, first)), 1479 NULL_RTX); 1480 rtx incr = GEN_INT (STACK_CHECK_PROBE_INTERVAL); 1481 rtx loop_lab = gen_label_rtx (); 1482 rtx test_lab = gen_label_rtx (); 1483 rtx end_lab = gen_label_rtx (); 1484 rtx temp; 1485 1486 if (GET_CODE (test_addr) != REG 1487 || REGNO (test_addr) < FIRST_PSEUDO_REGISTER) 1488 test_addr = force_reg (Pmode, test_addr); 1489 1490 emit_note (NOTE_INSN_LOOP_BEG); 1491 emit_jump (test_lab); 1492 1493 emit_label (loop_lab); 1494 emit_stack_probe (test_addr); 1495 1496 emit_note (NOTE_INSN_LOOP_CONT); 1497 1498#ifdef STACK_GROWS_DOWNWARD 1499#define CMP_OPCODE GTU 1500 temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr, 1501 1, OPTAB_WIDEN); 1502#else 1503#define CMP_OPCODE LTU 1504 temp = expand_binop (Pmode, add_optab, test_addr, incr, test_addr, 1505 1, OPTAB_WIDEN); 1506#endif 1507 1508 if (temp != test_addr) 1509 abort (); 1510 1511 emit_label (test_lab); 1512 emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE, 1513 NULL_RTX, Pmode, 1, loop_lab); 1514 emit_jump (end_lab); 1515 emit_note (NOTE_INSN_LOOP_END); 1516 emit_label (end_lab); 1517 1518 emit_stack_probe (last_addr); 1519 } 1520} 1521 1522/* Return an rtx representing the register or memory location 1523 in which a scalar value of data type VALTYPE 1524 was returned by a function call to function FUNC. 1525 FUNC is a FUNCTION_DECL node if the precise function is known, 1526 otherwise 0. 1527 OUTGOING is 1 if on a machine with register windows this function 1528 should return the register in which the function will put its result 1529 and 0 otherwise. */ 1530 1531rtx 1532hard_function_value (tree valtype, tree func ATTRIBUTE_UNUSED, 1533 int outgoing ATTRIBUTE_UNUSED) 1534{ 1535 rtx val; 1536 1537#ifdef FUNCTION_OUTGOING_VALUE 1538 if (outgoing) 1539 val = FUNCTION_OUTGOING_VALUE (valtype, func); 1540 else 1541#endif 1542 val = FUNCTION_VALUE (valtype, func); 1543 1544 if (GET_CODE (val) == REG 1545 && GET_MODE (val) == BLKmode) 1546 { 1547 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype); 1548 enum machine_mode tmpmode; 1549 1550 /* int_size_in_bytes can return -1. We don't need a check here 1551 since the value of bytes will be large enough that no mode 1552 will match and we will abort later in this function. */ 1553 1554 for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT); 1555 tmpmode != VOIDmode; 1556 tmpmode = GET_MODE_WIDER_MODE (tmpmode)) 1557 { 1558 /* Have we found a large enough mode? */ 1559 if (GET_MODE_SIZE (tmpmode) >= bytes) 1560 break; 1561 } 1562 1563 /* No suitable mode found. */ 1564 if (tmpmode == VOIDmode) 1565 abort (); 1566 1567 PUT_MODE (val, tmpmode); 1568 } 1569 return val; 1570} 1571 1572/* Return an rtx representing the register or memory location 1573 in which a scalar value of mode MODE was returned by a library call. */ 1574 1575rtx 1576hard_libcall_value (enum machine_mode mode) 1577{ 1578 return LIBCALL_VALUE (mode); 1579} 1580 1581/* Look up the tree code for a given rtx code 1582 to provide the arithmetic operation for REAL_ARITHMETIC. 1583 The function returns an int because the caller may not know 1584 what `enum tree_code' means. */ 1585 1586int 1587rtx_to_tree_code (enum rtx_code code) 1588{ 1589 enum tree_code tcode; 1590 1591 switch (code) 1592 { 1593 case PLUS: 1594 tcode = PLUS_EXPR; 1595 break; 1596 case MINUS: 1597 tcode = MINUS_EXPR; 1598 break; 1599 case MULT: 1600 tcode = MULT_EXPR; 1601 break; 1602 case DIV: 1603 tcode = RDIV_EXPR; 1604 break; 1605 case SMIN: 1606 tcode = MIN_EXPR; 1607 break; 1608 case SMAX: 1609 tcode = MAX_EXPR; 1610 break; 1611 default: 1612 tcode = LAST_AND_UNUSED_TREE_CODE; 1613 break; 1614 } 1615 return ((int) tcode); 1616} 1617 1618#include "gt-explow.h" 1619