/* Subroutines for manipulating rtx's in semantically interesting ways.
Copyright (C) 1987, 1991, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
-GNU CC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
#include "config.h"
#include "flags.h"
#include "function.h"
#include "expr.h"
+#include "optabs.h"
#include "hard-reg-set.h"
#include "insn-config.h"
+#include "ggc.h"
#include "recog.h"
-#include "insn-flags.h"
-#include "insn-codes.h"
-
-#if !defined PREFERRED_STACK_BOUNDARY && defined STACK_BOUNDARY
-#define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
-#endif
static rtx break_out_memory_refs PARAMS ((rtx));
static void emit_stack_probe PARAMS ((rtx));
{
int width = GET_MODE_BITSIZE (mode);
- /* We clear out all bits that don't belong in MODE, unless they and our
- sign bit are all one. So we get either a reasonable negative
- value or a reasonable unsigned value. */
-
- if (width < HOST_BITS_PER_WIDE_INT
- && ((c & ((HOST_WIDE_INT) (-1) << (width - 1)))
- != ((HOST_WIDE_INT) (-1) << (width - 1))))
- c &= ((HOST_WIDE_INT) 1 << width) - 1;
-
- /* If this would be an entire word for the target, but is not for
- the host, then sign-extend on the host so that the number will look
- the same way on the host that it would on the target.
+ /* Canonicalize BImode to 0 and STORE_FLAG_VALUE. */
+ if (mode == BImode)
+ return c & 1 ? STORE_FLAG_VALUE : 0;
- For example, when building a 64 bit alpha hosted 32 bit sparc
- targeted compiler, then we want the 32 bit unsigned value -1 to be
- represented as a 64 bit value -1, and not as 0x00000000ffffffff.
- The later confuses the sparc backend. */
+ /* Sign-extend for the requested mode. */
- if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT
- && BITS_PER_WORD == width
- && (c & ((HOST_WIDE_INT) 1 << (width - 1))))
- c |= ((HOST_WIDE_INT) (-1) << width);
+ if (width < HOST_BITS_PER_WIDE_INT)
+ {
+ HOST_WIDE_INT sign = 1;
+ sign <<= width - 1;
+ c &= (sign << 1) - 1;
+ c ^= sign;
+ c -= sign;
+ }
return c;
}
rtx
plus_constant_wide (x, c)
- register rtx x;
- register HOST_WIDE_INT c;
+ rtx x;
+ HOST_WIDE_INT c;
{
- register RTX_CODE code;
- register enum machine_mode mode;
- register rtx tem;
+ RTX_CODE code;
+ rtx y;
+ enum machine_mode mode;
+ rtx tem;
int all_constant = 0;
if (c == 0)
code = GET_CODE (x);
mode = GET_MODE (x);
+ y = x;
+
switch (code)
{
case CONST_INT:
case CONST_DOUBLE:
{
- HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
+ unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
- HOST_WIDE_INT l2 = c;
+ unsigned HOST_WIDE_INT l2 = c;
HOST_WIDE_INT h2 = c < 0 ? ~0 : 0;
- HOST_WIDE_INT lv, hv;
+ unsigned HOST_WIDE_INT lv;
+ HOST_WIDE_INT hv;
add_double (l1, h1, l2, h2, &lv, &hv);
if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
{
- /* Any rtl we create here must go in a saveable obstack, since
- we might have been called from within combine. */
- push_obstacks_nochange ();
- rtl_in_saveable_obstack ();
tem
= force_const_mem (GET_MODE (x),
plus_constant (get_pool_constant (XEXP (x, 0)),
c));
- pop_obstacks ();
if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
return tem;
}
Look for constant term in the sum and combine
with C. For an integer constant term, we make a combined
integer. For a constant term that is not an explicit integer,
- we cannot really combine, but group them together anyway.
+ we cannot really combine, but group them together anyway.
Restart or use a recursive call in case the remaining operand is
something that we handle specially, such as a SYMBOL_REF.
x = XEXP (x, 0);
goto restart;
}
- else if (CONSTANT_P (XEXP (x, 0)))
+ else if (CONSTANT_P (XEXP (x, 1)))
{
- x = gen_rtx_PLUS (mode,
- plus_constant (XEXP (x, 0), c),
- XEXP (x, 1));
+ x = gen_rtx_PLUS (mode, XEXP (x, 0), plus_constant (XEXP (x, 1), c));
c = 0;
}
- else if (CONSTANT_P (XEXP (x, 1)))
+ else if (find_constant_term_loc (&y))
{
- x = gen_rtx_PLUS (mode,
- XEXP (x, 0),
- plus_constant (XEXP (x, 1), c));
+ /* We need to be careful since X may be shared and we can't
+ modify it in place. */
+ rtx copy = copy_rtx (x);
+ rtx *const_loc = find_constant_term_loc (©);
+
+ *const_loc = plus_constant (*const_loc, c);
+ x = copy;
c = 0;
}
break;
-
+
default:
break;
}
else
return x;
}
-
-/* This is the same as `plus_constant', except that it handles LO_SUM.
-
- This function should be used via the `plus_constant_for_output' macro. */
-
-rtx
-plus_constant_for_output_wide (x, c)
- register rtx x;
- register HOST_WIDE_INT c;
-{
- register enum machine_mode mode = GET_MODE (x);
-
- if (GET_CODE (x) == LO_SUM)
- return gen_rtx_LO_SUM (mode, XEXP (x, 0),
- plus_constant_for_output (XEXP (x, 1), c));
-
- else
- return plus_constant (x, c);
-}
\f
/* If X is a sum, return a new sum like X but lacking any constant terms.
Add all the removed constant terms into *CONSTPTR.
rtx x;
rtx *constptr;
{
- register rtx x0, x1;
+ rtx x0, x1;
rtx tem;
if (GET_CODE (x) != PLUS)
return insn;
if (GET_CODE (insn) == JUMP_INSN)
{
- if (simplejump_p (insn))
+ if (any_uncondjump_p (insn))
next = JUMP_LABEL (insn);
else
return 0;
expr_size (exp)
tree exp;
{
- tree size = size_in_bytes (TREE_TYPE (exp));
+ tree size;
+
+ if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
+ && DECL_SIZE_UNIT (exp) != 0)
+ size = DECL_SIZE_UNIT (exp);
+ else
+ size = size_in_bytes (TREE_TYPE (exp));
if (TREE_CODE (size) != INTEGER_CST
&& contains_placeholder_p (size))
size = build (WITH_RECORD_EXPR, sizetype, size, exp);
- return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype),
- EXPAND_MEMORY_USE_BAD);
+ return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), 0);
+
}
\f
/* Return a copy of X in which all memory references
static rtx
break_out_memory_refs (x)
- register rtx x;
+ rtx x;
{
if (GET_CODE (x) == MEM
|| (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
|| GET_CODE (x) == MULT)
{
- register rtx op0 = break_out_memory_refs (XEXP (x, 0));
- register rtx op1 = break_out_memory_refs (XEXP (x, 1));
+ rtx op0 = break_out_memory_refs (XEXP (x, 0));
+ rtx op1 = break_out_memory_refs (XEXP (x, 1));
if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
case CONST_DOUBLE:
return x;
+ case SUBREG:
+ if (POINTERS_EXTEND_UNSIGNED >= 0
+ && (SUBREG_PROMOTED_VAR_P (x) || REG_POINTER (SUBREG_REG (x)))
+ && GET_MODE (SUBREG_REG (x)) == to_mode)
+ return SUBREG_REG (x);
+ break;
+
case LABEL_REF:
- temp = gen_rtx_LABEL_REF (to_mode, XEXP (x, 0));
- LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
- return temp;
+ if (POINTERS_EXTEND_UNSIGNED >= 0)
+ {
+ temp = gen_rtx_LABEL_REF (to_mode, XEXP (x, 0));
+ LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
+ return temp;
+ }
+ break;
case SYMBOL_REF:
- temp = gen_rtx_SYMBOL_REF (to_mode, XSTR (x, 0));
- SYMBOL_REF_FLAG (temp) = SYMBOL_REF_FLAG (x);
- CONSTANT_POOL_ADDRESS_P (temp) = CONSTANT_POOL_ADDRESS_P (x);
- return temp;
+ if (POINTERS_EXTEND_UNSIGNED >= 0)
+ {
+ temp = gen_rtx_SYMBOL_REF (to_mode, XSTR (x, 0));
+ SYMBOL_REF_FLAG (temp) = SYMBOL_REF_FLAG (x);
+ CONSTANT_POOL_ADDRESS_P (temp) = CONSTANT_POOL_ADDRESS_P (x);
+ STRING_POOL_ADDRESS_P (temp) = STRING_POOL_ADDRESS_P (x);
+ return temp;
+ }
+ break;
case CONST:
- return gen_rtx_CONST (to_mode,
- convert_memory_address (to_mode, XEXP (x, 0)));
+ if (POINTERS_EXTEND_UNSIGNED >= 0)
+ return gen_rtx_CONST (to_mode,
+ convert_memory_address (to_mode, XEXP (x, 0)));
+ break;
case PLUS:
case MULT:
permute the conversion and addition operation. We can always safely
permute them if we are making the address narrower. In addition,
always permute the operations if this is a constant. */
- if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
- || (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT
- && (INTVAL (XEXP (x, 1)) + 20000 < 40000
- || CONSTANT_P (XEXP (x, 0)))))
- return gen_rtx_fmt_ee (GET_CODE (x), to_mode,
+ if (POINTERS_EXTEND_UNSIGNED >= 0
+ && (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
+ || (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT
+ && (INTVAL (XEXP (x, 1)) + 20000 < 40000
+ || CONSTANT_P (XEXP (x, 0))))))
+ return gen_rtx_fmt_ee (GET_CODE (x), to_mode,
convert_memory_address (to_mode, XEXP (x, 0)),
convert_memory_address (to_mode, XEXP (x, 1)));
break;
-
+
default:
break;
}
rtx
copy_all_regs (x)
- register rtx x;
+ rtx x;
{
if (GET_CODE (x) == REG)
{
else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
|| GET_CODE (x) == MULT)
{
- register rtx op0 = copy_all_regs (XEXP (x, 0));
- register rtx op1 = copy_all_regs (XEXP (x, 1));
+ rtx op0 = copy_all_regs (XEXP (x, 0));
+ rtx op1 = copy_all_regs (XEXP (x, 1));
if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
}
rtx
memory_address (mode, x)
enum machine_mode mode;
- register rtx x;
+ rtx x;
{
- register rtx oldx = x;
+ rtx oldx = x;
if (GET_CODE (x) == ADDRESSOF)
return x;
#ifdef POINTERS_EXTEND_UNSIGNED
- if (GET_MODE (x) == ptr_mode)
+ if (GET_MODE (x) != Pmode)
x = convert_memory_address (Pmode, x);
#endif
{
if (GET_CODE (ref) != MEM)
return ref;
- if (memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
+ if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0)))
+ && memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
return ref;
+
/* Don't alter REF itself, since that is probably a stack slot. */
- return change_address (ref, GET_MODE (ref), XEXP (ref, 0));
+ return replace_equiv_address (ref, XEXP (ref, 0));
+}
+\f
+/* Given REF, either a MEM or a REG, and T, either the type of X or
+ the expression corresponding to REF, set RTX_UNCHANGING_P if
+ appropriate. */
+
+void
+maybe_set_unchanging (ref, t)
+ rtx ref;
+ tree t;
+{
+ /* We can set RTX_UNCHANGING_P from TREE_READONLY for decls whose
+ initialization is only executed once, or whose initializer always
+ has the same value. Currently we simplify this to PARM_DECLs in the
+ first case, and decls with TREE_CONSTANT initializers in the second. */
+ if ((TREE_READONLY (t) && DECL_P (t)
+ && (TREE_CODE (t) == PARM_DECL
+ || DECL_INITIAL (t) == NULL_TREE
+ || TREE_CONSTANT (DECL_INITIAL (t))))
+ || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
+ RTX_UNCHANGING_P (ref) = 1;
}
\f
/* Return a modified copy of X with its memory address copied
stabilize (x)
rtx x;
{
- register rtx addr;
- if (GET_CODE (x) != MEM)
- return x;
- addr = XEXP (x, 0);
- if (rtx_unstable_p (addr))
- {
- rtx temp = copy_all_regs (addr);
- rtx mem;
- if (GET_CODE (temp) != REG)
- temp = copy_to_reg (temp);
- mem = gen_rtx_MEM (GET_MODE (x), temp);
-
- /* Mark returned memref with in_struct if it's in an array or
- structure. Copy everything else from original memref. */
-
- MEM_COPY_ATTRIBUTES (mem, x);
- if (GET_CODE (addr) == PLUS)
- MEM_SET_IN_STRUCT_P (mem, 1);
+ if (GET_CODE (x) != MEM
+ || ! rtx_unstable_p (XEXP (x, 0)))
+ return x;
- return mem;
- }
- return x;
+ return
+ replace_equiv_address (x, force_reg (Pmode, copy_all_regs (XEXP (x, 0))));
}
\f
/* Copy the value or contents of X to a new temp reg and return that reg. */
copy_to_reg (x)
rtx x;
{
- register rtx temp = gen_reg_rtx (GET_MODE (x));
-
+ rtx temp = gen_reg_rtx (GET_MODE (x));
+
/* If not an operand, must be an address with PLUS and MULT so
- do the computation. */
+ do the computation. */
if (! general_operand (x, VOIDmode))
x = force_operand (x, temp);
-
+
if (x != temp)
emit_move_insn (temp, x);
enum machine_mode mode;
rtx x;
{
- register rtx temp = gen_reg_rtx (mode);
-
+ rtx temp = gen_reg_rtx (mode);
+
/* If not an operand, must be an address with PLUS and MULT so
- do the computation. */
+ do the computation. */
if (! general_operand (x, VOIDmode))
x = force_operand (x, temp);
enum machine_mode mode;
rtx x;
{
- register rtx temp, insn, set;
+ rtx temp, insn, set;
if (GET_CODE (x) == REG)
return x;
-
- temp = gen_reg_rtx (mode);
-
- if (! general_operand (x, mode))
- x = force_operand (x, NULL_RTX);
-
- insn = emit_move_insn (temp, x);
+
+ if (general_operand (x, mode))
+ {
+ temp = gen_reg_rtx (mode);
+ insn = emit_move_insn (temp, x);
+ }
+ else
+ {
+ temp = force_operand (x, NULL_RTX);
+ if (GET_CODE (temp) == REG)
+ insn = get_last_insn ();
+ else
+ {
+ rtx temp2 = gen_reg_rtx (mode);
+ insn = emit_move_insn (temp2, temp);
+ temp = temp2;
+ }
+ }
/* Let optimizers know that TEMP's value never changes
and that X can be substituted for it. Don't get confused
if (CONSTANT_P (x)
&& (set = single_set (insn)) != 0
&& SET_DEST (set) == temp)
- {
- rtx note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
+ set_unique_reg_note (insn, REG_EQUAL, x);
- if (note)
- XEXP (note, 0) = x;
- else
- REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, x, REG_NOTES (insn));
- }
return temp;
}
force_not_mem (x)
rtx x;
{
- register rtx temp;
+ rtx temp;
+
if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
return x;
+
temp = gen_reg_rtx (GET_MODE (x));
emit_move_insn (temp, x);
return temp;
rtx x, target;
enum machine_mode mode;
{
- register rtx temp;
+ rtx temp;
if (target && GET_CODE (target) == REG)
temp = target;
unsignedp = POINTERS_EXTEND_UNSIGNED;
break;
#endif
-
+
default:
break;
}
round_push (size)
rtx size;
{
-#ifdef PREFERRED_STACK_BOUNDARY
int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
if (align == 1)
return size;
NULL_RTX, 1);
size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
}
-#endif /* PREFERRED_STACK_BOUNDARY */
return size;
}
\f
}
/* Restore the stack pointer for the purpose in SAVE_LEVEL. SA is the save
- area made by emit_stack_save. If it is zero, we have nothing to do.
+ area made by emit_stack_save. If it is zero, we have nothing to do.
- Put any emitted insns after insn AFTER, if nonzero, otherwise at
+ Put any emitted insns after insn AFTER, if nonzero, otherwise at
current position. */
void
/* If we do not see the note in a pattern matching
these precise characteristics, we did something
- entirely wrong in allocate_dynamic_stack_space.
+ entirely wrong in allocate_dynamic_stack_space.
Note, one way this could happen is if SETJMP_VIA_SAVE_AREA
was defined on a machine where stacks grow towards higher
break;
if (srch == NULL_RTX)
- abort();
+ abort ();
XEXP (srch, 1) = XEXP (note, 1);
}
/* We can't attempt to minimize alignment necessary, because we don't
know the final value of preferred_stack_boundary yet while executing
this code. */
-#ifdef PREFERRED_STACK_BOUNDARY
cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
-#endif
/* We will need to ensure that the address we return is aligned to
BIGGEST_ALIGNMENT. If STACK_DYNAMIC_OFFSET is defined, we don't
- always know its final value at this point in the compilation (it
+ always know its final value at this point in the compilation (it
might depend on the size of the outgoing parameter lists, for
example), so we must align the value to be returned in that case.
(Note that STACK_DYNAMIC_OFFSET will have a default non-zero value if
If we have to align, we must leave space in SIZE for the hole
that might result from the alignment operation. */
-#if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET) || ! defined (PREFERRED_STACK_BOUNDARY)
+#if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET)
#define MUST_ALIGN 1
#else
#define MUST_ALIGN (PREFERRED_STACK_BOUNDARY < BIGGEST_ALIGNMENT)
#endif
if (MUST_ALIGN)
- {
- if (GET_CODE (size) == CONST_INT)
- size = GEN_INT (INTVAL (size)
- + (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1));
- else
- size = expand_binop (Pmode, add_optab, size,
- GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
- NULL_RTX, 1, OPTAB_LIB_WIDEN);
- }
+ size
+ = force_operand (plus_constant (size,
+ BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
+ NULL_RTX);
#ifdef SETJMP_VIA_SAVE_AREA
/* If setjmp restores regs from a save area in the stack frame,
/* See optimize_save_area_alloca to understand what is being
set up here. */
-#if !defined(PREFERRED_STACK_BOUNDARY) || !defined(MUST_ALIGN) || (PREFERRED_STACK_BOUNDARY != BIGGEST_ALIGNMENT)
- /* If anyone creates a target with these characteristics, let them
- know that our optimization cannot work correctly in such a case. */
- abort();
-#endif
+ /* ??? Code below assumes that the save area needs maximal
+ alignment. This constraint may be too strong. */
+ if (PREFERRED_STACK_BOUNDARY != BIGGEST_ALIGNMENT)
+ abort ();
if (GET_CODE (size) == CONST_INT)
{
- int new = INTVAL (size) / align * align;
+ HOST_WIDE_INT new = INTVAL (size) / align * align;
if (INTVAL (size) != new)
setjmpless_size = GEN_INT (new);
way of knowing which systems have this problem. So we avoid even
momentarily mis-aligning the stack. */
-#ifdef PREFERRED_STACK_BOUNDARY
/* If we added a variable amount to SIZE,
we can no longer assume it is aligned. */
#if !defined (SETJMP_VIA_SAVE_AREA)
if (MUST_ALIGN || known_align % PREFERRED_STACK_BOUNDARY != 0)
#endif
size = round_push (size);
-#endif
do_pending_stack_adjust ();
/* We ought to be called always on the toplevel and stack ought to be aligned
- propertly. */
-#ifdef PREFERRED_STACK_BOUNDARY
+ properly. */
if (stack_pointer_delta % (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT))
abort ();
-#endif
/* If needed, check that we have the required amount of stack. Take into
account what has already been checked. */
if (flag_stack_check && ! STACK_CHECK_BUILTIN)
probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size);
- /* Don't use a TARGET that isn't a pseudo. */
+ /* Don't use a TARGET that isn't a pseudo or is the wrong mode. */
if (target == 0 || GET_CODE (target) != REG
- || REGNO (target) < FIRST_PSEUDO_REGISTER)
+ || REGNO (target) < FIRST_PSEUDO_REGISTER
+ || GET_MODE (target) != Pmode)
target = gen_reg_rtx (Pmode);
mark_reg_pointer (target, known_align);
enum machine_mode mode = STACK_SIZE_MODE;
insn_operand_predicate_fn pred;
- pred = insn_data[(int) CODE_FOR_allocate_stack].operand[0].predicate;
- if (pred && ! ((*pred) (target, Pmode)))
-#ifdef POINTERS_EXTEND_UNSIGNED
- target = convert_memory_address (Pmode, target);
-#else
- target = copy_to_mode_reg (Pmode, target);
-#endif
-
+ /* We don't have to check against the predicate for operand 0 since
+ TARGET is known to be a pseudo of the proper mode, which must
+ be valid for the operand. For operand 1, convert to the
+ proper mode and validate. */
if (mode == VOIDmode)
- mode = Pmode;
+ mode = insn_data[(int) CODE_FOR_allocate_stack].operand[1].mode;
- size = convert_modes (mode, ptr_mode, size, 1);
pred = insn_data[(int) CODE_FOR_allocate_stack].operand[1].predicate;
if (pred && ! ((*pred) (size, mode)))
size = copy_to_mode_reg (mode, size);
#ifndef STACK_GROWS_DOWNWARD
emit_move_insn (target, virtual_stack_dynamic_rtx);
#endif
- size = convert_modes (Pmode, ptr_mode, size, 1);
/* Check stack bounds if necessary. */
if (current_function_limit_stack)
rtx available;
rtx space_available = gen_label_rtx ();
#ifdef STACK_GROWS_DOWNWARD
- available = expand_binop (Pmode, sub_optab,
+ available = expand_binop (Pmode, sub_optab,
stack_pointer_rtx, stack_limit_rtx,
NULL_RTX, 1, OPTAB_WIDEN);
#else
- available = expand_binop (Pmode, sub_optab,
+ available = expand_binop (Pmode, sub_optab,
stack_limit_rtx, stack_pointer_rtx,
NULL_RTX, 1, OPTAB_WIDEN);
#endif
emit_cmp_and_jump_insns (available, size, GEU, NULL_RTX, Pmode, 1,
- 0, space_available);
+ space_available);
#ifdef HAVE_trap
if (HAVE_trap)
emit_insn (gen_trap ());
REG_NOTES (note_target));
}
#endif /* SETJMP_VIA_SAVE_AREA */
+
#ifdef STACK_GROWS_DOWNWARD
- emit_move_insn (target, virtual_stack_dynamic_rtx);
+ emit_move_insn (target, virtual_stack_dynamic_rtx);
#endif
}
GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
NULL_RTX, 1);
}
-
+
/* Some systems require a particular insn to refer to the stack
to make the pages exist. */
#ifdef HAVE_probe
return target;
}
\f
-/* A front end may want to override GCC's stack checking by providing a
+/* A front end may want to override GCC's stack checking by providing a
run-time routine to call to check the stack, so provide a mechanism for
calling that routine. */
rtx libfunc;
{
stack_check_libfunc = libfunc;
+ ggc_add_rtx_root (&stack_check_libfunc, 1);
}
\f
/* Emit one stack probe at ADDRESS, an address within the stack. */
emit_move_insn (memref, const0_rtx);
}
-/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
+/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
FIRST is a constant and size is a Pmode RTX. These are offsets from the
current stack pointer. STACK_GROWS_DOWNWARD says whether to add or
subtract from the stack. If SIZE is constant, this is done
HOST_WIDE_INT first;
rtx size;
{
- /* First see if the front end has set up a function for us to call to
+ /* First ensure SIZE is Pmode. */
+ if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
+ size = convert_to_mode (Pmode, size, 1);
+
+ /* Next see if the front end has set up a function for us to call to
check the stack. */
if (stack_check_libfunc != 0)
- emit_library_call (stack_check_libfunc, 0, VOIDmode, 1,
- memory_address (QImode,
- gen_rtx (STACK_GROW_OP, Pmode,
- stack_pointer_rtx,
- plus_constant (size, first))),
- ptr_mode);
+ {
+ rtx addr = memory_address (QImode,
+ gen_rtx (STACK_GROW_OP, Pmode,
+ stack_pointer_rtx,
+ plus_constant (size, first)));
+
+#ifdef POINTERS_EXTEND_UNSIGNED
+ if (GET_MODE (addr) != ptr_mode)
+ addr = convert_memory_address (ptr_mode, addr);
+#endif
+
+ emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr,
+ ptr_mode);
+ }
/* Next see if we have an insn to check the stack. Use it if so. */
#ifdef HAVE_check_stack
|| REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
test_addr = force_reg (Pmode, test_addr);
- emit_note (NULL_PTR, NOTE_INSN_LOOP_BEG);
+ emit_note (NULL, NOTE_INSN_LOOP_BEG);
emit_jump (test_lab);
emit_label (loop_lab);
emit_stack_probe (test_addr);
- emit_note (NULL_PTR, NOTE_INSN_LOOP_CONT);
+ emit_note (NULL, NOTE_INSN_LOOP_CONT);
#ifdef STACK_GROWS_DOWNWARD
#define CMP_OPCODE GTU
emit_label (test_lab);
emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
- NULL_RTX, Pmode, 1, 0, loop_lab);
+ NULL_RTX, Pmode, 1, loop_lab);
emit_jump (end_lab);
- emit_note (NULL_PTR, NOTE_INSN_LOOP_END);
+ emit_note (NULL, NOTE_INSN_LOOP_END);
emit_label (end_lab);
emit_stack_probe (last_addr);
otherwise 0.
OUTGOING is 1 if on a machine with register windows this function
should return the register in which the function will put its result
- and 0 otherwise. */
+ and 0 otherwise. */
rtx
hard_function_value (valtype, func, outgoing)
unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype);
enum machine_mode tmpmode;
+ /* int_size_in_bytes can return -1. We don't need a check here
+ since the value of bytes will be large enough that no mode
+ will match and we will abort later in this function. */
+
for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
tmpmode != VOIDmode;
tmpmode = GET_MODE_WIDER_MODE (tmpmode))
abort ();
PUT_MODE (val, tmpmode);
- }
+ }
return val;
}
OSDN Git Service
