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