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