1 /* Subroutines for manipulating rtx's in semantically interesting ways.
2 Copyright (C) 1987, 1991, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 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
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
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
33 #include "hard-reg-set.h"
34 #include "insn-config.h"
37 static rtx break_out_memory_refs PARAMS ((rtx));
38 static void emit_stack_probe PARAMS ((rtx));
41 /* Truncate and perhaps sign-extend C as appropriate for MODE. */
44 trunc_int_for_mode (c, mode)
46 enum machine_mode mode;
48 int width = GET_MODE_BITSIZE (mode);
50 /* Canonicalize BImode to 0 and STORE_FLAG_VALUE. */
52 return c & 1 ? STORE_FLAG_VALUE : 0;
54 /* Sign-extend for the requested mode. */
56 if (width < HOST_BITS_PER_WIDE_INT)
58 HOST_WIDE_INT sign = 1;
68 /* Return an rtx for the sum of X and the integer C.
70 This function should be used via the `plus_constant' macro. */
73 plus_constant_wide (x, c)
79 enum machine_mode mode;
95 return GEN_INT (INTVAL (x) + c);
99 unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
100 HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
101 unsigned HOST_WIDE_INT l2 = c;
102 HOST_WIDE_INT h2 = c < 0 ? ~0 : 0;
103 unsigned HOST_WIDE_INT lv;
106 add_double (l1, h1, l2, h2, &lv, &hv);
108 return immed_double_const (lv, hv, VOIDmode);
112 /* If this is a reference to the constant pool, try replacing it with
113 a reference to a new constant. If the resulting address isn't
114 valid, don't return it because we have no way to validize it. */
115 if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
116 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
119 = force_const_mem (GET_MODE (x),
120 plus_constant (get_pool_constant (XEXP (x, 0)),
122 if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
128 /* If adding to something entirely constant, set a flag
129 so that we can add a CONST around the result. */
140 /* The interesting case is adding the integer to a sum.
141 Look for constant term in the sum and combine
142 with C. For an integer constant term, we make a combined
143 integer. For a constant term that is not an explicit integer,
144 we cannot really combine, but group them together anyway.
146 Restart or use a recursive call in case the remaining operand is
147 something that we handle specially, such as a SYMBOL_REF.
149 We may not immediately return from the recursive call here, lest
150 all_constant gets lost. */
152 if (GET_CODE (XEXP (x, 1)) == CONST_INT)
154 c += INTVAL (XEXP (x, 1));
156 if (GET_MODE (x) != VOIDmode)
157 c = trunc_int_for_mode (c, GET_MODE (x));
162 else if (CONSTANT_P (XEXP (x, 1)))
164 x = gen_rtx_PLUS (mode, XEXP (x, 0), plus_constant (XEXP (x, 1), c));
167 else if (find_constant_term_loc (&y))
169 /* We need to be careful since X may be shared and we can't
170 modify it in place. */
171 rtx copy = copy_rtx (x);
172 rtx *const_loc = find_constant_term_loc (©);
174 *const_loc = plus_constant (*const_loc, c);
185 x = gen_rtx_PLUS (mode, x, GEN_INT (c));
187 if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
189 else if (all_constant)
190 return gen_rtx_CONST (mode, x);
195 /* If X is a sum, return a new sum like X but lacking any constant terms.
196 Add all the removed constant terms into *CONSTPTR.
197 X itself is not altered. The result != X if and only if
198 it is not isomorphic to X. */
201 eliminate_constant_term (x, constptr)
208 if (GET_CODE (x) != PLUS)
211 /* First handle constants appearing at this level explicitly. */
212 if (GET_CODE (XEXP (x, 1)) == CONST_INT
213 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
215 && GET_CODE (tem) == CONST_INT)
218 return eliminate_constant_term (XEXP (x, 0), constptr);
222 x0 = eliminate_constant_term (XEXP (x, 0), &tem);
223 x1 = eliminate_constant_term (XEXP (x, 1), &tem);
224 if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0))
225 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x),
227 && GET_CODE (tem) == CONST_INT)
230 return gen_rtx_PLUS (GET_MODE (x), x0, x1);
236 /* Returns the insn that next references REG after INSN, or 0
237 if REG is clobbered before next referenced or we cannot find
238 an insn that references REG in a straight-line piece of code. */
241 find_next_ref (reg, insn)
247 for (insn = NEXT_INSN (insn); insn; insn = next)
249 next = NEXT_INSN (insn);
250 if (GET_CODE (insn) == NOTE)
252 if (GET_CODE (insn) == CODE_LABEL
253 || GET_CODE (insn) == BARRIER)
255 if (GET_CODE (insn) == INSN
256 || GET_CODE (insn) == JUMP_INSN
257 || GET_CODE (insn) == CALL_INSN)
259 if (reg_set_p (reg, insn))
261 if (reg_mentioned_p (reg, PATTERN (insn)))
263 if (GET_CODE (insn) == JUMP_INSN)
265 if (any_uncondjump_p (insn))
266 next = JUMP_LABEL (insn);
270 if (GET_CODE (insn) == CALL_INSN
271 && REGNO (reg) < FIRST_PSEUDO_REGISTER
272 && call_used_regs[REGNO (reg)])
281 /* Return an rtx for the size in bytes of the value of EXP. */
289 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
290 && DECL_SIZE_UNIT (exp) != 0)
291 size = DECL_SIZE_UNIT (exp);
293 size = size_in_bytes (TREE_TYPE (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),
300 EXPAND_MEMORY_USE_BAD);
303 /* Return a copy of X in which all memory references
304 and all constants that involve symbol refs
305 have been replaced with new temporary registers.
306 Also emit code to load the memory locations and constants
307 into those registers.
309 If X contains no such constants or memory references,
310 X itself (not a copy) is returned.
312 If a constant is found in the address that is not a legitimate constant
313 in an insn, it is left alone in the hope that it might be valid in the
316 X may contain no arithmetic except addition, subtraction and multiplication.
317 Values returned by expand_expr with 1 for sum_ok fit this constraint. */
320 break_out_memory_refs (x)
323 if (GET_CODE (x) == MEM
324 || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
325 && GET_MODE (x) != VOIDmode))
326 x = force_reg (GET_MODE (x), x);
327 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
328 || GET_CODE (x) == MULT)
330 rtx op0 = break_out_memory_refs (XEXP (x, 0));
331 rtx op1 = break_out_memory_refs (XEXP (x, 1));
333 if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
334 x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
340 #ifdef POINTERS_EXTEND_UNSIGNED
342 /* Given X, a memory address in ptr_mode, convert it to an address
343 in Pmode, or vice versa (TO_MODE says which way). We take advantage of
344 the fact that pointers are not allowed to overflow by commuting arithmetic
345 operations over conversions so that address arithmetic insns can be
349 convert_memory_address (to_mode, x)
350 enum machine_mode to_mode;
353 enum machine_mode from_mode = to_mode == ptr_mode ? Pmode : ptr_mode;
356 /* Here we handle some special cases. If none of them apply, fall through
357 to the default case. */
358 switch (GET_CODE (x))
365 if (POINTERS_EXTEND_UNSIGNED >= 0
366 && (SUBREG_PROMOTED_VAR_P (x) || REG_POINTER (SUBREG_REG (x)))
367 && GET_MODE (SUBREG_REG (x)) == to_mode)
368 return SUBREG_REG (x);
372 if (POINTERS_EXTEND_UNSIGNED >= 0)
374 temp = gen_rtx_LABEL_REF (to_mode, XEXP (x, 0));
375 LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
381 if (POINTERS_EXTEND_UNSIGNED >= 0)
383 temp = gen_rtx_SYMBOL_REF (to_mode, XSTR (x, 0));
384 SYMBOL_REF_FLAG (temp) = SYMBOL_REF_FLAG (x);
385 CONSTANT_POOL_ADDRESS_P (temp) = CONSTANT_POOL_ADDRESS_P (x);
386 STRING_POOL_ADDRESS_P (temp) = STRING_POOL_ADDRESS_P (x);
392 if (POINTERS_EXTEND_UNSIGNED >= 0)
393 return gen_rtx_CONST (to_mode,
394 convert_memory_address (to_mode, XEXP (x, 0)));
399 /* For addition the second operand is a small constant, we can safely
400 permute the conversion and addition operation. We can always safely
401 permute them if we are making the address narrower. In addition,
402 always permute the operations if this is a constant. */
403 if (POINTERS_EXTEND_UNSIGNED >= 0
404 && (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
405 || (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT
406 && (INTVAL (XEXP (x, 1)) + 20000 < 40000
407 || CONSTANT_P (XEXP (x, 0))))))
408 return gen_rtx_fmt_ee (GET_CODE (x), to_mode,
409 convert_memory_address (to_mode, XEXP (x, 0)),
410 convert_memory_address (to_mode, XEXP (x, 1)));
417 return convert_modes (to_mode, from_mode,
418 x, POINTERS_EXTEND_UNSIGNED);
422 /* Given a memory address or facsimile X, construct a new address,
423 currently equivalent, that is stable: future stores won't change it.
425 X must be composed of constants, register and memory references
426 combined with addition, subtraction and multiplication:
427 in other words, just what you can get from expand_expr if sum_ok is 1.
429 Works by making copies of all regs and memory locations used
430 by X and combining them the same way X does.
431 You could also stabilize the reference to this address
432 by copying the address to a register with copy_to_reg;
433 but then you wouldn't get indexed addressing in the reference. */
439 if (GET_CODE (x) == REG)
441 if (REGNO (x) != FRAME_POINTER_REGNUM
442 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
443 && REGNO (x) != HARD_FRAME_POINTER_REGNUM
448 else if (GET_CODE (x) == MEM)
450 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
451 || GET_CODE (x) == MULT)
453 rtx op0 = copy_all_regs (XEXP (x, 0));
454 rtx op1 = copy_all_regs (XEXP (x, 1));
455 if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
456 x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
461 /* Return something equivalent to X but valid as a memory address
462 for something of mode MODE. When X is not itself valid, this
463 works by copying X or subexpressions of it into registers. */
466 memory_address (mode, x)
467 enum machine_mode mode;
472 if (GET_CODE (x) == ADDRESSOF)
475 #ifdef POINTERS_EXTEND_UNSIGNED
476 if (GET_MODE (x) != Pmode)
477 x = convert_memory_address (Pmode, x);
480 /* By passing constant addresses thru registers
481 we get a chance to cse them. */
482 if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
483 x = force_reg (Pmode, x);
485 /* Accept a QUEUED that refers to a REG
486 even though that isn't a valid address.
487 On attempting to put this in an insn we will call protect_from_queue
488 which will turn it into a REG, which is valid. */
489 else if (GET_CODE (x) == QUEUED
490 && GET_CODE (QUEUED_VAR (x)) == REG)
493 /* We get better cse by rejecting indirect addressing at this stage.
494 Let the combiner create indirect addresses where appropriate.
495 For now, generate the code so that the subexpressions useful to share
496 are visible. But not if cse won't be done! */
499 if (! cse_not_expected && GET_CODE (x) != REG)
500 x = break_out_memory_refs (x);
502 /* At this point, any valid address is accepted. */
503 GO_IF_LEGITIMATE_ADDRESS (mode, x, win);
505 /* If it was valid before but breaking out memory refs invalidated it,
506 use it the old way. */
507 if (memory_address_p (mode, oldx))
510 /* Perform machine-dependent transformations on X
511 in certain cases. This is not necessary since the code
512 below can handle all possible cases, but machine-dependent
513 transformations can make better code. */
514 LEGITIMIZE_ADDRESS (x, oldx, mode, win);
516 /* PLUS and MULT can appear in special ways
517 as the result of attempts to make an address usable for indexing.
518 Usually they are dealt with by calling force_operand, below.
519 But a sum containing constant terms is special
520 if removing them makes the sum a valid address:
521 then we generate that address in a register
522 and index off of it. We do this because it often makes
523 shorter code, and because the addresses thus generated
524 in registers often become common subexpressions. */
525 if (GET_CODE (x) == PLUS)
527 rtx constant_term = const0_rtx;
528 rtx y = eliminate_constant_term (x, &constant_term);
529 if (constant_term == const0_rtx
530 || ! memory_address_p (mode, y))
531 x = force_operand (x, NULL_RTX);
534 y = gen_rtx_PLUS (GET_MODE (x), copy_to_reg (y), constant_term);
535 if (! memory_address_p (mode, y))
536 x = force_operand (x, NULL_RTX);
542 else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS)
543 x = force_operand (x, NULL_RTX);
545 /* If we have a register that's an invalid address,
546 it must be a hard reg of the wrong class. Copy it to a pseudo. */
547 else if (GET_CODE (x) == REG)
550 /* Last resort: copy the value to a register, since
551 the register is a valid address. */
553 x = force_reg (Pmode, x);
560 if (flag_force_addr && ! cse_not_expected && GET_CODE (x) != REG
561 /* Don't copy an addr via a reg if it is one of our stack slots. */
562 && ! (GET_CODE (x) == PLUS
563 && (XEXP (x, 0) == virtual_stack_vars_rtx
564 || XEXP (x, 0) == virtual_incoming_args_rtx)))
566 if (general_operand (x, Pmode))
567 x = force_reg (Pmode, x);
569 x = force_operand (x, NULL_RTX);
575 /* If we didn't change the address, we are done. Otherwise, mark
576 a reg as a pointer if we have REG or REG + CONST_INT. */
579 else if (GET_CODE (x) == REG)
580 mark_reg_pointer (x, BITS_PER_UNIT);
581 else if (GET_CODE (x) == PLUS
582 && GET_CODE (XEXP (x, 0)) == REG
583 && GET_CODE (XEXP (x, 1)) == CONST_INT)
584 mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT);
586 /* OLDX may have been the address on a temporary. Update the address
587 to indicate that X is now used. */
588 update_temp_slot_address (oldx, x);
593 /* Like `memory_address' but pretend `flag_force_addr' is 0. */
596 memory_address_noforce (mode, x)
597 enum machine_mode mode;
600 int ambient_force_addr = flag_force_addr;
604 val = memory_address (mode, x);
605 flag_force_addr = ambient_force_addr;
609 /* Convert a mem ref into one with a valid memory address.
610 Pass through anything else unchanged. */
616 if (GET_CODE (ref) != MEM)
618 if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0)))
619 && memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
622 /* Don't alter REF itself, since that is probably a stack slot. */
623 return replace_equiv_address (ref, XEXP (ref, 0));
626 /* Given REF, either a MEM or a REG, and T, either the type of X or
627 the expression corresponding to REF, set RTX_UNCHANGING_P if
631 maybe_set_unchanging (ref, t)
635 /* We can set RTX_UNCHANGING_P from TREE_READONLY for decls whose
636 initialization is only executed once, or whose initializer always
637 has the same value. Currently we simplify this to PARM_DECLs in the
638 first case, and decls with TREE_CONSTANT initializers in the second. */
639 if ((TREE_READONLY (t) && DECL_P (t)
640 && (TREE_CODE (t) == PARM_DECL
641 || DECL_INITIAL (t) == NULL_TREE
642 || TREE_CONSTANT (DECL_INITIAL (t))))
643 || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
644 RTX_UNCHANGING_P (ref) = 1;
647 /* Return a modified copy of X with its memory address copied
648 into a temporary register to protect it from side effects.
649 If X is not a MEM, it is returned unchanged (and not copied).
650 Perhaps even if it is a MEM, if there is no need to change it. */
657 if (GET_CODE (x) != MEM
658 || ! rtx_unstable_p (XEXP (x, 0)))
662 replace_equiv_address (x, force_reg (Pmode, copy_all_regs (XEXP (x, 0))));
665 /* Copy the value or contents of X to a new temp reg and return that reg. */
671 rtx temp = gen_reg_rtx (GET_MODE (x));
673 /* If not an operand, must be an address with PLUS and MULT so
674 do the computation. */
675 if (! general_operand (x, VOIDmode))
676 x = force_operand (x, temp);
679 emit_move_insn (temp, x);
684 /* Like copy_to_reg but always give the new register mode Pmode
685 in case X is a constant. */
691 return copy_to_mode_reg (Pmode, x);
694 /* Like copy_to_reg but always give the new register mode MODE
695 in case X is a constant. */
698 copy_to_mode_reg (mode, x)
699 enum machine_mode mode;
702 rtx temp = gen_reg_rtx (mode);
704 /* If not an operand, must be an address with PLUS and MULT so
705 do the computation. */
706 if (! general_operand (x, VOIDmode))
707 x = force_operand (x, temp);
709 if (GET_MODE (x) != mode && GET_MODE (x) != VOIDmode)
712 emit_move_insn (temp, x);
716 /* Load X into a register if it is not already one.
717 Use mode MODE for the register.
718 X should be valid for mode MODE, but it may be a constant which
719 is valid for all integer modes; that's why caller must specify MODE.
721 The caller must not alter the value in the register we return,
722 since we mark it as a "constant" register. */
726 enum machine_mode mode;
731 if (GET_CODE (x) == REG)
734 temp = gen_reg_rtx (mode);
736 if (! general_operand (x, mode))
737 x = force_operand (x, NULL_RTX);
739 insn = emit_move_insn (temp, x);
741 /* Let optimizers know that TEMP's value never changes
742 and that X can be substituted for it. Don't get confused
743 if INSN set something else (such as a SUBREG of TEMP). */
745 && (set = single_set (insn)) != 0
746 && SET_DEST (set) == temp)
747 set_unique_reg_note (insn, REG_EQUAL, x);
751 /* If X is a memory ref, copy its contents to a new temp reg and return
752 that reg. Otherwise, return X. */
760 if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
763 temp = gen_reg_rtx (GET_MODE (x));
764 emit_move_insn (temp, x);
768 /* Copy X to TARGET (if it's nonzero and a reg)
769 or to a new temp reg and return that reg.
770 MODE is the mode to use for X in case it is a constant. */
773 copy_to_suggested_reg (x, target, mode)
775 enum machine_mode mode;
779 if (target && GET_CODE (target) == REG)
782 temp = gen_reg_rtx (mode);
784 emit_move_insn (temp, x);
788 /* Return the mode to use to store a scalar of TYPE and MODE.
789 PUNSIGNEDP points to the signedness of the type and may be adjusted
790 to show what signedness to use on extension operations.
792 FOR_CALL is non-zero if this call is promoting args for a call. */
795 promote_mode (type, mode, punsignedp, for_call)
797 enum machine_mode mode;
799 int for_call ATTRIBUTE_UNUSED;
801 enum tree_code code = TREE_CODE (type);
802 int unsignedp = *punsignedp;
804 #ifdef PROMOTE_FOR_CALL_ONLY
812 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
813 case CHAR_TYPE: case REAL_TYPE: case OFFSET_TYPE:
814 PROMOTE_MODE (mode, unsignedp, type);
818 #ifdef POINTERS_EXTEND_UNSIGNED
822 unsignedp = POINTERS_EXTEND_UNSIGNED;
830 *punsignedp = unsignedp;
834 /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes).
835 This pops when ADJUST is positive. ADJUST need not be constant. */
838 adjust_stack (adjust)
842 adjust = protect_from_queue (adjust, 0);
844 if (adjust == const0_rtx)
847 /* We expect all variable sized adjustments to be multiple of
848 PREFERRED_STACK_BOUNDARY. */
849 if (GET_CODE (adjust) == CONST_INT)
850 stack_pointer_delta -= INTVAL (adjust);
852 temp = expand_binop (Pmode,
853 #ifdef STACK_GROWS_DOWNWARD
858 stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
861 if (temp != stack_pointer_rtx)
862 emit_move_insn (stack_pointer_rtx, temp);
865 /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes).
866 This pushes when ADJUST is positive. ADJUST need not be constant. */
869 anti_adjust_stack (adjust)
873 adjust = protect_from_queue (adjust, 0);
875 if (adjust == const0_rtx)
878 /* We expect all variable sized adjustments to be multiple of
879 PREFERRED_STACK_BOUNDARY. */
880 if (GET_CODE (adjust) == CONST_INT)
881 stack_pointer_delta += INTVAL (adjust);
883 temp = expand_binop (Pmode,
884 #ifdef STACK_GROWS_DOWNWARD
889 stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
892 if (temp != stack_pointer_rtx)
893 emit_move_insn (stack_pointer_rtx, temp);
896 /* Round the size of a block to be pushed up to the boundary required
897 by this machine. SIZE is the desired size, which need not be constant. */
903 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
906 if (GET_CODE (size) == CONST_INT)
908 int new = (INTVAL (size) + align - 1) / align * align;
909 if (INTVAL (size) != new)
910 size = GEN_INT (new);
914 /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
915 but we know it can't. So add ourselves and then do
917 size = expand_binop (Pmode, add_optab, size, GEN_INT (align - 1),
918 NULL_RTX, 1, OPTAB_LIB_WIDEN);
919 size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, GEN_INT (align),
921 size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
926 /* Save the stack pointer for the purpose in SAVE_LEVEL. PSAVE is a pointer
927 to a previously-created save area. If no save area has been allocated,
928 this function will allocate one. If a save area is specified, it
929 must be of the proper mode.
931 The insns are emitted after insn AFTER, if nonzero, otherwise the insns
932 are emitted at the current position. */
935 emit_stack_save (save_level, psave, after)
936 enum save_level save_level;
941 /* The default is that we use a move insn and save in a Pmode object. */
942 rtx (*fcn) PARAMS ((rtx, rtx)) = gen_move_insn;
943 enum machine_mode mode = STACK_SAVEAREA_MODE (save_level);
945 /* See if this machine has anything special to do for this kind of save. */
948 #ifdef HAVE_save_stack_block
950 if (HAVE_save_stack_block)
951 fcn = gen_save_stack_block;
954 #ifdef HAVE_save_stack_function
956 if (HAVE_save_stack_function)
957 fcn = gen_save_stack_function;
960 #ifdef HAVE_save_stack_nonlocal
962 if (HAVE_save_stack_nonlocal)
963 fcn = gen_save_stack_nonlocal;
970 /* If there is no save area and we have to allocate one, do so. Otherwise
971 verify the save area is the proper mode. */
975 if (mode != VOIDmode)
977 if (save_level == SAVE_NONLOCAL)
978 *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
980 *psave = sa = gen_reg_rtx (mode);
985 if (mode == VOIDmode || GET_MODE (sa) != mode)
994 /* We must validize inside the sequence, to ensure that any instructions
995 created by the validize call also get moved to the right place. */
997 sa = validize_mem (sa);
998 emit_insn (fcn (sa, stack_pointer_rtx));
999 seq = gen_sequence ();
1001 emit_insn_after (seq, after);
1006 sa = validize_mem (sa);
1007 emit_insn (fcn (sa, stack_pointer_rtx));
1011 /* Restore the stack pointer for the purpose in SAVE_LEVEL. SA is the save
1012 area made by emit_stack_save. If it is zero, we have nothing to do.
1014 Put any emitted insns after insn AFTER, if nonzero, otherwise at
1015 current position. */
1018 emit_stack_restore (save_level, sa, after)
1019 enum save_level save_level;
1023 /* The default is that we use a move insn. */
1024 rtx (*fcn) PARAMS ((rtx, rtx)) = gen_move_insn;
1026 /* See if this machine has anything special to do for this kind of save. */
1029 #ifdef HAVE_restore_stack_block
1031 if (HAVE_restore_stack_block)
1032 fcn = gen_restore_stack_block;
1035 #ifdef HAVE_restore_stack_function
1037 if (HAVE_restore_stack_function)
1038 fcn = gen_restore_stack_function;
1041 #ifdef HAVE_restore_stack_nonlocal
1043 if (HAVE_restore_stack_nonlocal)
1044 fcn = gen_restore_stack_nonlocal;
1052 sa = validize_mem (sa);
1059 emit_insn (fcn (stack_pointer_rtx, sa));
1060 seq = gen_sequence ();
1062 emit_insn_after (seq, after);
1065 emit_insn (fcn (stack_pointer_rtx, sa));
1068 #ifdef SETJMP_VIA_SAVE_AREA
1069 /* Optimize RTL generated by allocate_dynamic_stack_space for targets
1070 where SETJMP_VIA_SAVE_AREA is true. The problem is that on these
1071 platforms, the dynamic stack space used can corrupt the original
1072 frame, thus causing a crash if a longjmp unwinds to it. */
1075 optimize_save_area_alloca (insns)
1080 for (insn = insns; insn; insn = NEXT_INSN(insn))
1084 if (GET_CODE (insn) != INSN)
1087 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
1089 if (REG_NOTE_KIND (note) != REG_SAVE_AREA)
1092 if (!current_function_calls_setjmp)
1094 rtx pat = PATTERN (insn);
1096 /* If we do not see the note in a pattern matching
1097 these precise characteristics, we did something
1098 entirely wrong in allocate_dynamic_stack_space.
1100 Note, one way this could happen is if SETJMP_VIA_SAVE_AREA
1101 was defined on a machine where stacks grow towards higher
1104 Right now only supported port with stack that grow upward
1105 is the HPPA and it does not define SETJMP_VIA_SAVE_AREA. */
1106 if (GET_CODE (pat) != SET
1107 || SET_DEST (pat) != stack_pointer_rtx
1108 || GET_CODE (SET_SRC (pat)) != MINUS
1109 || XEXP (SET_SRC (pat), 0) != stack_pointer_rtx)
1112 /* This will now be transformed into a (set REG REG)
1113 so we can just blow away all the other notes. */
1114 XEXP (SET_SRC (pat), 1) = XEXP (note, 0);
1115 REG_NOTES (insn) = NULL_RTX;
1119 /* setjmp was called, we must remove the REG_SAVE_AREA
1120 note so that later passes do not get confused by its
1122 if (note == REG_NOTES (insn))
1124 REG_NOTES (insn) = XEXP (note, 1);
1130 for (srch = REG_NOTES (insn); srch; srch = XEXP (srch, 1))
1131 if (XEXP (srch, 1) == note)
1134 if (srch == NULL_RTX)
1137 XEXP (srch, 1) = XEXP (note, 1);
1140 /* Once we've seen the note of interest, we need not look at
1141 the rest of them. */
1146 #endif /* SETJMP_VIA_SAVE_AREA */
1148 /* Return an rtx representing the address of an area of memory dynamically
1149 pushed on the stack. This region of memory is always aligned to
1150 a multiple of BIGGEST_ALIGNMENT.
1152 Any required stack pointer alignment is preserved.
1154 SIZE is an rtx representing the size of the area.
1155 TARGET is a place in which the address can be placed.
1157 KNOWN_ALIGN is the alignment (in bits) that we know SIZE has. */
1160 allocate_dynamic_stack_space (size, target, known_align)
1165 #ifdef SETJMP_VIA_SAVE_AREA
1166 rtx setjmpless_size = NULL_RTX;
1169 /* If we're asking for zero bytes, it doesn't matter what we point
1170 to since we can't dereference it. But return a reasonable
1172 if (size == const0_rtx)
1173 return virtual_stack_dynamic_rtx;
1175 /* Otherwise, show we're calling alloca or equivalent. */
1176 current_function_calls_alloca = 1;
1178 /* Ensure the size is in the proper mode. */
1179 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1180 size = convert_to_mode (Pmode, size, 1);
1182 /* We can't attempt to minimize alignment necessary, because we don't
1183 know the final value of preferred_stack_boundary yet while executing
1185 cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
1187 /* We will need to ensure that the address we return is aligned to
1188 BIGGEST_ALIGNMENT. If STACK_DYNAMIC_OFFSET is defined, we don't
1189 always know its final value at this point in the compilation (it
1190 might depend on the size of the outgoing parameter lists, for
1191 example), so we must align the value to be returned in that case.
1192 (Note that STACK_DYNAMIC_OFFSET will have a default non-zero value if
1193 STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined).
1194 We must also do an alignment operation on the returned value if
1195 the stack pointer alignment is less strict that BIGGEST_ALIGNMENT.
1197 If we have to align, we must leave space in SIZE for the hole
1198 that might result from the alignment operation. */
1200 #if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET)
1201 #define MUST_ALIGN 1
1203 #define MUST_ALIGN (PREFERRED_STACK_BOUNDARY < BIGGEST_ALIGNMENT)
1208 = force_operand (plus_constant (size,
1209 BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1212 #ifdef SETJMP_VIA_SAVE_AREA
1213 /* If setjmp restores regs from a save area in the stack frame,
1214 avoid clobbering the reg save area. Note that the offset of
1215 virtual_incoming_args_rtx includes the preallocated stack args space.
1216 It would be no problem to clobber that, but it's on the wrong side
1217 of the old save area. */
1220 = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx,
1221 stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN);
1223 if (!current_function_calls_setjmp)
1225 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1227 /* See optimize_save_area_alloca to understand what is being
1230 /* ??? Code below assumes that the save area needs maximal
1231 alignment. This constraint may be too strong. */
1232 if (PREFERRED_STACK_BOUNDARY != BIGGEST_ALIGNMENT)
1235 if (GET_CODE (size) == CONST_INT)
1237 HOST_WIDE_INT new = INTVAL (size) / align * align;
1239 if (INTVAL (size) != new)
1240 setjmpless_size = GEN_INT (new);
1242 setjmpless_size = size;
1246 /* Since we know overflow is not possible, we avoid using
1247 CEIL_DIV_EXPR and use TRUNC_DIV_EXPR instead. */
1248 setjmpless_size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size,
1249 GEN_INT (align), NULL_RTX, 1);
1250 setjmpless_size = expand_mult (Pmode, setjmpless_size,
1251 GEN_INT (align), NULL_RTX, 1);
1253 /* Our optimization works based upon being able to perform a simple
1254 transformation of this RTL into a (set REG REG) so make sure things
1255 did in fact end up in a REG. */
1256 if (!register_operand (setjmpless_size, Pmode))
1257 setjmpless_size = force_reg (Pmode, setjmpless_size);
1260 size = expand_binop (Pmode, add_optab, size, dynamic_offset,
1261 NULL_RTX, 1, OPTAB_LIB_WIDEN);
1263 #endif /* SETJMP_VIA_SAVE_AREA */
1265 /* Round the size to a multiple of the required stack alignment.
1266 Since the stack if presumed to be rounded before this allocation,
1267 this will maintain the required alignment.
1269 If the stack grows downward, we could save an insn by subtracting
1270 SIZE from the stack pointer and then aligning the stack pointer.
1271 The problem with this is that the stack pointer may be unaligned
1272 between the execution of the subtraction and alignment insns and
1273 some machines do not allow this. Even on those that do, some
1274 signal handlers malfunction if a signal should occur between those
1275 insns. Since this is an extremely rare event, we have no reliable
1276 way of knowing which systems have this problem. So we avoid even
1277 momentarily mis-aligning the stack. */
1279 /* If we added a variable amount to SIZE,
1280 we can no longer assume it is aligned. */
1281 #if !defined (SETJMP_VIA_SAVE_AREA)
1282 if (MUST_ALIGN || known_align % PREFERRED_STACK_BOUNDARY != 0)
1284 size = round_push (size);
1286 do_pending_stack_adjust ();
1288 /* We ought to be called always on the toplevel and stack ought to be aligned
1290 if (stack_pointer_delta % (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT))
1293 /* If needed, check that we have the required amount of stack. Take into
1294 account what has already been checked. */
1295 if (flag_stack_check && ! STACK_CHECK_BUILTIN)
1296 probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size);
1298 /* Don't use a TARGET that isn't a pseudo or is the wrong mode. */
1299 if (target == 0 || GET_CODE (target) != REG
1300 || REGNO (target) < FIRST_PSEUDO_REGISTER
1301 || GET_MODE (target) != Pmode)
1302 target = gen_reg_rtx (Pmode);
1304 mark_reg_pointer (target, known_align);
1306 /* Perform the required allocation from the stack. Some systems do
1307 this differently than simply incrementing/decrementing from the
1308 stack pointer, such as acquiring the space by calling malloc(). */
1309 #ifdef HAVE_allocate_stack
1310 if (HAVE_allocate_stack)
1312 enum machine_mode mode = STACK_SIZE_MODE;
1313 insn_operand_predicate_fn pred;
1315 /* We don't have to check against the predicate for operand 0 since
1316 TARGET is known to be a pseudo of the proper mode, which must
1317 be valid for the operand. For operand 1, convert to the
1318 proper mode and validate. */
1319 if (mode == VOIDmode)
1320 mode = insn_data[(int) CODE_FOR_allocate_stack].operand[1].mode;
1322 pred = insn_data[(int) CODE_FOR_allocate_stack].operand[1].predicate;
1323 if (pred && ! ((*pred) (size, mode)))
1324 size = copy_to_mode_reg (mode, size);
1326 emit_insn (gen_allocate_stack (target, size));
1331 #ifndef STACK_GROWS_DOWNWARD
1332 emit_move_insn (target, virtual_stack_dynamic_rtx);
1335 /* Check stack bounds if necessary. */
1336 if (current_function_limit_stack)
1339 rtx space_available = gen_label_rtx ();
1340 #ifdef STACK_GROWS_DOWNWARD
1341 available = expand_binop (Pmode, sub_optab,
1342 stack_pointer_rtx, stack_limit_rtx,
1343 NULL_RTX, 1, OPTAB_WIDEN);
1345 available = expand_binop (Pmode, sub_optab,
1346 stack_limit_rtx, stack_pointer_rtx,
1347 NULL_RTX, 1, OPTAB_WIDEN);
1349 emit_cmp_and_jump_insns (available, size, GEU, NULL_RTX, Pmode, 1,
1350 0, space_available);
1353 emit_insn (gen_trap ());
1356 error ("stack limits not supported on this target");
1358 emit_label (space_available);
1361 anti_adjust_stack (size);
1362 #ifdef SETJMP_VIA_SAVE_AREA
1363 if (setjmpless_size != NULL_RTX)
1365 rtx note_target = get_last_insn ();
1367 REG_NOTES (note_target)
1368 = gen_rtx_EXPR_LIST (REG_SAVE_AREA, setjmpless_size,
1369 REG_NOTES (note_target));
1371 #endif /* SETJMP_VIA_SAVE_AREA */
1373 #ifdef STACK_GROWS_DOWNWARD
1374 emit_move_insn (target, virtual_stack_dynamic_rtx);
1380 /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
1381 but we know it can't. So add ourselves and then do
1383 target = expand_binop (Pmode, add_optab, target,
1384 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1385 NULL_RTX, 1, OPTAB_LIB_WIDEN);
1386 target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target,
1387 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1389 target = expand_mult (Pmode, target,
1390 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1394 /* Some systems require a particular insn to refer to the stack
1395 to make the pages exist. */
1398 emit_insn (gen_probe ());
1401 /* Record the new stack level for nonlocal gotos. */
1402 if (nonlocal_goto_handler_slots != 0)
1403 emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
1408 /* A front end may want to override GCC's stack checking by providing a
1409 run-time routine to call to check the stack, so provide a mechanism for
1410 calling that routine. */
1412 static rtx stack_check_libfunc;
1415 set_stack_check_libfunc (libfunc)
1418 stack_check_libfunc = libfunc;
1421 /* Emit one stack probe at ADDRESS, an address within the stack. */
1424 emit_stack_probe (address)
1427 rtx memref = gen_rtx_MEM (word_mode, address);
1429 MEM_VOLATILE_P (memref) = 1;
1431 if (STACK_CHECK_PROBE_LOAD)
1432 emit_move_insn (gen_reg_rtx (word_mode), memref);
1434 emit_move_insn (memref, const0_rtx);
1437 /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
1438 FIRST is a constant and size is a Pmode RTX. These are offsets from the
1439 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or
1440 subtract from the stack. If SIZE is constant, this is done
1441 with a fixed number of probes. Otherwise, we must make a loop. */
1443 #ifdef STACK_GROWS_DOWNWARD
1444 #define STACK_GROW_OP MINUS
1446 #define STACK_GROW_OP PLUS
1450 probe_stack_range (first, size)
1451 HOST_WIDE_INT first;
1454 /* First ensure SIZE is Pmode. */
1455 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1456 size = convert_to_mode (Pmode, size, 1);
1458 /* Next see if the front end has set up a function for us to call to
1460 if (stack_check_libfunc != 0)
1462 rtx addr = memory_address (QImode,
1463 gen_rtx (STACK_GROW_OP, Pmode,
1465 plus_constant (size, first)));
1467 #ifdef POINTERS_EXTEND_UNSIGNED
1468 if (GET_MODE (addr) != ptr_mode)
1469 addr = convert_memory_address (ptr_mode, addr);
1472 emit_library_call (stack_check_libfunc, 0, VOIDmode, 1, addr,
1476 /* Next see if we have an insn to check the stack. Use it if so. */
1477 #ifdef HAVE_check_stack
1478 else if (HAVE_check_stack)
1480 insn_operand_predicate_fn pred;
1482 = force_operand (gen_rtx_STACK_GROW_OP (Pmode,
1484 plus_constant (size, first)),
1487 pred = insn_data[(int) CODE_FOR_check_stack].operand[0].predicate;
1488 if (pred && ! ((*pred) (last_addr, Pmode)))
1489 last_addr = copy_to_mode_reg (Pmode, last_addr);
1491 emit_insn (gen_check_stack (last_addr));
1495 /* If we have to generate explicit probes, see if we have a constant
1496 small number of them to generate. If so, that's the easy case. */
1497 else if (GET_CODE (size) == CONST_INT
1498 && INTVAL (size) < 10 * STACK_CHECK_PROBE_INTERVAL)
1500 HOST_WIDE_INT offset;
1502 /* Start probing at FIRST + N * STACK_CHECK_PROBE_INTERVAL
1503 for values of N from 1 until it exceeds LAST. If only one
1504 probe is needed, this will not generate any code. Then probe
1506 for (offset = first + STACK_CHECK_PROBE_INTERVAL;
1507 offset < INTVAL (size);
1508 offset = offset + STACK_CHECK_PROBE_INTERVAL)
1509 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1513 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1515 plus_constant (size, first)));
1518 /* In the variable case, do the same as above, but in a loop. We emit loop
1519 notes so that loop optimization can be done. */
1523 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1525 GEN_INT (first + STACK_CHECK_PROBE_INTERVAL)),
1528 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1530 plus_constant (size, first)),
1532 rtx incr = GEN_INT (STACK_CHECK_PROBE_INTERVAL);
1533 rtx loop_lab = gen_label_rtx ();
1534 rtx test_lab = gen_label_rtx ();
1535 rtx end_lab = gen_label_rtx ();
1538 if (GET_CODE (test_addr) != REG
1539 || REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
1540 test_addr = force_reg (Pmode, test_addr);
1542 emit_note (NULL, NOTE_INSN_LOOP_BEG);
1543 emit_jump (test_lab);
1545 emit_label (loop_lab);
1546 emit_stack_probe (test_addr);
1548 emit_note (NULL, NOTE_INSN_LOOP_CONT);
1550 #ifdef STACK_GROWS_DOWNWARD
1551 #define CMP_OPCODE GTU
1552 temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr,
1555 #define CMP_OPCODE LTU
1556 temp = expand_binop (Pmode, add_optab, test_addr, incr, test_addr,
1560 if (temp != test_addr)
1563 emit_label (test_lab);
1564 emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
1565 NULL_RTX, Pmode, 1, 0, loop_lab);
1566 emit_jump (end_lab);
1567 emit_note (NULL, NOTE_INSN_LOOP_END);
1568 emit_label (end_lab);
1570 emit_stack_probe (last_addr);
1574 /* Return an rtx representing the register or memory location
1575 in which a scalar value of data type VALTYPE
1576 was returned by a function call to function FUNC.
1577 FUNC is a FUNCTION_DECL node if the precise function is known,
1579 OUTGOING is 1 if on a machine with register windows this function
1580 should return the register in which the function will put its result
1584 hard_function_value (valtype, func, outgoing)
1586 tree func ATTRIBUTE_UNUSED;
1587 int outgoing ATTRIBUTE_UNUSED;
1591 #ifdef FUNCTION_OUTGOING_VALUE
1593 val = FUNCTION_OUTGOING_VALUE (valtype, func);
1596 val = FUNCTION_VALUE (valtype, func);
1598 if (GET_CODE (val) == REG
1599 && GET_MODE (val) == BLKmode)
1601 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype);
1602 enum machine_mode tmpmode;
1604 for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1605 tmpmode != VOIDmode;
1606 tmpmode = GET_MODE_WIDER_MODE (tmpmode))
1608 /* Have we found a large enough mode? */
1609 if (GET_MODE_SIZE (tmpmode) >= bytes)
1613 /* No suitable mode found. */
1614 if (tmpmode == VOIDmode)
1617 PUT_MODE (val, tmpmode);
1622 /* Return an rtx representing the register or memory location
1623 in which a scalar value of mode MODE was returned by a library call. */
1626 hard_libcall_value (mode)
1627 enum machine_mode mode;
1629 return LIBCALL_VALUE (mode);
1632 /* Look up the tree code for a given rtx code
1633 to provide the arithmetic operation for REAL_ARITHMETIC.
1634 The function returns an int because the caller may not know
1635 what `enum tree_code' means. */
1638 rtx_to_tree_code (code)
1641 enum tree_code tcode;
1664 tcode = LAST_AND_UNUSED_TREE_CODE;
1667 return ((int) tcode);