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