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, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, 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#include "target.h" 41 42static rtx break_out_memory_refs (rtx); 43static void emit_stack_probe (rtx); 44 45 46/* Truncate and perhaps sign-extend C as appropriate for MODE. */ 47 48HOST_WIDE_INT 49trunc_int_for_mode (HOST_WIDE_INT c, enum machine_mode mode) 50{ 51 int width = GET_MODE_BITSIZE (mode); 52 53 /* You want to truncate to a _what_? */ 54 gcc_assert (SCALAR_INT_MODE_P (mode)); 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 76rtx 77plus_constant (rtx x, HOST_WIDE_INT c) 78{ 79 RTX_CODE code; 80 rtx y; 81 enum machine_mode mode; 82 rtx tem; 83 int all_constant = 0; 84 85 if (c == 0) 86 return x; 87 88 restart: 89 90 code = GET_CODE (x); 91 mode = GET_MODE (x); 92 y = x; 93 94 switch (code) 95 { 96 case CONST_INT: 97 return GEN_INT (INTVAL (x) + c); 98 99 case CONST_DOUBLE: 100 { 101 unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x); 102 HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x); 103 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 (rtx x, rtx *constptr) 204{ 205 rtx x0, x1; 206 rtx tem; 207 208 if (GET_CODE (x) != PLUS) 209 return x; 210 211 /* First handle constants appearing at this level explicitly. */ 212 if (GET_CODE (XEXP (x, 1)) == CONST_INT 213 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr, 214 XEXP (x, 1))) 215 && GET_CODE (tem) == CONST_INT) 216 { 217 *constptr = tem; 218 return eliminate_constant_term (XEXP (x, 0), constptr); 219 } 220 221 tem = const0_rtx; 222 x0 = eliminate_constant_term (XEXP (x, 0), &tem); 223 x1 = eliminate_constant_term (XEXP (x, 1), &tem); 224 if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0)) 225 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), 226 *constptr, tem)) 227 && GET_CODE (tem) == CONST_INT) 228 { 229 *constptr = tem; 230 return gen_rtx_PLUS (GET_MODE (x), x0, x1); 231 } 232 233 return x; 234} 235 236/* Return an rtx for the size in bytes of the value of EXP. */ 237 238rtx 239expr_size (tree exp) 240{ 241 tree size; 242 243 if (TREE_CODE (exp) == WITH_SIZE_EXPR) 244 size = TREE_OPERAND (exp, 1); 245 else 246 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (lang_hooks.expr_size (exp), 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 size; 258 259 if (TREE_CODE (exp) == WITH_SIZE_EXPR) 260 size = TREE_OPERAND (exp, 1); 261 else 262 size = lang_hooks.expr_size (exp); 263 264 if (size == 0 || !host_integerp (size, 0)) 265 return -1; 266 267 return tree_low_cst (size, 0); 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 (MEM_P (x) 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 gcc_assert (GET_MODE (x) == to_mode || GET_MODE (x) == VOIDmode); 318 return x; 319#else /* defined(POINTERS_EXTEND_UNSIGNED) */ 320 enum machine_mode from_mode; 321 rtx temp; 322 enum rtx_code code; 323 324 /* If X already has the right mode, just return it. */ 325 if (GET_MODE (x) == to_mode) 326 return x; 327 328 from_mode = to_mode == ptr_mode ? Pmode : ptr_mode; 329 330 /* Here we handle some special cases. If none of them apply, fall through 331 to the default case. */ 332 switch (GET_CODE (x)) 333 { 334 case CONST_INT: 335 case CONST_DOUBLE: 336 if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)) 337 code = TRUNCATE; 338 else if (POINTERS_EXTEND_UNSIGNED < 0) 339 break; 340 else if (POINTERS_EXTEND_UNSIGNED > 0) 341 code = ZERO_EXTEND; 342 else 343 code = SIGN_EXTEND; 344 temp = simplify_unary_operation (code, to_mode, x, from_mode); 345 if (temp) 346 return temp; 347 break; 348 349 case SUBREG: 350 if ((SUBREG_PROMOTED_VAR_P (x) || REG_POINTER (SUBREG_REG (x))) 351 && GET_MODE (SUBREG_REG (x)) == to_mode) 352 return SUBREG_REG (x); 353 break; 354 355 case LABEL_REF: 356 temp = gen_rtx_LABEL_REF (to_mode, XEXP (x, 0)); 357 LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x); 358 return temp; 359 break; 360 361 case SYMBOL_REF: 362 temp = shallow_copy_rtx (x); 363 PUT_MODE (temp, to_mode); 364 return temp; 365 break; 366 367 case CONST: 368 return gen_rtx_CONST (to_mode, 369 convert_memory_address (to_mode, XEXP (x, 0))); 370 break; 371 372 case PLUS: 373 case MULT: 374 /* For addition we can safely permute the conversion and addition 375 operation if one operand is a constant and converting the constant 376 does not change it. We can always safely permute them if we are 377 making the address narrower. */ 378 if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode) 379 || (GET_CODE (x) == PLUS 380 && GET_CODE (XEXP (x, 1)) == CONST_INT 381 && XEXP (x, 1) == convert_memory_address (to_mode, XEXP (x, 1)))) 382 return gen_rtx_fmt_ee (GET_CODE (x), to_mode, 383 convert_memory_address (to_mode, XEXP (x, 0)), 384 XEXP (x, 1)); 385 break; 386 387 default: 388 break; 389 } 390 391 return convert_modes (to_mode, from_mode, 392 x, POINTERS_EXTEND_UNSIGNED); 393#endif /* defined(POINTERS_EXTEND_UNSIGNED) */ 394} 395 396/* Return something equivalent to X but valid as a memory address 397 for something of mode MODE. When X is not itself valid, this 398 works by copying X or subexpressions of it into registers. */ 399 400rtx 401memory_address (enum machine_mode mode, rtx x) 402{ 403 rtx oldx = x; 404 405 x = convert_memory_address (Pmode, x); 406 407 /* By passing constant addresses through registers 408 we get a chance to cse them. */ 409 if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)) 410 x = force_reg (Pmode, x); 411 412 /* We get better cse by rejecting indirect addressing at this stage. 413 Let the combiner create indirect addresses where appropriate. 414 For now, generate the code so that the subexpressions useful to share 415 are visible. But not if cse won't be done! */ 416 else 417 { 418 if (! cse_not_expected && !REG_P (x)) 419 x = break_out_memory_refs (x); 420 421 /* At this point, any valid address is accepted. */ 422 if (memory_address_p (mode, x)) 423 goto win; 424 425 /* If it was valid before but breaking out memory refs invalidated it, 426 use it the old way. */ 427 if (memory_address_p (mode, oldx)) 428 goto win2; 429 430 /* Perform machine-dependent transformations on X 431 in certain cases. This is not necessary since the code 432 below can handle all possible cases, but machine-dependent 433 transformations can make better code. */ 434 LEGITIMIZE_ADDRESS (x, oldx, mode, win); 435 436 /* PLUS and MULT can appear in special ways 437 as the result of attempts to make an address usable for indexing. 438 Usually they are dealt with by calling force_operand, below. 439 But a sum containing constant terms is special 440 if removing them makes the sum a valid address: 441 then we generate that address in a register 442 and index off of it. We do this because it often makes 443 shorter code, and because the addresses thus generated 444 in registers often become common subexpressions. */ 445 if (GET_CODE (x) == PLUS) 446 { 447 rtx constant_term = const0_rtx; 448 rtx y = eliminate_constant_term (x, &constant_term); 449 if (constant_term == const0_rtx 450 || ! memory_address_p (mode, y)) 451 x = force_operand (x, NULL_RTX); 452 else 453 { 454 y = gen_rtx_PLUS (GET_MODE (x), copy_to_reg (y), constant_term); 455 if (! memory_address_p (mode, y)) 456 x = force_operand (x, NULL_RTX); 457 else 458 x = y; 459 } 460 } 461 462 else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS) 463 x = force_operand (x, NULL_RTX); 464 465 /* If we have a register that's an invalid address, 466 it must be a hard reg of the wrong class. Copy it to a pseudo. */ 467 else if (REG_P (x)) 468 x = copy_to_reg (x); 469 470 /* Last resort: copy the value to a register, since 471 the register is a valid address. */ 472 else 473 x = force_reg (Pmode, x); 474 475 goto done; 476 477 win2: 478 x = oldx; 479 win: 480 if (flag_force_addr && ! cse_not_expected && !REG_P (x)) 481 { 482 x = force_operand (x, NULL_RTX); 483 x = force_reg (Pmode, x); 484 } 485 } 486 487 done: 488 489 /* If we didn't change the address, we are done. Otherwise, mark 490 a reg as a pointer if we have REG or REG + CONST_INT. */ 491 if (oldx == x) 492 return x; 493 else if (REG_P (x)) 494 mark_reg_pointer (x, BITS_PER_UNIT); 495 else if (GET_CODE (x) == PLUS 496 && REG_P (XEXP (x, 0)) 497 && GET_CODE (XEXP (x, 1)) == CONST_INT) 498 mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT); 499 500 /* OLDX may have been the address on a temporary. Update the address 501 to indicate that X is now used. */ 502 update_temp_slot_address (oldx, x); 503 504 return x; 505} 506 507/* Like `memory_address' but pretend `flag_force_addr' is 0. */ 508 509rtx 510memory_address_noforce (enum machine_mode mode, rtx x) 511{ 512 int ambient_force_addr = flag_force_addr; 513 rtx val; 514 515 flag_force_addr = 0; 516 val = memory_address (mode, x); 517 flag_force_addr = ambient_force_addr; 518 return val; 519} 520 521/* Convert a mem ref into one with a valid memory address. 522 Pass through anything else unchanged. */ 523 524rtx 525validize_mem (rtx ref) 526{ 527 if (!MEM_P (ref)) 528 return ref; 529 if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0))) 530 && memory_address_p (GET_MODE (ref), XEXP (ref, 0))) 531 return ref; 532 533 /* Don't alter REF itself, since that is probably a stack slot. */ 534 return replace_equiv_address (ref, XEXP (ref, 0)); 535} 536 537/* Copy the value or contents of X to a new temp reg and return that reg. */ 538 539rtx 540copy_to_reg (rtx x) 541{ 542 rtx temp = gen_reg_rtx (GET_MODE (x)); 543 544 /* If not an operand, must be an address with PLUS and MULT so 545 do the computation. */ 546 if (! general_operand (x, VOIDmode)) 547 x = force_operand (x, temp); 548 549 if (x != temp) 550 emit_move_insn (temp, x); 551 552 return temp; 553} 554 555/* Like copy_to_reg but always give the new register mode Pmode 556 in case X is a constant. */ 557 558rtx 559copy_addr_to_reg (rtx x) 560{ 561 return copy_to_mode_reg (Pmode, x); 562} 563 564/* Like copy_to_reg but always give the new register mode MODE 565 in case X is a constant. */ 566 567rtx 568copy_to_mode_reg (enum machine_mode mode, rtx x) 569{ 570 rtx temp = gen_reg_rtx (mode); 571 572 /* If not an operand, must be an address with PLUS and MULT so 573 do the computation. */ 574 if (! general_operand (x, VOIDmode)) 575 x = force_operand (x, temp); 576 577 gcc_assert (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode); 578 if (x != temp) 579 emit_move_insn (temp, x); 580 return temp; 581} 582 583/* Load X into a register if it is not already one. 584 Use mode MODE for the register. 585 X should be valid for mode MODE, but it may be a constant which 586 is valid for all integer modes; that's why caller must specify MODE. 587 588 The caller must not alter the value in the register we return, 589 since we mark it as a "constant" register. */ 590 591rtx 592force_reg (enum machine_mode mode, rtx x) 593{ 594 rtx temp, insn, set; 595 596 if (REG_P (x)) 597 return x; 598 599 if (general_operand (x, mode)) 600 { 601 temp = gen_reg_rtx (mode); 602 insn = emit_move_insn (temp, x); 603 } 604 else 605 { 606 temp = force_operand (x, NULL_RTX); 607 if (REG_P (temp)) 608 insn = get_last_insn (); 609 else 610 { 611 rtx temp2 = gen_reg_rtx (mode); 612 insn = emit_move_insn (temp2, temp); 613 temp = temp2; 614 } 615 } 616 617 /* Let optimizers know that TEMP's value never changes 618 and that X can be substituted for it. Don't get confused 619 if INSN set something else (such as a SUBREG of TEMP). */ 620 if (CONSTANT_P (x) 621 && (set = single_set (insn)) != 0 622 && SET_DEST (set) == temp 623 && ! rtx_equal_p (x, SET_SRC (set))) 624 set_unique_reg_note (insn, REG_EQUAL, x); 625 626 /* Let optimizers know that TEMP is a pointer, and if so, the 627 known alignment of that pointer. */ 628 { 629 unsigned align = 0; 630 if (GET_CODE (x) == SYMBOL_REF) 631 { 632 align = BITS_PER_UNIT; 633 if (SYMBOL_REF_DECL (x) && DECL_P (SYMBOL_REF_DECL (x))) 634 align = DECL_ALIGN (SYMBOL_REF_DECL (x)); 635 } 636 else if (GET_CODE (x) == LABEL_REF) 637 align = BITS_PER_UNIT; 638 else if (GET_CODE (x) == CONST 639 && GET_CODE (XEXP (x, 0)) == PLUS 640 && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF 641 && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT) 642 { 643 rtx s = XEXP (XEXP (x, 0), 0); 644 rtx c = XEXP (XEXP (x, 0), 1); 645 unsigned sa, ca; 646 647 sa = BITS_PER_UNIT; 648 if (SYMBOL_REF_DECL (s) && DECL_P (SYMBOL_REF_DECL (s))) 649 sa = DECL_ALIGN (SYMBOL_REF_DECL (s)); 650 651 ca = exact_log2 (INTVAL (c) & -INTVAL (c)) * BITS_PER_UNIT; 652 653 align = MIN (sa, ca); 654 } 655 656 if (align) 657 mark_reg_pointer (temp, align); 658 } 659 660 return temp; 661} 662 663/* If X is a memory ref, copy its contents to a new temp reg and return 664 that reg. Otherwise, return X. */ 665 666rtx 667force_not_mem (rtx x) 668{ 669 rtx temp; 670 671 if (!MEM_P (x) || GET_MODE (x) == BLKmode) 672 return x; 673 674 temp = gen_reg_rtx (GET_MODE (x)); 675 676 if (MEM_POINTER (x)) 677 REG_POINTER (temp) = 1; 678 679 emit_move_insn (temp, x); 680 return temp; 681} 682 683/* Copy X to TARGET (if it's nonzero and a reg) 684 or to a new temp reg and return that reg. 685 MODE is the mode to use for X in case it is a constant. */ 686 687rtx 688copy_to_suggested_reg (rtx x, rtx target, enum machine_mode mode) 689{ 690 rtx temp; 691 692 if (target && REG_P (target)) 693 temp = target; 694 else 695 temp = gen_reg_rtx (mode); 696 697 emit_move_insn (temp, x); 698 return temp; 699} 700 701/* Return the mode to use to store a scalar of TYPE and MODE. 702 PUNSIGNEDP points to the signedness of the type and may be adjusted 703 to show what signedness to use on extension operations. 704 705 FOR_CALL is nonzero if this call is promoting args for a call. */ 706 707#if defined(PROMOTE_MODE) && !defined(PROMOTE_FUNCTION_MODE) 708#define PROMOTE_FUNCTION_MODE PROMOTE_MODE 709#endif 710 711enum machine_mode 712promote_mode (tree type, enum machine_mode mode, int *punsignedp, 713 int for_call ATTRIBUTE_UNUSED) 714{ 715 enum tree_code code = TREE_CODE (type); 716 int unsignedp = *punsignedp; 717 718#ifndef PROMOTE_MODE 719 if (! for_call) 720 return mode; 721#endif 722 723 switch (code) 724 { 725#ifdef PROMOTE_FUNCTION_MODE 726 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: 727 case CHAR_TYPE: case REAL_TYPE: case OFFSET_TYPE: 728#ifdef PROMOTE_MODE 729 if (for_call) 730 { 731#endif 732 PROMOTE_FUNCTION_MODE (mode, unsignedp, type); 733#ifdef PROMOTE_MODE 734 } 735 else 736 { 737 PROMOTE_MODE (mode, unsignedp, type); 738 } 739#endif 740 break; 741#endif 742 743#ifdef POINTERS_EXTEND_UNSIGNED 744 case REFERENCE_TYPE: 745 case POINTER_TYPE: 746 mode = Pmode; 747 unsignedp = POINTERS_EXTEND_UNSIGNED; 748 break; 749#endif 750 751 default: 752 break; 753 } 754 755 *punsignedp = unsignedp; 756 return mode; 757} 758 759/* Adjust the stack pointer by ADJUST (an rtx for a number of bytes). 760 This pops when ADJUST is positive. ADJUST need not be constant. */ 761 762void 763adjust_stack (rtx adjust) 764{ 765 rtx temp; 766 767 if (adjust == const0_rtx) 768 return; 769 770 /* We expect all variable sized adjustments to be multiple of 771 PREFERRED_STACK_BOUNDARY. */ 772 if (GET_CODE (adjust) == CONST_INT) 773 stack_pointer_delta -= INTVAL (adjust); 774 775 temp = expand_binop (Pmode, 776#ifdef STACK_GROWS_DOWNWARD 777 add_optab, 778#else 779 sub_optab, 780#endif 781 stack_pointer_rtx, adjust, stack_pointer_rtx, 0, 782 OPTAB_LIB_WIDEN); 783 784 if (temp != stack_pointer_rtx) 785 emit_move_insn (stack_pointer_rtx, temp); 786} 787 788/* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes). 789 This pushes when ADJUST is positive. ADJUST need not be constant. */ 790 791void 792anti_adjust_stack (rtx adjust) 793{ 794 rtx temp; 795 796 if (adjust == const0_rtx) 797 return; 798 799 /* We expect all variable sized adjustments to be multiple of 800 PREFERRED_STACK_BOUNDARY. */ 801 if (GET_CODE (adjust) == CONST_INT) 802 stack_pointer_delta += INTVAL (adjust); 803 804 temp = expand_binop (Pmode, 805#ifdef STACK_GROWS_DOWNWARD 806 sub_optab, 807#else 808 add_optab, 809#endif 810 stack_pointer_rtx, adjust, stack_pointer_rtx, 0, 811 OPTAB_LIB_WIDEN); 812 813 if (temp != stack_pointer_rtx) 814 emit_move_insn (stack_pointer_rtx, temp); 815} 816 817/* Round the size of a block to be pushed up to the boundary required 818 by this machine. SIZE is the desired size, which need not be constant. */ 819 820static rtx 821round_push (rtx size) 822{ 823 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; 824 825 if (align == 1) 826 return size; 827 828 if (GET_CODE (size) == CONST_INT) 829 { 830 HOST_WIDE_INT new = (INTVAL (size) + align - 1) / align * align; 831 832 if (INTVAL (size) != new) 833 size = GEN_INT (new); 834 } 835 else 836 { 837 /* CEIL_DIV_EXPR needs to worry about the addition overflowing, 838 but we know it can't. So add ourselves and then do 839 TRUNC_DIV_EXPR. */ 840 size = expand_binop (Pmode, add_optab, size, GEN_INT (align - 1), 841 NULL_RTX, 1, OPTAB_LIB_WIDEN); 842 size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, GEN_INT (align), 843 NULL_RTX, 1); 844 size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1); 845 } 846 847 return size; 848} 849 850/* Save the stack pointer for the purpose in SAVE_LEVEL. PSAVE is a pointer 851 to a previously-created save area. If no save area has been allocated, 852 this function will allocate one. If a save area is specified, it 853 must be of the proper mode. 854 855 The insns are emitted after insn AFTER, if nonzero, otherwise the insns 856 are emitted at the current position. */ 857 858void 859emit_stack_save (enum save_level save_level, rtx *psave, rtx after) 860{ 861 rtx sa = *psave; 862 /* The default is that we use a move insn and save in a Pmode object. */ 863 rtx (*fcn) (rtx, rtx) = gen_move_insn; 864 enum machine_mode mode = STACK_SAVEAREA_MODE (save_level); 865 866 /* See if this machine has anything special to do for this kind of save. */ 867 switch (save_level) 868 { 869#ifdef HAVE_save_stack_block 870 case SAVE_BLOCK: 871 if (HAVE_save_stack_block) 872 fcn = gen_save_stack_block; 873 break; 874#endif 875#ifdef HAVE_save_stack_function 876 case SAVE_FUNCTION: 877 if (HAVE_save_stack_function) 878 fcn = gen_save_stack_function; 879 break; 880#endif 881#ifdef HAVE_save_stack_nonlocal 882 case SAVE_NONLOCAL: 883 if (HAVE_save_stack_nonlocal) 884 fcn = gen_save_stack_nonlocal; 885 break; 886#endif 887 default: 888 break; 889 } 890 891 /* If there is no save area and we have to allocate one, do so. Otherwise 892 verify the save area is the proper mode. */ 893 894 if (sa == 0) 895 { 896 if (mode != VOIDmode) 897 { 898 if (save_level == SAVE_NONLOCAL) 899 *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0); 900 else 901 *psave = sa = gen_reg_rtx (mode); 902 } 903 } 904 905 if (after) 906 { 907 rtx seq; 908 909 start_sequence (); 910 do_pending_stack_adjust (); 911 /* We must validize inside the sequence, to ensure that any instructions 912 created by the validize call also get moved to the right place. */ 913 if (sa != 0) 914 sa = validize_mem (sa); 915 emit_insn (fcn (sa, stack_pointer_rtx)); 916 seq = get_insns (); 917 end_sequence (); 918 emit_insn_after (seq, after); 919 } 920 else 921 { 922 do_pending_stack_adjust (); 923 if (sa != 0) 924 sa = validize_mem (sa); 925 emit_insn (fcn (sa, stack_pointer_rtx)); 926 } 927} 928 929/* Restore the stack pointer for the purpose in SAVE_LEVEL. SA is the save 930 area made by emit_stack_save. If it is zero, we have nothing to do. 931 932 Put any emitted insns after insn AFTER, if nonzero, otherwise at 933 current position. */ 934 935void 936emit_stack_restore (enum save_level save_level, rtx sa, rtx after) 937{ 938 /* The default is that we use a move insn. */ 939 rtx (*fcn) (rtx, rtx) = gen_move_insn; 940 941 /* See if this machine has anything special to do for this kind of save. */ 942 switch (save_level) 943 { 944#ifdef HAVE_restore_stack_block 945 case SAVE_BLOCK: 946 if (HAVE_restore_stack_block) 947 fcn = gen_restore_stack_block; 948 break; 949#endif 950#ifdef HAVE_restore_stack_function 951 case SAVE_FUNCTION: 952 if (HAVE_restore_stack_function) 953 fcn = gen_restore_stack_function; 954 break; 955#endif 956#ifdef HAVE_restore_stack_nonlocal 957 case SAVE_NONLOCAL: 958 if (HAVE_restore_stack_nonlocal) 959 fcn = gen_restore_stack_nonlocal; 960 break; 961#endif 962 default: 963 break; 964 } 965 966 if (sa != 0) 967 { 968 sa = validize_mem (sa); 969 /* These clobbers prevent the scheduler from moving 970 references to variable arrays below the code 971 that deletes (pops) the arrays. */ 972 emit_insn (gen_rtx_CLOBBER (VOIDmode, 973 gen_rtx_MEM (BLKmode, 974 gen_rtx_SCRATCH (VOIDmode)))); 975 emit_insn (gen_rtx_CLOBBER (VOIDmode, 976 gen_rtx_MEM (BLKmode, stack_pointer_rtx))); 977 } 978 979 discard_pending_stack_adjust (); 980 981 if (after) 982 { 983 rtx seq; 984 985 start_sequence (); 986 emit_insn (fcn (stack_pointer_rtx, sa)); 987 seq = get_insns (); 988 end_sequence (); 989 emit_insn_after (seq, after); 990 } 991 else 992 emit_insn (fcn (stack_pointer_rtx, sa)); 993} 994 995/* Invoke emit_stack_save on the nonlocal_goto_save_area for the current 996 function. This function should be called whenever we allocate or 997 deallocate dynamic stack space. */ 998 999void 1000update_nonlocal_goto_save_area (void) 1001{ 1002 tree t_save; 1003 rtx r_save; 1004 1005 /* The nonlocal_goto_save_area object is an array of N pointers. The 1006 first one is used for the frame pointer save; the rest are sized by 1007 STACK_SAVEAREA_MODE. Create a reference to array index 1, the first 1008 of the stack save area slots. */ 1009 t_save = build4 (ARRAY_REF, ptr_type_node, cfun->nonlocal_goto_save_area, 1010 integer_one_node, NULL_TREE, NULL_TREE); 1011 r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE); 1012 1013 emit_stack_save (SAVE_NONLOCAL, &r_save, NULL_RTX); 1014} 1015 1016/* Return an rtx representing the address of an area of memory dynamically 1017 pushed on the stack. This region of memory is always aligned to 1018 a multiple of BIGGEST_ALIGNMENT. 1019 1020 Any required stack pointer alignment is preserved. 1021 1022 SIZE is an rtx representing the size of the area. 1023 TARGET is a place in which the address can be placed. 1024 1025 KNOWN_ALIGN is the alignment (in bits) that we know SIZE has. */ 1026 1027rtx 1028allocate_dynamic_stack_space (rtx size, rtx target, int known_align) 1029{ 1030 /* If we're asking for zero bytes, it doesn't matter what we point 1031 to since we can't dereference it. But return a reasonable 1032 address anyway. */ 1033 if (size == const0_rtx) 1034 return virtual_stack_dynamic_rtx; 1035 1036 /* Otherwise, show we're calling alloca or equivalent. */ 1037 current_function_calls_alloca = 1; 1038 1039 /* Ensure the size is in the proper mode. */ 1040 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode) 1041 size = convert_to_mode (Pmode, size, 1); 1042 1043 /* We can't attempt to minimize alignment necessary, because we don't 1044 know the final value of preferred_stack_boundary yet while executing 1045 this code. */ 1046 cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY; 1047 1048 /* We will need to ensure that the address we return is aligned to 1049 BIGGEST_ALIGNMENT. If STACK_DYNAMIC_OFFSET is defined, we don't 1050 always know its final value at this point in the compilation (it 1051 might depend on the size of the outgoing parameter lists, for 1052 example), so we must align the value to be returned in that case. 1053 (Note that STACK_DYNAMIC_OFFSET will have a default nonzero value if 1054 STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined). 1055 We must also do an alignment operation on the returned value if 1056 the stack pointer alignment is less strict that BIGGEST_ALIGNMENT. 1057 1058 If we have to align, we must leave space in SIZE for the hole 1059 that might result from the alignment operation. */ 1060 1061#if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET) 1062#define MUST_ALIGN 1 1063#else 1064#define MUST_ALIGN (PREFERRED_STACK_BOUNDARY < BIGGEST_ALIGNMENT) 1065#endif 1066 1067 if (MUST_ALIGN) 1068 size 1069 = force_operand (plus_constant (size, 1070 BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1), 1071 NULL_RTX); 1072 1073#ifdef SETJMP_VIA_SAVE_AREA 1074 /* If setjmp restores regs from a save area in the stack frame, 1075 avoid clobbering the reg save area. Note that the offset of 1076 virtual_incoming_args_rtx includes the preallocated stack args space. 1077 It would be no problem to clobber that, but it's on the wrong side 1078 of the old save area. 1079 1080 What used to happen is that, since we did not know for sure 1081 whether setjmp() was invoked until after RTL generation, we 1082 would use reg notes to store the "optimized" size and fix things 1083 up later. These days we know this information before we ever 1084 start building RTL so the reg notes are unnecessary. */ 1085 if (!current_function_calls_setjmp) 1086 { 1087 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; 1088 1089 /* ??? Code below assumes that the save area needs maximal 1090 alignment. This constraint may be too strong. */ 1091 gcc_assert (PREFERRED_STACK_BOUNDARY == BIGGEST_ALIGNMENT); 1092 1093 if (GET_CODE (size) == CONST_INT) 1094 { 1095 HOST_WIDE_INT new = INTVAL (size) / align * align; 1096 1097 if (INTVAL (size) != new) 1098 size = GEN_INT (new); 1099 } 1100 else 1101 { 1102 /* Since we know overflow is not possible, we avoid using 1103 CEIL_DIV_EXPR and use TRUNC_DIV_EXPR instead. */ 1104 size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, 1105 GEN_INT (align), NULL_RTX, 1); 1106 size = expand_mult (Pmode, size, 1107 GEN_INT (align), NULL_RTX, 1); 1108 } 1109 } 1110 else 1111 { 1112 rtx dynamic_offset 1113 = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx, 1114 stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN); 1115 1116 size = expand_binop (Pmode, add_optab, size, dynamic_offset, 1117 NULL_RTX, 1, OPTAB_LIB_WIDEN); 1118 } 1119#endif /* SETJMP_VIA_SAVE_AREA */ 1120 1121 /* Round the size to a multiple of the required stack alignment. 1122 Since the stack if presumed to be rounded before this allocation, 1123 this will maintain the required alignment. 1124 1125 If the stack grows downward, we could save an insn by subtracting 1126 SIZE from the stack pointer and then aligning the stack pointer. 1127 The problem with this is that the stack pointer may be unaligned 1128 between the execution of the subtraction and alignment insns and 1129 some machines do not allow this. Even on those that do, some 1130 signal handlers malfunction if a signal should occur between those 1131 insns. Since this is an extremely rare event, we have no reliable 1132 way of knowing which systems have this problem. So we avoid even 1133 momentarily mis-aligning the stack. */ 1134 1135 /* If we added a variable amount to SIZE, 1136 we can no longer assume it is aligned. */ 1137#if !defined (SETJMP_VIA_SAVE_AREA) 1138 if (MUST_ALIGN || known_align % PREFERRED_STACK_BOUNDARY != 0) 1139#endif 1140 size = round_push (size); 1141 1142 do_pending_stack_adjust (); 1143 1144 /* We ought to be called always on the toplevel and stack ought to be aligned 1145 properly. */ 1146 gcc_assert (!(stack_pointer_delta 1147 % (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT))); 1148 1149 /* If needed, check that we have the required amount of stack. Take into 1150 account what has already been checked. */ 1151 if (flag_stack_check && ! STACK_CHECK_BUILTIN) 1152 probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size); 1153 1154 /* Don't use a TARGET that isn't a pseudo or is the wrong mode. */ 1155 if (target == 0 || !REG_P (target) 1156 || REGNO (target) < FIRST_PSEUDO_REGISTER 1157 || GET_MODE (target) != Pmode) 1158 target = gen_reg_rtx (Pmode); 1159 1160 mark_reg_pointer (target, known_align); 1161 1162 /* Perform the required allocation from the stack. Some systems do 1163 this differently than simply incrementing/decrementing from the 1164 stack pointer, such as acquiring the space by calling malloc(). */ 1165#ifdef HAVE_allocate_stack 1166 if (HAVE_allocate_stack) 1167 { 1168 enum machine_mode mode = STACK_SIZE_MODE; 1169 insn_operand_predicate_fn pred; 1170 1171 /* We don't have to check against the predicate for operand 0 since 1172 TARGET is known to be a pseudo of the proper mode, which must 1173 be valid for the operand. For operand 1, convert to the 1174 proper mode and validate. */ 1175 if (mode == VOIDmode) 1176 mode = insn_data[(int) CODE_FOR_allocate_stack].operand[1].mode; 1177 1178 pred = insn_data[(int) CODE_FOR_allocate_stack].operand[1].predicate; 1179 if (pred && ! ((*pred) (size, mode))) 1180 size = copy_to_mode_reg (mode, convert_to_mode (mode, size, 1)); 1181 1182 emit_insn (gen_allocate_stack (target, size)); 1183 } 1184 else 1185#endif 1186 { 1187#ifndef STACK_GROWS_DOWNWARD 1188 emit_move_insn (target, virtual_stack_dynamic_rtx); 1189#endif 1190 1191 /* Check stack bounds if necessary. */ 1192 if (current_function_limit_stack) 1193 { 1194 rtx available; 1195 rtx space_available = gen_label_rtx (); 1196#ifdef STACK_GROWS_DOWNWARD 1197 available = expand_binop (Pmode, sub_optab, 1198 stack_pointer_rtx, stack_limit_rtx, 1199 NULL_RTX, 1, OPTAB_WIDEN); 1200#else 1201 available = expand_binop (Pmode, sub_optab, 1202 stack_limit_rtx, stack_pointer_rtx, 1203 NULL_RTX, 1, OPTAB_WIDEN); 1204#endif 1205 emit_cmp_and_jump_insns (available, size, GEU, NULL_RTX, Pmode, 1, 1206 space_available); 1207#ifdef HAVE_trap 1208 if (HAVE_trap) 1209 emit_insn (gen_trap ()); 1210 else 1211#endif 1212 error ("stack limits not supported on this target"); 1213 emit_barrier (); 1214 emit_label (space_available); 1215 } 1216 1217 anti_adjust_stack (size); 1218 1219#ifdef STACK_GROWS_DOWNWARD 1220 emit_move_insn (target, virtual_stack_dynamic_rtx); 1221#endif 1222 } 1223 1224 if (MUST_ALIGN) 1225 { 1226 /* CEIL_DIV_EXPR needs to worry about the addition overflowing, 1227 but we know it can't. So add ourselves and then do 1228 TRUNC_DIV_EXPR. */ 1229 target = expand_binop (Pmode, add_optab, target, 1230 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1), 1231 NULL_RTX, 1, OPTAB_LIB_WIDEN); 1232 target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target, 1233 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT), 1234 NULL_RTX, 1); 1235 target = expand_mult (Pmode, target, 1236 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT), 1237 NULL_RTX, 1); 1238 } 1239 1240 /* Record the new stack level for nonlocal gotos. */ 1241 if (cfun->nonlocal_goto_save_area != 0) 1242 update_nonlocal_goto_save_area (); 1243 1244 return target; 1245} 1246 1247/* A front end may want to override GCC's stack checking by providing a 1248 run-time routine to call to check the stack, so provide a mechanism for 1249 calling that routine. */ 1250 1251static GTY(()) rtx stack_check_libfunc; 1252 1253void 1254set_stack_check_libfunc (rtx libfunc) 1255{ 1256 stack_check_libfunc = libfunc; 1257} 1258 1259/* Emit one stack probe at ADDRESS, an address within the stack. */ 1260 1261static void 1262emit_stack_probe (rtx address) 1263{ 1264 rtx memref = gen_rtx_MEM (word_mode, address); 1265 1266 MEM_VOLATILE_P (memref) = 1; 1267 1268 if (STACK_CHECK_PROBE_LOAD) 1269 emit_move_insn (gen_reg_rtx (word_mode), memref); 1270 else 1271 emit_move_insn (memref, const0_rtx); 1272} 1273 1274/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 1275 FIRST is a constant and size is a Pmode RTX. These are offsets from the 1276 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or 1277 subtract from the stack. If SIZE is constant, this is done 1278 with a fixed number of probes. Otherwise, we must make a loop. */ 1279 1280#ifdef STACK_GROWS_DOWNWARD 1281#define STACK_GROW_OP MINUS 1282#else 1283#define STACK_GROW_OP PLUS 1284#endif 1285 1286void 1287probe_stack_range (HOST_WIDE_INT first, rtx size) 1288{ 1289 /* First ensure SIZE is Pmode. */ 1290 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode) 1291 size = convert_to_mode (Pmode, size, 1); 1292 1293 /* Next see if the front end has set up a function for us to call to 1294 check the stack. */ 1295 if (stack_check_libfunc != 0) 1296 { 1297 rtx addr = memory_address (QImode, 1298 gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1299 stack_pointer_rtx, 1300 plus_constant (size, first))); 1301 1302 addr = convert_memory_address (ptr_mode, addr); 1303 emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr, 1304 ptr_mode); 1305 } 1306 1307 /* Next see if we have an insn to check the stack. Use it if so. */ 1308#ifdef HAVE_check_stack 1309 else if (HAVE_check_stack) 1310 { 1311 insn_operand_predicate_fn pred; 1312 rtx last_addr 1313 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1314 stack_pointer_rtx, 1315 plus_constant (size, first)), 1316 NULL_RTX); 1317 1318 pred = insn_data[(int) CODE_FOR_check_stack].operand[0].predicate; 1319 if (pred && ! ((*pred) (last_addr, Pmode))) 1320 last_addr = copy_to_mode_reg (Pmode, last_addr); 1321 1322 emit_insn (gen_check_stack (last_addr)); 1323 } 1324#endif 1325 1326 /* If we have to generate explicit probes, see if we have a constant 1327 small number of them to generate. If so, that's the easy case. */ 1328 else if (GET_CODE (size) == CONST_INT 1329 && INTVAL (size) < 10 * STACK_CHECK_PROBE_INTERVAL) 1330 { 1331 HOST_WIDE_INT offset; 1332 1333 /* Start probing at FIRST + N * STACK_CHECK_PROBE_INTERVAL 1334 for values of N from 1 until it exceeds LAST. If only one 1335 probe is needed, this will not generate any code. Then probe 1336 at LAST. */ 1337 for (offset = first + STACK_CHECK_PROBE_INTERVAL; 1338 offset < INTVAL (size); 1339 offset = offset + STACK_CHECK_PROBE_INTERVAL) 1340 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1341 stack_pointer_rtx, 1342 GEN_INT (offset))); 1343 1344 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1345 stack_pointer_rtx, 1346 plus_constant (size, first))); 1347 } 1348 1349 /* In the variable case, do the same as above, but in a loop. We emit loop 1350 notes so that loop optimization can be done. */ 1351 else 1352 { 1353 rtx test_addr 1354 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1355 stack_pointer_rtx, 1356 GEN_INT (first + STACK_CHECK_PROBE_INTERVAL)), 1357 NULL_RTX); 1358 rtx last_addr 1359 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode, 1360 stack_pointer_rtx, 1361 plus_constant (size, first)), 1362 NULL_RTX); 1363 rtx incr = GEN_INT (STACK_CHECK_PROBE_INTERVAL); 1364 rtx loop_lab = gen_label_rtx (); 1365 rtx test_lab = gen_label_rtx (); 1366 rtx end_lab = gen_label_rtx (); 1367 rtx temp; 1368 1369 if (!REG_P (test_addr) 1370 || REGNO (test_addr) < FIRST_PSEUDO_REGISTER) 1371 test_addr = force_reg (Pmode, test_addr); 1372 1373 emit_jump (test_lab); 1374 1375 emit_label (loop_lab); 1376 emit_stack_probe (test_addr); 1377 1378#ifdef STACK_GROWS_DOWNWARD 1379#define CMP_OPCODE GTU 1380 temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr, 1381 1, OPTAB_WIDEN); 1382#else 1383#define CMP_OPCODE LTU 1384 temp = expand_binop (Pmode, add_optab, test_addr, incr, test_addr, 1385 1, OPTAB_WIDEN); 1386#endif 1387 1388 gcc_assert (temp == test_addr); 1389 1390 emit_label (test_lab); 1391 emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE, 1392 NULL_RTX, Pmode, 1, loop_lab); 1393 emit_jump (end_lab); 1394 emit_label (end_lab); 1395 1396 emit_stack_probe (last_addr); 1397 } 1398} 1399 1400/* Return an rtx representing the register or memory location 1401 in which a scalar value of data type VALTYPE 1402 was returned by a function call to function FUNC. 1403 FUNC is a FUNCTION_DECL, FNTYPE a FUNCTION_TYPE node if the precise 1404 function is known, otherwise 0. 1405 OUTGOING is 1 if on a machine with register windows this function 1406 should return the register in which the function will put its result 1407 and 0 otherwise. */ 1408 1409rtx 1410hard_function_value (tree valtype, tree func, tree fntype, 1411 int outgoing ATTRIBUTE_UNUSED) 1412{ 1413 rtx val; 1414 1415 val = targetm.calls.function_value (valtype, func ? func : fntype, outgoing); 1416 1417 if (REG_P (val) 1418 && GET_MODE (val) == BLKmode) 1419 { 1420 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype); 1421 enum machine_mode tmpmode; 1422 1423 /* int_size_in_bytes can return -1. We don't need a check here 1424 since the value of bytes will then be large enough that no 1425 mode will match anyway. */ 1426 1427 for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT); 1428 tmpmode != VOIDmode; 1429 tmpmode = GET_MODE_WIDER_MODE (tmpmode)) 1430 { 1431 /* Have we found a large enough mode? */ 1432 if (GET_MODE_SIZE (tmpmode) >= bytes) 1433 break; 1434 } 1435 1436 /* No suitable mode found. */ 1437 gcc_assert (tmpmode != VOIDmode); 1438 1439 PUT_MODE (val, tmpmode); 1440 } 1441 return val; 1442} 1443 1444/* Return an rtx representing the register or memory location 1445 in which a scalar value of mode MODE was returned by a library call. */ 1446 1447rtx 1448hard_libcall_value (enum machine_mode mode) 1449{ 1450 return LIBCALL_VALUE (mode); 1451} 1452 1453/* Look up the tree code for a given rtx code 1454 to provide the arithmetic operation for REAL_ARITHMETIC. 1455 The function returns an int because the caller may not know 1456 what `enum tree_code' means. */ 1457 1458int 1459rtx_to_tree_code (enum rtx_code code) 1460{ 1461 enum tree_code tcode; 1462 1463 switch (code) 1464 { 1465 case PLUS: 1466 tcode = PLUS_EXPR; 1467 break; 1468 case MINUS: 1469 tcode = MINUS_EXPR; 1470 break; 1471 case MULT: 1472 tcode = MULT_EXPR; 1473 break; 1474 case DIV: 1475 tcode = RDIV_EXPR; 1476 break; 1477 case SMIN: 1478 tcode = MIN_EXPR; 1479 break; 1480 case SMAX: 1481 tcode = MAX_EXPR; 1482 break; 1483 default: 1484 tcode = LAST_AND_UNUSED_TREE_CODE; 1485 break; 1486 } 1487 return ((int) tcode); 1488} 1489 1490#include "gt-explow.h" 1491