#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "toplev.h"
#include "rtl.h"
#include "tree.h"
#include "tm_p.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 "langhooks.h"
#include "target.h"
#include "output.h"
static rtx break_out_memory_refs (rtx);
static void emit_stack_probe (rtx);
HOST_WIDE_INT
trunc_int_for_mode (HOST_WIDE_INT c, enum machine_mode mode)
{
int width = GET_MODE_BITSIZE (mode);
gcc_assert (SCALAR_INT_MODE_P (mode));
if (mode == BImode)
return c & 1 ? STORE_FLAG_VALUE : 0;
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 (rtx x, HOST_WIDE_INT c)
{
RTX_CODE code;
rtx y;
enum machine_mode mode;
rtx tem;
int all_constant = 0;
if (c == 0)
return x;
restart:
code = GET_CODE (x);
mode = GET_MODE (x);
y = x;
switch (code)
{
case CONST_INT:
return GEN_INT (INTVAL (x) + c);
case CONST_DOUBLE:
{
unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
unsigned HOST_WIDE_INT l2 = c;
HOST_WIDE_INT h2 = c < 0 ? ~0 : 0;
unsigned HOST_WIDE_INT lv;
HOST_WIDE_INT hv;
add_double (l1, h1, l2, h2, &lv, &hv);
return immed_double_const (lv, hv, VOIDmode);
}
case MEM:
if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
{
tem
= force_const_mem (GET_MODE (x),
plus_constant (get_pool_constant (XEXP (x, 0)),
c));
if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
return tem;
}
break;
case CONST:
x = XEXP (x, 0);
all_constant = 1;
goto restart;
case SYMBOL_REF:
case LABEL_REF:
all_constant = 1;
break;
case PLUS:
if (GET_CODE (XEXP (x, 1)) == CONST_INT)
{
c += INTVAL (XEXP (x, 1));
if (GET_MODE (x) != VOIDmode)
c = trunc_int_for_mode (c, GET_MODE (x));
x = XEXP (x, 0);
goto restart;
}
else if (CONSTANT_P (XEXP (x, 1)))
{
x = gen_rtx_PLUS (mode, XEXP (x, 0), plus_constant (XEXP (x, 1), c));
c = 0;
}
else if (find_constant_term_loc (&y))
{
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;
}
if (c != 0)
x = gen_rtx_PLUS (mode, x, GEN_INT (c));
if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
return x;
else if (all_constant)
return gen_rtx_CONST (mode, x);
else
return x;
}
rtx
eliminate_constant_term (rtx x, rtx *constptr)
{
rtx x0, x1;
rtx tem;
if (GET_CODE (x) != PLUS)
return x;
if (GET_CODE (XEXP (x, 1)) == CONST_INT
&& 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
XEXP (x, 1)))
&& GET_CODE (tem) == CONST_INT)
{
*constptr = tem;
return eliminate_constant_term (XEXP (x, 0), constptr);
}
tem = const0_rtx;
x0 = eliminate_constant_term (XEXP (x, 0), &tem);
x1 = eliminate_constant_term (XEXP (x, 1), &tem);
if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0))
&& 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x),
*constptr, tem))
&& GET_CODE (tem) == CONST_INT)
{
*constptr = tem;
return gen_rtx_PLUS (GET_MODE (x), x0, x1);
}
return x;
}
rtx
expr_size (tree exp)
{
tree size;
if (TREE_CODE (exp) == WITH_SIZE_EXPR)
size = TREE_OPERAND (exp, 1);
else
size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (lang_hooks.expr_size (exp), exp);
return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), 0);
}
HOST_WIDE_INT
int_expr_size (tree exp)
{
tree size;
if (TREE_CODE (exp) == WITH_SIZE_EXPR)
size = TREE_OPERAND (exp, 1);
else
size = lang_hooks.expr_size (exp);
if (size == 0 || !host_integerp (size, 0))
return -1;
return tree_low_cst (size, 0);
}
static rtx
break_out_memory_refs (rtx x)
{
if (MEM_P (x)
|| (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
&& GET_MODE (x) != VOIDmode))
x = force_reg (GET_MODE (x), x);
else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
|| GET_CODE (x) == MULT)
{
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);
}
return x;
}
rtx
convert_memory_address (enum machine_mode to_mode ATTRIBUTE_UNUSED,
rtx x)
{
#ifndef POINTERS_EXTEND_UNSIGNED
gcc_assert (GET_MODE (x) == to_mode || GET_MODE (x) == VOIDmode);
return x;
#else
enum machine_mode from_mode;
rtx temp;
enum rtx_code code;
if (GET_MODE (x) == to_mode)
return x;
from_mode = to_mode == ptr_mode ? Pmode : ptr_mode;
switch (GET_CODE (x))
{
case CONST_INT:
case CONST_DOUBLE:
if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode))
code = TRUNCATE;
else if (POINTERS_EXTEND_UNSIGNED < 0)
break;
else if (POINTERS_EXTEND_UNSIGNED > 0)
code = ZERO_EXTEND;
else
code = SIGN_EXTEND;
temp = simplify_unary_operation (code, to_mode, x, from_mode);
if (temp)
return temp;
break;
case SUBREG:
if ((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;
break;
case SYMBOL_REF:
temp = shallow_copy_rtx (x);
PUT_MODE (temp, to_mode);
return temp;
break;
case CONST:
return gen_rtx_CONST (to_mode,
convert_memory_address (to_mode, XEXP (x, 0)));
break;
case PLUS:
case MULT:
if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
|| (GET_CODE (x) == PLUS
&& GET_CODE (XEXP (x, 1)) == CONST_INT
&& XEXP (x, 1) == convert_memory_address (to_mode, XEXP (x, 1))))
return gen_rtx_fmt_ee (GET_CODE (x), to_mode,
convert_memory_address (to_mode, XEXP (x, 0)),
XEXP (x, 1));
break;
default:
break;
}
return convert_modes (to_mode, from_mode,
x, POINTERS_EXTEND_UNSIGNED);
#endif
}
rtx
memory_address (enum machine_mode mode, rtx x)
{
rtx oldx = x;
x = convert_memory_address (Pmode, x);
if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
x = force_reg (Pmode, x);
else
{
if (! cse_not_expected && !REG_P (x))
x = break_out_memory_refs (x);
if (memory_address_p (mode, x))
goto win;
if (memory_address_p (mode, oldx))
goto win2;
LEGITIMIZE_ADDRESS (x, oldx, mode, win);
if (GET_CODE (x) == PLUS)
{
rtx constant_term = const0_rtx;
rtx y = eliminate_constant_term (x, &constant_term);
if (constant_term == const0_rtx
|| ! memory_address_p (mode, y))
x = force_operand (x, NULL_RTX);
else
{
y = gen_rtx_PLUS (GET_MODE (x), copy_to_reg (y), constant_term);
if (! memory_address_p (mode, y))
x = force_operand (x, NULL_RTX);
else
x = y;
}
}
else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS)
x = force_operand (x, NULL_RTX);
else if (REG_P (x))
x = copy_to_reg (x);
else
x = force_reg (Pmode, x);
goto done;
win2:
x = oldx;
win:
if (flag_force_addr && ! cse_not_expected && !REG_P (x))
{
x = force_operand (x, NULL_RTX);
x = force_reg (Pmode, x);
}
}
done:
if (oldx == x)
return x;
else if (REG_P (x))
mark_reg_pointer (x, BITS_PER_UNIT);
else if (GET_CODE (x) == PLUS
&& REG_P (XEXP (x, 0))
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT);
update_temp_slot_address (oldx, x);
return x;
}
rtx
memory_address_noforce (enum machine_mode mode, rtx x)
{
int ambient_force_addr = flag_force_addr;
rtx val;
flag_force_addr = 0;
val = memory_address (mode, x);
flag_force_addr = ambient_force_addr;
return val;
}
rtx
validize_mem (rtx ref)
{
if (!MEM_P (ref))
return ref;
ref = use_anchored_address (ref);
if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0)))
&& memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
return ref;
return replace_equiv_address (ref, XEXP (ref, 0));
}
rtx
use_anchored_address (rtx x)
{
rtx base;
HOST_WIDE_INT offset;
if (!flag_section_anchors)
return x;
if (!MEM_P (x))
return x;
base = XEXP (x, 0);
offset = 0;
if (GET_CODE (base) == CONST
&& GET_CODE (XEXP (base, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (base, 0), 1)) == CONST_INT)
{
offset += INTVAL (XEXP (XEXP (base, 0), 1));
base = XEXP (XEXP (base, 0), 0);
}
if (GET_CODE (base) != SYMBOL_REF
|| !SYMBOL_REF_HAS_BLOCK_INFO_P (base)
|| SYMBOL_REF_ANCHOR_P (base)
|| SYMBOL_REF_BLOCK (base) == NULL
|| !targetm.use_anchors_for_symbol_p (base))
return x;
place_block_symbol (base);
offset += SYMBOL_REF_BLOCK_OFFSET (base);
base = get_section_anchor (SYMBOL_REF_BLOCK (base), offset,
SYMBOL_REF_TLS_MODEL (base));
offset -= SYMBOL_REF_BLOCK_OFFSET (base);
if (!cse_not_expected)
base = force_reg (GET_MODE (base), base);
return replace_equiv_address (x, plus_constant (base, offset));
}
rtx
copy_to_reg (rtx x)
{
rtx temp = gen_reg_rtx (GET_MODE (x));
if (! general_operand (x, VOIDmode))
x = force_operand (x, temp);
if (x != temp)
emit_move_insn (temp, x);
return temp;
}
rtx
copy_addr_to_reg (rtx x)
{
return copy_to_mode_reg (Pmode, x);
}
rtx
copy_to_mode_reg (enum machine_mode mode, rtx x)
{
rtx temp = gen_reg_rtx (mode);
if (! general_operand (x, VOIDmode))
x = force_operand (x, temp);
gcc_assert (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode);
if (x != temp)
{
tree exp = (current_function_decl != NULL_TREE) ?
DECL_RESULT (current_function_decl) : NULL_TREE;
if (exp != NULL_TREE && DECL_RTL_IF_SET (exp) == x
&& GET_CODE (x) == PARALLEL)
{
tree type = TREE_TYPE (exp);
rtx memloc = assign_temp (type, 1, 1, 1);
memloc = validize_mem (memloc);
emit_group_store (memloc, x, type, int_size_in_bytes (type));
x = memloc;
}
emit_move_insn (temp, x);
}
return temp;
}
rtx
force_reg (enum machine_mode mode, rtx x)
{
rtx temp, insn, set;
if (REG_P (x))
return 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 (REG_P (temp))
insn = get_last_insn ();
else
{
rtx temp2 = gen_reg_rtx (mode);
insn = emit_move_insn (temp2, temp);
temp = temp2;
}
}
if (CONSTANT_P (x)
&& (set = single_set (insn)) != 0
&& SET_DEST (set) == temp
&& ! rtx_equal_p (x, SET_SRC (set)))
set_unique_reg_note (insn, REG_EQUAL, x);
{
unsigned align = 0;
if (GET_CODE (x) == SYMBOL_REF)
{
align = BITS_PER_UNIT;
if (SYMBOL_REF_DECL (x) && DECL_P (SYMBOL_REF_DECL (x)))
align = DECL_ALIGN (SYMBOL_REF_DECL (x));
}
else if (GET_CODE (x) == LABEL_REF)
align = BITS_PER_UNIT;
else if (GET_CODE (x) == CONST
&& GET_CODE (XEXP (x, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
&& GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
{
rtx s = XEXP (XEXP (x, 0), 0);
rtx c = XEXP (XEXP (x, 0), 1);
unsigned sa, ca;
sa = BITS_PER_UNIT;
if (SYMBOL_REF_DECL (s) && DECL_P (SYMBOL_REF_DECL (s)))
sa = DECL_ALIGN (SYMBOL_REF_DECL (s));
ca = exact_log2 (INTVAL (c) & -INTVAL (c)) * BITS_PER_UNIT;
align = MIN (sa, ca);
}
else if (MEM_P (x) && MEM_POINTER (x))
align = MEM_ALIGN (x);
if (align)
mark_reg_pointer (temp, align);
}
return temp;
}
rtx
force_not_mem (rtx x)
{
rtx temp;
if (!MEM_P (x) || GET_MODE (x) == BLKmode)
return x;
temp = gen_reg_rtx (GET_MODE (x));
if (MEM_POINTER (x))
REG_POINTER (temp) = 1;
emit_move_insn (temp, x);
return temp;
}
rtx
copy_to_suggested_reg (rtx x, rtx target, enum machine_mode mode)
{
rtx temp;
if (target && REG_P (target))
temp = target;
else
temp = gen_reg_rtx (mode);
emit_move_insn (temp, x);
return temp;
}
#if defined(PROMOTE_MODE) && !defined(PROMOTE_FUNCTION_MODE)
#define PROMOTE_FUNCTION_MODE PROMOTE_MODE
#endif
enum machine_mode
promote_mode (tree type, enum machine_mode mode, int *punsignedp,
int for_call ATTRIBUTE_UNUSED)
{
enum tree_code code = TREE_CODE (type);
int unsignedp = *punsignedp;
#ifndef PROMOTE_MODE
if (! for_call)
return mode;
#endif
switch (code)
{
#ifdef PROMOTE_FUNCTION_MODE
case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
case REAL_TYPE: case OFFSET_TYPE:
#ifdef PROMOTE_MODE
if (for_call)
{
#endif
PROMOTE_FUNCTION_MODE (mode, unsignedp, type);
#ifdef PROMOTE_MODE
}
else
{
PROMOTE_MODE (mode, unsignedp, type);
}
#endif
break;
#endif
#ifdef POINTERS_EXTEND_UNSIGNED
case REFERENCE_TYPE:
case POINTER_TYPE:
mode = Pmode;
unsignedp = POINTERS_EXTEND_UNSIGNED;
break;
#endif
default:
break;
}
*punsignedp = unsignedp;
return mode;
}
void
adjust_stack (rtx adjust)
{
rtx temp;
if (adjust == const0_rtx)
return;
if (GET_CODE (adjust) == CONST_INT)
stack_pointer_delta -= INTVAL (adjust);
temp = expand_binop (Pmode,
#ifdef STACK_GROWS_DOWNWARD
add_optab,
#else
sub_optab,
#endif
stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
OPTAB_LIB_WIDEN);
if (temp != stack_pointer_rtx)
emit_move_insn (stack_pointer_rtx, temp);
}
void
anti_adjust_stack (rtx adjust)
{
rtx temp;
if (adjust == const0_rtx)
return;
if (GET_CODE (adjust) == CONST_INT)
stack_pointer_delta += INTVAL (adjust);
temp = expand_binop (Pmode,
#ifdef STACK_GROWS_DOWNWARD
sub_optab,
#else
add_optab,
#endif
stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
OPTAB_LIB_WIDEN);
if (temp != stack_pointer_rtx)
emit_move_insn (stack_pointer_rtx, temp);
}
static rtx
round_push (rtx size)
{
int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
if (align == 1)
return size;
if (GET_CODE (size) == CONST_INT)
{
HOST_WIDE_INT new = (INTVAL (size) + align - 1) / align * align;
if (INTVAL (size) != new)
size = GEN_INT (new);
}
else
{
size = expand_binop (Pmode, add_optab, size, GEN_INT (align - 1),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, GEN_INT (align),
NULL_RTX, 1);
size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
}
return size;
}
void
emit_stack_save (enum save_level save_level, rtx *psave, rtx after)
{
rtx sa = *psave;
rtx (*fcn) (rtx, rtx) = gen_move_insn;
enum machine_mode mode = STACK_SAVEAREA_MODE (save_level);
switch (save_level)
{
#ifdef HAVE_save_stack_block
case SAVE_BLOCK:
if (HAVE_save_stack_block)
fcn = gen_save_stack_block;
break;
#endif
#ifdef HAVE_save_stack_function
case SAVE_FUNCTION:
if (HAVE_save_stack_function)
fcn = gen_save_stack_function;
break;
#endif
#ifdef HAVE_save_stack_nonlocal
case SAVE_NONLOCAL:
if (HAVE_save_stack_nonlocal)
fcn = gen_save_stack_nonlocal;
break;
#endif
default:
break;
}
if (sa == 0)
{
if (mode != VOIDmode)
{
if (save_level == SAVE_NONLOCAL)
*psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
else
*psave = sa = gen_reg_rtx (mode);
}
}
if (after)
{
rtx seq;
start_sequence ();
do_pending_stack_adjust ();
if (sa != 0)
sa = validize_mem (sa);
emit_insn (fcn (sa, stack_pointer_rtx));
seq = get_insns ();
end_sequence ();
emit_insn_after (seq, after);
}
else
{
do_pending_stack_adjust ();
if (sa != 0)
sa = validize_mem (sa);
emit_insn (fcn (sa, stack_pointer_rtx));
}
}
void
emit_stack_restore (enum save_level save_level, rtx sa, rtx after)
{
rtx (*fcn) (rtx, rtx) = gen_move_insn;
switch (save_level)
{
#ifdef HAVE_restore_stack_block
case SAVE_BLOCK:
if (HAVE_restore_stack_block)
fcn = gen_restore_stack_block;
break;
#endif
#ifdef HAVE_restore_stack_function
case SAVE_FUNCTION:
if (HAVE_restore_stack_function)
fcn = gen_restore_stack_function;
break;
#endif
#ifdef HAVE_restore_stack_nonlocal
case SAVE_NONLOCAL:
if (HAVE_restore_stack_nonlocal)
fcn = gen_restore_stack_nonlocal;
break;
#endif
default:
break;
}
if (sa != 0)
{
sa = validize_mem (sa);
emit_insn (gen_rtx_CLOBBER (VOIDmode,
gen_rtx_MEM (BLKmode,
gen_rtx_SCRATCH (VOIDmode))));
emit_insn (gen_rtx_CLOBBER (VOIDmode,
gen_rtx_MEM (BLKmode, stack_pointer_rtx)));
}
discard_pending_stack_adjust ();
if (after)
{
rtx seq;
start_sequence ();
emit_insn (fcn (stack_pointer_rtx, sa));
seq = get_insns ();
end_sequence ();
emit_insn_after (seq, after);
}
else
emit_insn (fcn (stack_pointer_rtx, sa));
}
void
update_nonlocal_goto_save_area (void)
{
tree t_save;
rtx r_save;
t_save = build4 (ARRAY_REF, ptr_type_node, cfun->nonlocal_goto_save_area,
integer_one_node, NULL_TREE, NULL_TREE);
r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE);
emit_stack_save (SAVE_NONLOCAL, &r_save, NULL_RTX);
}
rtx
allocate_dynamic_stack_space (rtx size, rtx target, int known_align)
{
if (size == const0_rtx)
return virtual_stack_dynamic_rtx;
current_function_calls_alloca = 1;
if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
size = convert_to_mode (Pmode, size, 1);
cfun->preferred_stack_boundary = 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 defined (STACK_DYNAMIC_OFFSET)
if (current_function_calls_setjmp
&& targetm.have_dynamic_stack_space)
size = gen_rtx_PLUS (GET_MODE (size), size,
gen_rtx_CONST_INT (GET_MODE (size),
abs (STACK_DYNAMIC_OFFSET (current_function_decl))));
#endif
size
= force_operand (plus_constant (size,
BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
NULL_RTX);
}
#ifdef SETJMP_VIA_SAVE_AREA
if (!current_function_calls_setjmp)
{
int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
gcc_assert (PREFERRED_STACK_BOUNDARY == BIGGEST_ALIGNMENT);
if (GET_CODE (size) == CONST_INT)
{
HOST_WIDE_INT new = INTVAL (size) / align * align;
if (INTVAL (size) != new)
size = GEN_INT (new);
}
else
{
size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size,
GEN_INT (align), NULL_RTX, 1);
size = expand_mult (Pmode, size,
GEN_INT (align), NULL_RTX, 1);
}
}
else
{
rtx dynamic_offset
= expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx,
stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN);
size = expand_binop (Pmode, add_optab, size, dynamic_offset,
NULL_RTX, 1, OPTAB_LIB_WIDEN);
}
#endif
#if !defined (SETJMP_VIA_SAVE_AREA)
if (MUST_ALIGN || known_align % PREFERRED_STACK_BOUNDARY != 0)
#endif
size = round_push (size);
do_pending_stack_adjust ();
gcc_assert (!(stack_pointer_delta
% (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)));
if (flag_stack_check && ! STACK_CHECK_BUILTIN)
probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size);
if (target == 0 || !REG_P (target)
|| REGNO (target) < FIRST_PSEUDO_REGISTER
|| GET_MODE (target) != Pmode)
target = gen_reg_rtx (Pmode);
mark_reg_pointer (target, known_align);
#ifdef HAVE_allocate_stack
if (HAVE_allocate_stack)
{
enum machine_mode mode = STACK_SIZE_MODE;
insn_operand_predicate_fn pred;
if (mode == VOIDmode)
mode = insn_data[(int) CODE_FOR_allocate_stack].operand[1].mode;
pred = insn_data[(int) CODE_FOR_allocate_stack].operand[1].predicate;
if (pred && ! ((*pred) (size, mode)))
size = copy_to_mode_reg (mode, convert_to_mode (mode, size, 1));
emit_insn (gen_allocate_stack (target, size));
}
else
#endif
{
#ifndef STACK_GROWS_DOWNWARD
emit_move_insn (target, virtual_stack_dynamic_rtx);
#endif
if (current_function_limit_stack)
{
rtx available;
rtx space_available = gen_label_rtx ();
#ifdef STACK_GROWS_DOWNWARD
available = expand_binop (Pmode, sub_optab,
stack_pointer_rtx, stack_limit_rtx,
NULL_RTX, 1, OPTAB_WIDEN);
#else
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,
space_available);
#ifdef HAVE_trap
if (HAVE_trap)
emit_insn (gen_trap ());
else
#endif
error ("stack limits not supported on this target");
emit_barrier ();
emit_label (space_available);
}
anti_adjust_stack (size);
#ifdef STACK_GROWS_DOWNWARD
emit_move_insn (target, virtual_stack_dynamic_rtx);
#endif
}
if (MUST_ALIGN)
{
target = expand_binop (Pmode, add_optab, target,
GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target,
GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
NULL_RTX, 1);
target = expand_mult (Pmode, target,
GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
NULL_RTX, 1);
}
if (cfun->nonlocal_goto_save_area != 0)
update_nonlocal_goto_save_area ();
return target;
}
static GTY(()) rtx stack_check_libfunc;
void
set_stack_check_libfunc (rtx libfunc)
{
stack_check_libfunc = libfunc;
}
static void
emit_stack_probe (rtx address)
{
rtx memref = gen_rtx_MEM (word_mode, address);
MEM_VOLATILE_P (memref) = 1;
if (STACK_CHECK_PROBE_LOAD)
emit_move_insn (gen_reg_rtx (word_mode), memref);
else
emit_move_insn (memref, const0_rtx);
}
#ifdef STACK_GROWS_DOWNWARD
#define STACK_GROW_OP MINUS
#else
#define STACK_GROW_OP PLUS
#endif
void
probe_stack_range (HOST_WIDE_INT first, rtx size)
{
if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
size = convert_to_mode (Pmode, size, 1);
if (stack_check_libfunc != 0)
{
rtx addr = memory_address (QImode,
gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
stack_pointer_rtx,
plus_constant (size, first)));
addr = convert_memory_address (ptr_mode, addr);
emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr,
ptr_mode);
}
#ifdef HAVE_check_stack
else if (HAVE_check_stack)
{
insn_operand_predicate_fn pred;
rtx last_addr
= force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
stack_pointer_rtx,
plus_constant (size, first)),
NULL_RTX);
pred = insn_data[(int) CODE_FOR_check_stack].operand[0].predicate;
if (pred && ! ((*pred) (last_addr, Pmode)))
last_addr = copy_to_mode_reg (Pmode, last_addr);
emit_insn (gen_check_stack (last_addr));
}
#endif
else if (GET_CODE (size) == CONST_INT
&& INTVAL (size) < 10 * STACK_CHECK_PROBE_INTERVAL)
{
HOST_WIDE_INT offset;
for (offset = first + STACK_CHECK_PROBE_INTERVAL;
offset < INTVAL (size);
offset = offset + STACK_CHECK_PROBE_INTERVAL)
emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
stack_pointer_rtx,
GEN_INT (offset)));
emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
stack_pointer_rtx,
plus_constant (size, first)));
}
else
{
rtx test_addr
= force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
stack_pointer_rtx,
GEN_INT (first + STACK_CHECK_PROBE_INTERVAL)),
NULL_RTX);
rtx last_addr
= force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
stack_pointer_rtx,
plus_constant (size, first)),
NULL_RTX);
rtx incr = GEN_INT (STACK_CHECK_PROBE_INTERVAL);
rtx loop_lab = gen_label_rtx ();
rtx test_lab = gen_label_rtx ();
rtx end_lab = gen_label_rtx ();
rtx temp;
if (!REG_P (test_addr)
|| REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
test_addr = force_reg (Pmode, test_addr);
emit_jump (test_lab);
emit_label (loop_lab);
emit_stack_probe (test_addr);
#ifdef STACK_GROWS_DOWNWARD
#define CMP_OPCODE GTU
temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr,
1, OPTAB_WIDEN);
#else
#define CMP_OPCODE LTU
temp = expand_binop (Pmode, add_optab, test_addr, incr, test_addr,
1, OPTAB_WIDEN);
#endif
gcc_assert (temp == test_addr);
emit_label (test_lab);
emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
NULL_RTX, Pmode, 1, loop_lab);
emit_jump (end_lab);
emit_label (end_lab);
emit_stack_probe (last_addr);
}
}
rtx
hard_function_value (tree valtype, tree func, tree fntype,
int outgoing ATTRIBUTE_UNUSED)
{
rtx val;
val = targetm.calls.function_value (valtype, func ? func : fntype, outgoing);
if (REG_P (val)
&& GET_MODE (val) == BLKmode)
{
unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype);
enum machine_mode tmpmode;
for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
tmpmode != VOIDmode;
tmpmode = GET_MODE_WIDER_MODE (tmpmode))
{
if (GET_MODE_SIZE (tmpmode) >= bytes)
break;
}
gcc_assert (tmpmode != VOIDmode);
PUT_MODE (val, tmpmode);
}
return val;
}
rtx
hard_libcall_value (enum machine_mode mode)
{
return LIBCALL_VALUE (mode);
}
int
rtx_to_tree_code (enum rtx_code code)
{
enum tree_code tcode;
switch (code)
{
case PLUS:
tcode = PLUS_EXPR;
break;
case MINUS:
tcode = MINUS_EXPR;
break;
case MULT:
tcode = MULT_EXPR;
break;
case DIV:
tcode = RDIV_EXPR;
break;
case SMIN:
tcode = MIN_EXPR;
break;
case SMAX:
tcode = MAX_EXPR;
break;
default:
tcode = LAST_AND_UNUSED_TREE_CODE;
break;
}
return ((int) tcode);
}
#include "gt-explow.h"