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