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