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
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
25 #include "coretypes.h"
35 #include "hard-reg-set.h"
36 #include "insn-config.h"
39 #include "langhooks.h"
41 static rtx break_out_memory_refs PARAMS ((rtx));
42 static void emit_stack_probe PARAMS ((rtx));
45 /* Truncate and perhaps sign-extend C as appropriate for MODE. */
48 trunc_int_for_mode (c, mode)
50 enum machine_mode mode;
52 int width = GET_MODE_BITSIZE (mode);
54 /* You want to truncate to a _what_? */
55 if (! SCALAR_INT_MODE_P (mode))
58 /* Canonicalize BImode to 0 and STORE_FLAG_VALUE. */
60 return c & 1 ? STORE_FLAG_VALUE : 0;
62 /* Sign-extend for the requested mode. */
64 if (width < HOST_BITS_PER_WIDE_INT)
66 HOST_WIDE_INT sign = 1;
76 /* Return an rtx for the sum of X and the integer C.
78 This function should be used via the `plus_constant' macro. */
81 plus_constant_wide (x, c)
87 enum machine_mode mode;
103 return GEN_INT (INTVAL (x) + c);
107 unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
108 HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
109 unsigned HOST_WIDE_INT l2 = c;
110 HOST_WIDE_INT h2 = c < 0 ? ~0 : 0;
111 unsigned HOST_WIDE_INT lv;
114 add_double (l1, h1, l2, h2, &lv, &hv);
116 return immed_double_const (lv, hv, VOIDmode);
120 /* If this is a reference to the constant pool, try replacing it with
121 a reference to a new constant. If the resulting address isn't
122 valid, don't return it because we have no way to validize it. */
123 if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
124 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
127 = force_const_mem (GET_MODE (x),
128 plus_constant (get_pool_constant (XEXP (x, 0)),
130 if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
136 /* If adding to something entirely constant, set a flag
137 so that we can add a CONST around the result. */
148 /* The interesting case is adding the integer to a sum.
149 Look for constant term in the sum and combine
150 with C. For an integer constant term, we make a combined
151 integer. For a constant term that is not an explicit integer,
152 we cannot really combine, but group them together anyway.
154 Restart or use a recursive call in case the remaining operand is
155 something that we handle specially, such as a SYMBOL_REF.
157 We may not immediately return from the recursive call here, lest
158 all_constant gets lost. */
160 if (GET_CODE (XEXP (x, 1)) == CONST_INT)
162 c += INTVAL (XEXP (x, 1));
164 if (GET_MODE (x) != VOIDmode)
165 c = trunc_int_for_mode (c, GET_MODE (x));
170 else if (CONSTANT_P (XEXP (x, 1)))
172 x = gen_rtx_PLUS (mode, XEXP (x, 0), plus_constant (XEXP (x, 1), c));
175 else if (find_constant_term_loc (&y))
177 /* We need to be careful since X may be shared and we can't
178 modify it in place. */
179 rtx copy = copy_rtx (x);
180 rtx *const_loc = find_constant_term_loc (©);
182 *const_loc = plus_constant (*const_loc, c);
193 x = gen_rtx_PLUS (mode, x, GEN_INT (c));
195 if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
197 else if (all_constant)
198 return gen_rtx_CONST (mode, x);
203 /* If X is a sum, return a new sum like X but lacking any constant terms.
204 Add all the removed constant terms into *CONSTPTR.
205 X itself is not altered. The result != X if and only if
206 it is not isomorphic to X. */
209 eliminate_constant_term (x, constptr)
216 if (GET_CODE (x) != PLUS)
219 /* First handle constants appearing at this level explicitly. */
220 if (GET_CODE (XEXP (x, 1)) == CONST_INT
221 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
223 && GET_CODE (tem) == CONST_INT)
226 return eliminate_constant_term (XEXP (x, 0), constptr);
230 x0 = eliminate_constant_term (XEXP (x, 0), &tem);
231 x1 = eliminate_constant_term (XEXP (x, 1), &tem);
232 if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0))
233 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x),
235 && GET_CODE (tem) == CONST_INT)
238 return gen_rtx_PLUS (GET_MODE (x), x0, x1);
244 /* Return an rtx for the size in bytes of the value of EXP. */
250 tree size = (*lang_hooks.expr_size) (exp);
252 if (CONTAINS_PLACEHOLDER_P (size))
253 size = build (WITH_RECORD_EXPR, sizetype, size, exp);
255 return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), 0);
258 /* Return a wide integer for the size in bytes of the value of EXP, or -1
259 if the size can vary or is larger than an integer. */
265 tree t = (*lang_hooks.expr_size) (exp);
268 || TREE_CODE (t) != INTEGER_CST
270 || TREE_INT_CST_HIGH (t) != 0
271 /* If the result would appear negative, it's too big to represent. */
272 || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
275 return TREE_INT_CST_LOW (t);
278 /* Return a copy of X in which all memory references
279 and all constants that involve symbol refs
280 have been replaced with new temporary registers.
281 Also emit code to load the memory locations and constants
282 into those registers.
284 If X contains no such constants or memory references,
285 X itself (not a copy) is returned.
287 If a constant is found in the address that is not a legitimate constant
288 in an insn, it is left alone in the hope that it might be valid in the
291 X may contain no arithmetic except addition, subtraction and multiplication.
292 Values returned by expand_expr with 1 for sum_ok fit this constraint. */
295 break_out_memory_refs (x)
298 if (GET_CODE (x) == MEM
299 || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
300 && GET_MODE (x) != VOIDmode))
301 x = force_reg (GET_MODE (x), x);
302 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
303 || GET_CODE (x) == MULT)
305 rtx op0 = break_out_memory_refs (XEXP (x, 0));
306 rtx op1 = break_out_memory_refs (XEXP (x, 1));
308 if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
309 x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
315 #ifdef POINTERS_EXTEND_UNSIGNED
317 /* Given X, a memory address in ptr_mode, convert it to an address
318 in Pmode, or vice versa (TO_MODE says which way). We take advantage of
319 the fact that pointers are not allowed to overflow by commuting arithmetic
320 operations over conversions so that address arithmetic insns can be
324 convert_memory_address (to_mode, x)
325 enum machine_mode to_mode;
328 enum machine_mode from_mode = to_mode == ptr_mode ? Pmode : ptr_mode;
332 /* Here we handle some special cases. If none of them apply, fall through
333 to the default case. */
334 switch (GET_CODE (x))
338 if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode))
340 else if (POINTERS_EXTEND_UNSIGNED < 0)
342 else if (POINTERS_EXTEND_UNSIGNED > 0)
346 temp = simplify_unary_operation (code, to_mode, x, from_mode);
352 if ((SUBREG_PROMOTED_VAR_P (x) || REG_POINTER (SUBREG_REG (x)))
353 && GET_MODE (SUBREG_REG (x)) == to_mode)
354 return SUBREG_REG (x);
358 temp = gen_rtx_LABEL_REF (to_mode, XEXP (x, 0));
359 LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
364 temp = shallow_copy_rtx (x);
365 PUT_MODE (temp, to_mode);
370 return gen_rtx_CONST (to_mode,
371 convert_memory_address (to_mode, XEXP (x, 0)));
376 /* For addition we can safely permute the conversion and addition
377 operation if one operand is a constant and converting the constant
378 does not change it. We can always safely permute them if we are
379 making the address narrower. */
380 if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
381 || (GET_CODE (x) == PLUS
382 && GET_CODE (XEXP (x, 1)) == CONST_INT
383 && XEXP (x, 1) == convert_memory_address (to_mode, XEXP (x, 1))))
384 return gen_rtx_fmt_ee (GET_CODE (x), to_mode,
385 convert_memory_address (to_mode, XEXP (x, 0)),
393 return convert_modes (to_mode, from_mode,
394 x, POINTERS_EXTEND_UNSIGNED);
398 /* Given a memory address or facsimile X, construct a new address,
399 currently equivalent, that is stable: future stores won't change it.
401 X must be composed of constants, register and memory references
402 combined with addition, subtraction and multiplication:
403 in other words, just what you can get from expand_expr if sum_ok is 1.
405 Works by making copies of all regs and memory locations used
406 by X and combining them the same way X does.
407 You could also stabilize the reference to this address
408 by copying the address to a register with copy_to_reg;
409 but then you wouldn't get indexed addressing in the reference. */
415 if (GET_CODE (x) == REG)
417 if (REGNO (x) != FRAME_POINTER_REGNUM
418 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
419 && REGNO (x) != HARD_FRAME_POINTER_REGNUM
424 else if (GET_CODE (x) == MEM)
426 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
427 || GET_CODE (x) == MULT)
429 rtx op0 = copy_all_regs (XEXP (x, 0));
430 rtx op1 = copy_all_regs (XEXP (x, 1));
431 if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
432 x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
437 /* Return something equivalent to X but valid as a memory address
438 for something of mode MODE. When X is not itself valid, this
439 works by copying X or subexpressions of it into registers. */
442 memory_address (mode, x)
443 enum machine_mode mode;
448 if (GET_CODE (x) == ADDRESSOF)
451 #ifdef POINTERS_EXTEND_UNSIGNED
452 if (GET_MODE (x) != Pmode)
453 x = convert_memory_address (Pmode, x);
456 /* By passing constant addresses thru registers
457 we get a chance to cse them. */
458 if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
459 x = force_reg (Pmode, x);
461 /* Accept a QUEUED that refers to a REG
462 even though that isn't a valid address.
463 On attempting to put this in an insn we will call protect_from_queue
464 which will turn it into a REG, which is valid. */
465 else if (GET_CODE (x) == QUEUED
466 && GET_CODE (QUEUED_VAR (x)) == REG)
469 /* We get better cse by rejecting indirect addressing at this stage.
470 Let the combiner create indirect addresses where appropriate.
471 For now, generate the code so that the subexpressions useful to share
472 are visible. But not if cse won't be done! */
475 if (! cse_not_expected && GET_CODE (x) != REG)
476 x = break_out_memory_refs (x);
478 /* At this point, any valid address is accepted. */
479 GO_IF_LEGITIMATE_ADDRESS (mode, x, win);
481 /* If it was valid before but breaking out memory refs invalidated it,
482 use it the old way. */
483 if (memory_address_p (mode, oldx))
486 /* Perform machine-dependent transformations on X
487 in certain cases. This is not necessary since the code
488 below can handle all possible cases, but machine-dependent
489 transformations can make better code. */
490 LEGITIMIZE_ADDRESS (x, oldx, mode, win);
492 /* PLUS and MULT can appear in special ways
493 as the result of attempts to make an address usable for indexing.
494 Usually they are dealt with by calling force_operand, below.
495 But a sum containing constant terms is special
496 if removing them makes the sum a valid address:
497 then we generate that address in a register
498 and index off of it. We do this because it often makes
499 shorter code, and because the addresses thus generated
500 in registers often become common subexpressions. */
501 if (GET_CODE (x) == PLUS)
503 rtx constant_term = const0_rtx;
504 rtx y = eliminate_constant_term (x, &constant_term);
505 if (constant_term == const0_rtx
506 || ! memory_address_p (mode, y))
507 x = force_operand (x, NULL_RTX);
510 y = gen_rtx_PLUS (GET_MODE (x), copy_to_reg (y), constant_term);
511 if (! memory_address_p (mode, y))
512 x = force_operand (x, NULL_RTX);
518 else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS)
519 x = force_operand (x, NULL_RTX);
521 /* If we have a register that's an invalid address,
522 it must be a hard reg of the wrong class. Copy it to a pseudo. */
523 else if (GET_CODE (x) == REG)
526 /* Last resort: copy the value to a register, since
527 the register is a valid address. */
529 x = force_reg (Pmode, x);
536 if (flag_force_addr && ! cse_not_expected && GET_CODE (x) != REG
537 /* Don't copy an addr via a reg if it is one of our stack slots. */
538 && ! (GET_CODE (x) == PLUS
539 && (XEXP (x, 0) == virtual_stack_vars_rtx
540 || XEXP (x, 0) == virtual_incoming_args_rtx)))
542 if (general_operand (x, Pmode))
543 x = force_reg (Pmode, x);
545 x = force_operand (x, NULL_RTX);
551 /* If we didn't change the address, we are done. Otherwise, mark
552 a reg as a pointer if we have REG or REG + CONST_INT. */
555 else if (GET_CODE (x) == REG)
556 mark_reg_pointer (x, BITS_PER_UNIT);
557 else if (GET_CODE (x) == PLUS
558 && GET_CODE (XEXP (x, 0)) == REG
559 && GET_CODE (XEXP (x, 1)) == CONST_INT)
560 mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT);
562 /* OLDX may have been the address on a temporary. Update the address
563 to indicate that X is now used. */
564 update_temp_slot_address (oldx, x);
569 /* Like `memory_address' but pretend `flag_force_addr' is 0. */
572 memory_address_noforce (mode, x)
573 enum machine_mode mode;
576 int ambient_force_addr = flag_force_addr;
580 val = memory_address (mode, x);
581 flag_force_addr = ambient_force_addr;
585 /* Convert a mem ref into one with a valid memory address.
586 Pass through anything else unchanged. */
592 if (GET_CODE (ref) != MEM)
594 if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0)))
595 && memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
598 /* Don't alter REF itself, since that is probably a stack slot. */
599 return replace_equiv_address (ref, XEXP (ref, 0));
602 /* Given REF, either a MEM or a REG, and T, either the type of X or
603 the expression corresponding to REF, set RTX_UNCHANGING_P if
607 maybe_set_unchanging (ref, t)
611 /* We can set RTX_UNCHANGING_P from TREE_READONLY for decls whose
612 initialization is only executed once, or whose initializer always
613 has the same value. Currently we simplify this to PARM_DECLs in the
614 first case, and decls with TREE_CONSTANT initializers in the second.
616 We cannot do this for non-static aggregates, because of the double
617 writes that can be generated by store_constructor, depending on the
618 contents of the initializer. Yes, this does eliminate a good fraction
619 of the number of uses of RTX_UNCHANGING_P for a language like Ada.
620 It also eliminates a good quantity of bugs. Let this be incentive to
621 eliminate RTX_UNCHANGING_P entirely in favor of a more reliable
622 solution, perhaps based on alias sets. */
624 if ((TREE_READONLY (t) && DECL_P (t)
625 && (TREE_STATIC (t) || ! AGGREGATE_TYPE_P (TREE_TYPE (t)))
626 && (TREE_CODE (t) == PARM_DECL
627 || (DECL_INITIAL (t) && TREE_CONSTANT (DECL_INITIAL (t)))))
628 || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
629 RTX_UNCHANGING_P (ref) = 1;
632 /* Return a modified copy of X with its memory address copied
633 into a temporary register to protect it from side effects.
634 If X is not a MEM, it is returned unchanged (and not copied).
635 Perhaps even if it is a MEM, if there is no need to change it. */
641 if (GET_CODE (x) != MEM
642 || ! rtx_unstable_p (XEXP (x, 0)))
646 replace_equiv_address (x, force_reg (Pmode, copy_all_regs (XEXP (x, 0))));
649 /* Copy the value or contents of X to a new temp reg and return that reg. */
655 rtx temp = gen_reg_rtx (GET_MODE (x));
657 /* If not an operand, must be an address with PLUS and MULT so
658 do the computation. */
659 if (! general_operand (x, VOIDmode))
660 x = force_operand (x, temp);
663 emit_move_insn (temp, x);
668 /* Like copy_to_reg but always give the new register mode Pmode
669 in case X is a constant. */
675 return copy_to_mode_reg (Pmode, x);
678 /* Like copy_to_reg but always give the new register mode MODE
679 in case X is a constant. */
682 copy_to_mode_reg (mode, x)
683 enum machine_mode mode;
686 rtx temp = gen_reg_rtx (mode);
688 /* If not an operand, must be an address with PLUS and MULT so
689 do the computation. */
690 if (! general_operand (x, VOIDmode))
691 x = force_operand (x, temp);
693 if (GET_MODE (x) != mode && GET_MODE (x) != VOIDmode)
696 emit_move_insn (temp, x);
700 /* Load X into a register if it is not already one.
701 Use mode MODE for the register.
702 X should be valid for mode MODE, but it may be a constant which
703 is valid for all integer modes; that's why caller must specify MODE.
705 The caller must not alter the value in the register we return,
706 since we mark it as a "constant" register. */
710 enum machine_mode mode;
715 if (GET_CODE (x) == REG)
718 if (general_operand (x, mode))
720 temp = gen_reg_rtx (mode);
721 insn = emit_move_insn (temp, x);
725 temp = force_operand (x, NULL_RTX);
726 if (GET_CODE (temp) == REG)
727 insn = get_last_insn ();
730 rtx temp2 = gen_reg_rtx (mode);
731 insn = emit_move_insn (temp2, temp);
736 /* Let optimizers know that TEMP's value never changes
737 and that X can be substituted for it. Don't get confused
738 if INSN set something else (such as a SUBREG of TEMP). */
740 && (set = single_set (insn)) != 0
741 && SET_DEST (set) == temp
742 && ! rtx_equal_p (x, SET_SRC (set)))
743 set_unique_reg_note (insn, REG_EQUAL, x);
748 /* If X is a memory ref, copy its contents to a new temp reg and return
749 that reg. Otherwise, return X. */
757 if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
760 temp = gen_reg_rtx (GET_MODE (x));
761 emit_move_insn (temp, x);
765 /* Copy X to TARGET (if it's nonzero and a reg)
766 or to a new temp reg and return that reg.
767 MODE is the mode to use for X in case it is a constant. */
770 copy_to_suggested_reg (x, target, mode)
772 enum machine_mode mode;
776 if (target && GET_CODE (target) == REG)
779 temp = gen_reg_rtx (mode);
781 emit_move_insn (temp, x);
785 /* Return the mode to use to store a scalar of TYPE and MODE.
786 PUNSIGNEDP points to the signedness of the type and may be adjusted
787 to show what signedness to use on extension operations.
789 FOR_CALL is nonzero if this call is promoting args for a call. */
792 promote_mode (type, mode, punsignedp, for_call)
794 enum machine_mode mode;
796 int for_call ATTRIBUTE_UNUSED;
798 enum tree_code code = TREE_CODE (type);
799 int unsignedp = *punsignedp;
801 #ifdef PROMOTE_FOR_CALL_ONLY
809 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
810 case CHAR_TYPE: case REAL_TYPE: case OFFSET_TYPE:
811 PROMOTE_MODE (mode, unsignedp, type);
815 #ifdef POINTERS_EXTEND_UNSIGNED
819 unsignedp = POINTERS_EXTEND_UNSIGNED;
827 *punsignedp = unsignedp;
831 /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes).
832 This pops when ADJUST is positive. ADJUST need not be constant. */
835 adjust_stack (adjust)
839 adjust = protect_from_queue (adjust, 0);
841 if (adjust == const0_rtx)
844 /* We expect all variable sized adjustments to be multiple of
845 PREFERRED_STACK_BOUNDARY. */
846 if (GET_CODE (adjust) == CONST_INT)
847 stack_pointer_delta -= INTVAL (adjust);
849 temp = expand_binop (Pmode,
850 #ifdef STACK_GROWS_DOWNWARD
855 stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
858 if (temp != stack_pointer_rtx)
859 emit_move_insn (stack_pointer_rtx, temp);
862 /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes).
863 This pushes when ADJUST is positive. ADJUST need not be constant. */
866 anti_adjust_stack (adjust)
870 adjust = protect_from_queue (adjust, 0);
872 if (adjust == const0_rtx)
875 /* We expect all variable sized adjustments to be multiple of
876 PREFERRED_STACK_BOUNDARY. */
877 if (GET_CODE (adjust) == CONST_INT)
878 stack_pointer_delta += INTVAL (adjust);
880 temp = expand_binop (Pmode,
881 #ifdef STACK_GROWS_DOWNWARD
886 stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
889 if (temp != stack_pointer_rtx)
890 emit_move_insn (stack_pointer_rtx, temp);
893 /* Round the size of a block to be pushed up to the boundary required
894 by this machine. SIZE is the desired size, which need not be constant. */
900 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
905 if (GET_CODE (size) == CONST_INT)
907 HOST_WIDE_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);
927 /* Save the stack pointer for the purpose in SAVE_LEVEL. PSAVE is a pointer
928 to a previously-created save area. If no save area has been allocated,
929 this function will allocate one. If a save area is specified, it
930 must be of the proper mode.
932 The insns are emitted after insn AFTER, if nonzero, otherwise the insns
933 are emitted at the current position. */
936 emit_stack_save (save_level, psave, after)
937 enum save_level save_level;
942 /* The default is that we use a move insn and save in a Pmode object. */
943 rtx (*fcn) PARAMS ((rtx, rtx)) = gen_move_insn;
944 enum machine_mode mode = STACK_SAVEAREA_MODE (save_level);
946 /* See if this machine has anything special to do for this kind of save. */
949 #ifdef HAVE_save_stack_block
951 if (HAVE_save_stack_block)
952 fcn = gen_save_stack_block;
955 #ifdef HAVE_save_stack_function
957 if (HAVE_save_stack_function)
958 fcn = gen_save_stack_function;
961 #ifdef HAVE_save_stack_nonlocal
963 if (HAVE_save_stack_nonlocal)
964 fcn = gen_save_stack_nonlocal;
971 /* If there is no save area and we have to allocate one, do so. Otherwise
972 verify the save area is the proper mode. */
976 if (mode != VOIDmode)
978 if (save_level == SAVE_NONLOCAL)
979 *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
981 *psave = sa = gen_reg_rtx (mode);
986 if (mode == VOIDmode || GET_MODE (sa) != mode)
995 /* We must validize inside the sequence, to ensure that any instructions
996 created by the validize call also get moved to the right place. */
998 sa = validize_mem (sa);
999 emit_insn (fcn (sa, stack_pointer_rtx));
1002 emit_insn_after (seq, after);
1007 sa = validize_mem (sa);
1008 emit_insn (fcn (sa, stack_pointer_rtx));
1012 /* Restore the stack pointer for the purpose in SAVE_LEVEL. SA is the save
1013 area made by emit_stack_save. If it is zero, we have nothing to do.
1015 Put any emitted insns after insn AFTER, if nonzero, otherwise at
1016 current position. */
1019 emit_stack_restore (save_level, sa, after)
1020 enum save_level save_level;
1024 /* The default is that we use a move insn. */
1025 rtx (*fcn) PARAMS ((rtx, rtx)) = gen_move_insn;
1027 /* See if this machine has anything special to do for this kind of save. */
1030 #ifdef HAVE_restore_stack_block
1032 if (HAVE_restore_stack_block)
1033 fcn = gen_restore_stack_block;
1036 #ifdef HAVE_restore_stack_function
1038 if (HAVE_restore_stack_function)
1039 fcn = gen_restore_stack_function;
1042 #ifdef HAVE_restore_stack_nonlocal
1044 if (HAVE_restore_stack_nonlocal)
1045 fcn = gen_restore_stack_nonlocal;
1054 sa = validize_mem (sa);
1055 /* These clobbers prevent the scheduler from moving
1056 references to variable arrays below the code
1057 that deletes (pops) the arrays. */
1058 emit_insn (gen_rtx_CLOBBER (VOIDmode,
1059 gen_rtx_MEM (BLKmode,
1060 gen_rtx_SCRATCH (VOIDmode))));
1061 emit_insn (gen_rtx_CLOBBER (VOIDmode,
1062 gen_rtx_MEM (BLKmode, stack_pointer_rtx)));
1070 emit_insn (fcn (stack_pointer_rtx, sa));
1073 emit_insn_after (seq, after);
1076 emit_insn (fcn (stack_pointer_rtx, sa));
1079 #ifdef SETJMP_VIA_SAVE_AREA
1080 /* Optimize RTL generated by allocate_dynamic_stack_space for targets
1081 where SETJMP_VIA_SAVE_AREA is true. The problem is that on these
1082 platforms, the dynamic stack space used can corrupt the original
1083 frame, thus causing a crash if a longjmp unwinds to it. */
1086 optimize_save_area_alloca (insns)
1091 for (insn = insns; insn; insn = NEXT_INSN(insn))
1095 if (GET_CODE (insn) != INSN)
1098 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
1100 if (REG_NOTE_KIND (note) != REG_SAVE_AREA)
1103 if (!current_function_calls_setjmp)
1105 rtx pat = PATTERN (insn);
1107 /* If we do not see the note in a pattern matching
1108 these precise characteristics, we did something
1109 entirely wrong in allocate_dynamic_stack_space.
1111 Note, one way this could happen is if SETJMP_VIA_SAVE_AREA
1112 was defined on a machine where stacks grow towards higher
1115 Right now only supported port with stack that grow upward
1116 is the HPPA and it does not define SETJMP_VIA_SAVE_AREA. */
1117 if (GET_CODE (pat) != SET
1118 || SET_DEST (pat) != stack_pointer_rtx
1119 || GET_CODE (SET_SRC (pat)) != MINUS
1120 || XEXP (SET_SRC (pat), 0) != stack_pointer_rtx)
1123 /* This will now be transformed into a (set REG REG)
1124 so we can just blow away all the other notes. */
1125 XEXP (SET_SRC (pat), 1) = XEXP (note, 0);
1126 REG_NOTES (insn) = NULL_RTX;
1130 /* setjmp was called, we must remove the REG_SAVE_AREA
1131 note so that later passes do not get confused by its
1133 if (note == REG_NOTES (insn))
1135 REG_NOTES (insn) = XEXP (note, 1);
1141 for (srch = REG_NOTES (insn); srch; srch = XEXP (srch, 1))
1142 if (XEXP (srch, 1) == note)
1145 if (srch == NULL_RTX)
1148 XEXP (srch, 1) = XEXP (note, 1);
1151 /* Once we've seen the note of interest, we need not look at
1152 the rest of them. */
1157 #endif /* SETJMP_VIA_SAVE_AREA */
1159 /* Return an rtx representing the address of an area of memory dynamically
1160 pushed on the stack. This region of memory is always aligned to
1161 a multiple of BIGGEST_ALIGNMENT.
1163 Any required stack pointer alignment is preserved.
1165 SIZE is an rtx representing the size of the area.
1166 TARGET is a place in which the address can be placed.
1168 KNOWN_ALIGN is the alignment (in bits) that we know SIZE has. */
1171 allocate_dynamic_stack_space (size, target, known_align)
1176 #ifdef SETJMP_VIA_SAVE_AREA
1177 rtx setjmpless_size = NULL_RTX;
1180 /* If we're asking for zero bytes, it doesn't matter what we point
1181 to since we can't dereference it. But return a reasonable
1183 if (size == const0_rtx)
1184 return virtual_stack_dynamic_rtx;
1186 /* Otherwise, show we're calling alloca or equivalent. */
1187 current_function_calls_alloca = 1;
1189 /* Ensure the size is in the proper mode. */
1190 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1191 size = convert_to_mode (Pmode, size, 1);
1193 /* We can't attempt to minimize alignment necessary, because we don't
1194 know the final value of preferred_stack_boundary yet while executing
1196 cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
1198 /* We will need to ensure that the address we return is aligned to
1199 BIGGEST_ALIGNMENT. If STACK_DYNAMIC_OFFSET is defined, we don't
1200 always know its final value at this point in the compilation (it
1201 might depend on the size of the outgoing parameter lists, for
1202 example), so we must align the value to be returned in that case.
1203 (Note that STACK_DYNAMIC_OFFSET will have a default nonzero value if
1204 STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined).
1205 We must also do an alignment operation on the returned value if
1206 the stack pointer alignment is less strict that BIGGEST_ALIGNMENT.
1208 If we have to align, we must leave space in SIZE for the hole
1209 that might result from the alignment operation. */
1211 #if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET)
1212 #define MUST_ALIGN 1
1214 #define MUST_ALIGN (PREFERRED_STACK_BOUNDARY < BIGGEST_ALIGNMENT)
1219 = force_operand (plus_constant (size,
1220 BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1223 #ifdef SETJMP_VIA_SAVE_AREA
1224 /* If setjmp restores regs from a save area in the stack frame,
1225 avoid clobbering the reg save area. Note that the offset of
1226 virtual_incoming_args_rtx includes the preallocated stack args space.
1227 It would be no problem to clobber that, but it's on the wrong side
1228 of the old save area. */
1231 = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx,
1232 stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN);
1234 if (!current_function_calls_setjmp)
1236 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1238 /* See optimize_save_area_alloca to understand what is being
1241 /* ??? Code below assumes that the save area needs maximal
1242 alignment. This constraint may be too strong. */
1243 if (PREFERRED_STACK_BOUNDARY != BIGGEST_ALIGNMENT)
1246 if (GET_CODE (size) == CONST_INT)
1248 HOST_WIDE_INT new = INTVAL (size) / align * align;
1250 if (INTVAL (size) != new)
1251 setjmpless_size = GEN_INT (new);
1253 setjmpless_size = size;
1257 /* Since we know overflow is not possible, we avoid using
1258 CEIL_DIV_EXPR and use TRUNC_DIV_EXPR instead. */
1259 setjmpless_size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size,
1260 GEN_INT (align), NULL_RTX, 1);
1261 setjmpless_size = expand_mult (Pmode, setjmpless_size,
1262 GEN_INT (align), NULL_RTX, 1);
1264 /* Our optimization works based upon being able to perform a simple
1265 transformation of this RTL into a (set REG REG) so make sure things
1266 did in fact end up in a REG. */
1267 if (!register_operand (setjmpless_size, Pmode))
1268 setjmpless_size = force_reg (Pmode, setjmpless_size);
1271 size = expand_binop (Pmode, add_optab, size, dynamic_offset,
1272 NULL_RTX, 1, OPTAB_LIB_WIDEN);
1274 #endif /* SETJMP_VIA_SAVE_AREA */
1276 /* Round the size to a multiple of the required stack alignment.
1277 Since the stack if presumed to be rounded before this allocation,
1278 this will maintain the required alignment.
1280 If the stack grows downward, we could save an insn by subtracting
1281 SIZE from the stack pointer and then aligning the stack pointer.
1282 The problem with this is that the stack pointer may be unaligned
1283 between the execution of the subtraction and alignment insns and
1284 some machines do not allow this. Even on those that do, some
1285 signal handlers malfunction if a signal should occur between those
1286 insns. Since this is an extremely rare event, we have no reliable
1287 way of knowing which systems have this problem. So we avoid even
1288 momentarily mis-aligning the stack. */
1290 /* If we added a variable amount to SIZE,
1291 we can no longer assume it is aligned. */
1292 #if !defined (SETJMP_VIA_SAVE_AREA)
1293 if (MUST_ALIGN || known_align % PREFERRED_STACK_BOUNDARY != 0)
1295 size = round_push (size);
1297 do_pending_stack_adjust ();
1299 /* We ought to be called always on the toplevel and stack ought to be aligned
1301 if (stack_pointer_delta % (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT))
1304 /* If needed, check that we have the required amount of stack. Take into
1305 account what has already been checked. */
1306 if (flag_stack_check && ! STACK_CHECK_BUILTIN)
1307 probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size);
1309 /* Don't use a TARGET that isn't a pseudo or is the wrong mode. */
1310 if (target == 0 || GET_CODE (target) != REG
1311 || REGNO (target) < FIRST_PSEUDO_REGISTER
1312 || GET_MODE (target) != Pmode)
1313 target = gen_reg_rtx (Pmode);
1315 mark_reg_pointer (target, known_align);
1317 /* Perform the required allocation from the stack. Some systems do
1318 this differently than simply incrementing/decrementing from the
1319 stack pointer, such as acquiring the space by calling malloc(). */
1320 #ifdef HAVE_allocate_stack
1321 if (HAVE_allocate_stack)
1323 enum machine_mode mode = STACK_SIZE_MODE;
1324 insn_operand_predicate_fn pred;
1326 /* We don't have to check against the predicate for operand 0 since
1327 TARGET is known to be a pseudo of the proper mode, which must
1328 be valid for the operand. For operand 1, convert to the
1329 proper mode and validate. */
1330 if (mode == VOIDmode)
1331 mode = insn_data[(int) CODE_FOR_allocate_stack].operand[1].mode;
1333 pred = insn_data[(int) CODE_FOR_allocate_stack].operand[1].predicate;
1334 if (pred && ! ((*pred) (size, mode)))
1335 size = copy_to_mode_reg (mode, convert_to_mode (mode, size, 1));
1337 emit_insn (gen_allocate_stack (target, size));
1342 #ifndef STACK_GROWS_DOWNWARD
1343 emit_move_insn (target, virtual_stack_dynamic_rtx);
1346 /* Check stack bounds if necessary. */
1347 if (current_function_limit_stack)
1350 rtx space_available = gen_label_rtx ();
1351 #ifdef STACK_GROWS_DOWNWARD
1352 available = expand_binop (Pmode, sub_optab,
1353 stack_pointer_rtx, stack_limit_rtx,
1354 NULL_RTX, 1, OPTAB_WIDEN);
1356 available = expand_binop (Pmode, sub_optab,
1357 stack_limit_rtx, stack_pointer_rtx,
1358 NULL_RTX, 1, OPTAB_WIDEN);
1360 emit_cmp_and_jump_insns (available, size, GEU, NULL_RTX, Pmode, 1,
1364 emit_insn (gen_trap ());
1367 error ("stack limits not supported on this target");
1369 emit_label (space_available);
1372 anti_adjust_stack (size);
1373 #ifdef SETJMP_VIA_SAVE_AREA
1374 if (setjmpless_size != NULL_RTX)
1376 rtx note_target = get_last_insn ();
1378 REG_NOTES (note_target)
1379 = gen_rtx_EXPR_LIST (REG_SAVE_AREA, setjmpless_size,
1380 REG_NOTES (note_target));
1382 #endif /* SETJMP_VIA_SAVE_AREA */
1384 #ifdef STACK_GROWS_DOWNWARD
1385 emit_move_insn (target, virtual_stack_dynamic_rtx);
1391 /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
1392 but we know it can't. So add ourselves and then do
1394 target = expand_binop (Pmode, add_optab, target,
1395 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1396 NULL_RTX, 1, OPTAB_LIB_WIDEN);
1397 target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target,
1398 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1400 target = expand_mult (Pmode, target,
1401 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1405 /* Record the new stack level for nonlocal gotos. */
1406 if (nonlocal_goto_handler_slots != 0)
1407 emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
1412 /* A front end may want to override GCC's stack checking by providing a
1413 run-time routine to call to check the stack, so provide a mechanism for
1414 calling that routine. */
1416 static GTY(()) rtx stack_check_libfunc;
1419 set_stack_check_libfunc (libfunc)
1422 stack_check_libfunc = libfunc;
1425 /* Emit one stack probe at ADDRESS, an address within the stack. */
1428 emit_stack_probe (address)
1431 rtx memref = gen_rtx_MEM (word_mode, address);
1433 MEM_VOLATILE_P (memref) = 1;
1435 if (STACK_CHECK_PROBE_LOAD)
1436 emit_move_insn (gen_reg_rtx (word_mode), memref);
1438 emit_move_insn (memref, const0_rtx);
1441 /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
1442 FIRST is a constant and size is a Pmode RTX. These are offsets from the
1443 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or
1444 subtract from the stack. If SIZE is constant, this is done
1445 with a fixed number of probes. Otherwise, we must make a loop. */
1447 #ifdef STACK_GROWS_DOWNWARD
1448 #define STACK_GROW_OP MINUS
1450 #define STACK_GROW_OP PLUS
1454 probe_stack_range (first, size)
1455 HOST_WIDE_INT first;
1458 /* First ensure SIZE is Pmode. */
1459 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1460 size = convert_to_mode (Pmode, size, 1);
1462 /* Next see if the front end has set up a function for us to call to
1464 if (stack_check_libfunc != 0)
1466 rtx addr = memory_address (QImode,
1467 gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1469 plus_constant (size, first)));
1471 #ifdef POINTERS_EXTEND_UNSIGNED
1472 if (GET_MODE (addr) != ptr_mode)
1473 addr = convert_memory_address (ptr_mode, addr);
1476 emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr,
1480 /* Next see if we have an insn to check the stack. Use it if so. */
1481 #ifdef HAVE_check_stack
1482 else if (HAVE_check_stack)
1484 insn_operand_predicate_fn pred;
1486 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1488 plus_constant (size, first)),
1491 pred = insn_data[(int) CODE_FOR_check_stack].operand[0].predicate;
1492 if (pred && ! ((*pred) (last_addr, Pmode)))
1493 last_addr = copy_to_mode_reg (Pmode, last_addr);
1495 emit_insn (gen_check_stack (last_addr));
1499 /* If we have to generate explicit probes, see if we have a constant
1500 small number of them to generate. If so, that's the easy case. */
1501 else if (GET_CODE (size) == CONST_INT
1502 && INTVAL (size) < 10 * STACK_CHECK_PROBE_INTERVAL)
1504 HOST_WIDE_INT offset;
1506 /* Start probing at FIRST + N * STACK_CHECK_PROBE_INTERVAL
1507 for values of N from 1 until it exceeds LAST. If only one
1508 probe is needed, this will not generate any code. Then probe
1510 for (offset = first + STACK_CHECK_PROBE_INTERVAL;
1511 offset < INTVAL (size);
1512 offset = offset + STACK_CHECK_PROBE_INTERVAL)
1513 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1517 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1519 plus_constant (size, first)));
1522 /* In the variable case, do the same as above, but in a loop. We emit loop
1523 notes so that loop optimization can be done. */
1527 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1529 GEN_INT (first + STACK_CHECK_PROBE_INTERVAL)),
1532 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1534 plus_constant (size, first)),
1536 rtx incr = GEN_INT (STACK_CHECK_PROBE_INTERVAL);
1537 rtx loop_lab = gen_label_rtx ();
1538 rtx test_lab = gen_label_rtx ();
1539 rtx end_lab = gen_label_rtx ();
1542 if (GET_CODE (test_addr) != REG
1543 || REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
1544 test_addr = force_reg (Pmode, test_addr);
1546 emit_note (NOTE_INSN_LOOP_BEG);
1547 emit_jump (test_lab);
1549 emit_label (loop_lab);
1550 emit_stack_probe (test_addr);
1552 emit_note (NOTE_INSN_LOOP_CONT);
1554 #ifdef STACK_GROWS_DOWNWARD
1555 #define CMP_OPCODE GTU
1556 temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr,
1559 #define CMP_OPCODE LTU
1560 temp = expand_binop (Pmode, add_optab, test_addr, incr, test_addr,
1564 if (temp != test_addr)
1567 emit_label (test_lab);
1568 emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
1569 NULL_RTX, Pmode, 1, loop_lab);
1570 emit_jump (end_lab);
1571 emit_note (NOTE_INSN_LOOP_END);
1572 emit_label (end_lab);
1574 emit_stack_probe (last_addr);
1578 /* Return an rtx representing the register or memory location
1579 in which a scalar value of data type VALTYPE
1580 was returned by a function call to function FUNC.
1581 FUNC is a FUNCTION_DECL node if the precise function is known,
1583 OUTGOING is 1 if on a machine with register windows this function
1584 should return the register in which the function will put its result
1588 hard_function_value (valtype, func, outgoing)
1590 tree func ATTRIBUTE_UNUSED;
1591 int outgoing ATTRIBUTE_UNUSED;
1595 #ifdef FUNCTION_OUTGOING_VALUE
1597 val = FUNCTION_OUTGOING_VALUE (valtype, func);
1600 val = FUNCTION_VALUE (valtype, func);
1602 if (GET_CODE (val) == REG
1603 && GET_MODE (val) == BLKmode)
1605 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype);
1606 enum machine_mode tmpmode;
1608 /* int_size_in_bytes can return -1. We don't need a check here
1609 since the value of bytes will be large enough that no mode
1610 will match and we will abort later in this function. */
1612 for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1613 tmpmode != VOIDmode;
1614 tmpmode = GET_MODE_WIDER_MODE (tmpmode))
1616 /* Have we found a large enough mode? */
1617 if (GET_MODE_SIZE (tmpmode) >= bytes)
1621 /* No suitable mode found. */
1622 if (tmpmode == VOIDmode)
1625 PUT_MODE (val, tmpmode);
1630 /* Return an rtx representing the register or memory location
1631 in which a scalar value of mode MODE was returned by a library call. */
1634 hard_libcall_value (mode)
1635 enum machine_mode mode;
1637 return LIBCALL_VALUE (mode);
1640 /* Look up the tree code for a given rtx code
1641 to provide the arithmetic operation for REAL_ARITHMETIC.
1642 The function returns an int because the caller may not know
1643 what `enum tree_code' means. */
1646 rtx_to_tree_code (code)
1649 enum tree_code tcode;
1672 tcode = LAST_AND_UNUSED_TREE_CODE;
1675 return ((int) tcode);
1678 #include "gt-explow.h"