Similar to patch 1, but here the calls are all to expand_* routines.
Tested in the same way as before. OK to install?
Thanks,
Richard
gcc/
* asan.c (asan_clear_shadow): Use gen_int_mode with the mode
of the associated expand_* call.
(asan_emit_stack_protection): Likewise.
* builtins.c (round_trampoline_addr): Likewise.
* explow.c (allocate_dynamic_stack_space, probe_stack_range): Likewise.
* expmed.c (expand_smod_pow2, expand_sdiv_pow2, expand_divmod)
(emit_store_flag): Likewise.
* expr.c (emit_move_resolve_push, push_block, emit_single_push_insn_1)
(emit_push_insn, optimize_bitfield_assignment_op, expand_expr_real_1):
Likewise.
* function.c (instantiate_virtual_regs_in_insn): Likewise.
* ifcvt.c (noce_try_store_flag_constants): Likewise.
* loop-unroll.c (unroll_loop_runtime_iterations): Likewise.
* modulo-sched.c (generate_prolog_epilog): Likewise.
* optabs.c (expand_binop, widen_leading, expand_doubleword_clz)
(expand_ctz, expand_ffs, expand_unop): Likewise.
Index: gcc/asan.c
===================================================================
--- gcc/asan.c 2013-09-09 10:23:49.095277703 +0100
+++ gcc/asan.c 2013-09-09 10:55:59.743537289 +0100
@@ -897,15 +897,15 @@ asan_clear_shadow (rtx shadow_mem, HOST_
top_label = gen_label_rtx ();
addr = force_reg (Pmode, XEXP (shadow_mem, 0));
shadow_mem = adjust_automodify_address (shadow_mem, SImode, addr, 0);
end = force_reg (Pmode, plus_constant (Pmode, addr, len));
emit_label (top_label);
emit_move_insn (shadow_mem, const0_rtx);
- tmp = expand_simple_binop (Pmode, PLUS, addr, GEN_INT (4), addr,
+ tmp = expand_simple_binop (Pmode, PLUS, addr, gen_int_mode (4, Pmode), addr,
true, OPTAB_LIB_WIDEN);
if (tmp != addr)
emit_move_insn (addr, tmp);
emit_cmp_and_jump_insns (addr, end, LT, NULL_RTX, Pmode, true, top_label);
jump = get_last_insn ();
gcc_assert (JUMP_P (jump));
add_reg_note (jump, REG_BR_PROB, GEN_INT (REG_BR_PROB_BASE * 80 / 100));
@@ -962,25 +962,27 @@ asan_emit_stack_protection (rtx base, HO
else
pp_string (&asan_pp, "9 <unknown>");
pp_space (&asan_pp);
}
str_cst = asan_pp_string (&asan_pp);
/* Emit the prologue sequence. */
- base = expand_binop (Pmode, add_optab, base, GEN_INT (base_offset),
+ base = expand_binop (Pmode, add_optab, base,
+ gen_int_mode (base_offset, Pmode),
NULL_RTX, 1, OPTAB_DIRECT);
mem = gen_rtx_MEM (ptr_mode, base);
emit_move_insn (mem, GEN_INT (ASAN_STACK_FRAME_MAGIC));
mem = adjust_address (mem, VOIDmode, GET_MODE_SIZE (ptr_mode));
emit_move_insn (mem, expand_normal (str_cst));
shadow_base = expand_binop (Pmode, lshr_optab, base,
GEN_INT (ASAN_SHADOW_SHIFT),
NULL_RTX, 1, OPTAB_DIRECT);
shadow_base = expand_binop (Pmode, add_optab, shadow_base,
- GEN_INT (targetm.asan_shadow_offset ()),
+ gen_int_mode (targetm.asan_shadow_offset (),
+ Pmode),
NULL_RTX, 1, OPTAB_DIRECT);
gcc_assert (asan_shadow_set != -1
&& (ASAN_RED_ZONE_SIZE >> ASAN_SHADOW_SHIFT) == 4);
shadow_mem = gen_rtx_MEM (SImode, shadow_base);
set_mem_alias_set (shadow_mem, asan_shadow_set);
prev_offset = base_offset;
for (l = length; l; l -= 2)
Index: gcc/builtins.c
===================================================================
--- gcc/builtins.c 2013-09-08 17:18:39.707590244 +0100
+++ gcc/builtins.c 2013-09-09 10:55:59.747537322 +0100
@@ -4858,16 +4858,16 @@ round_trampoline_addr (rtx tramp)
/* If we don't need too much alignment, we'll have been guaranteed
proper alignment by get_trampoline_type. */
if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
return tramp;
/* Round address up to desired boundary. */
temp = gen_reg_rtx (Pmode);
- addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
- mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
+ addend = gen_int_mode (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1, Pmode);
+ mask = gen_int_mode (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT, Pmode);
temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
temp, 0, OPTAB_LIB_WIDEN);
tramp = expand_simple_binop (Pmode, AND, temp, mask,
temp, 0, OPTAB_LIB_WIDEN);
return tramp;
Index: gcc/explow.c
===================================================================
--- gcc/explow.c 2013-09-09 10:49:45.226460819 +0100
+++ gcc/explow.c 2013-09-09 10:55:59.748537330 +0100
@@ -1351,15 +1351,16 @@ allocate_dynamic_stack_space (rtx size,
by malloc does not meet REQUIRED_ALIGN, we increase SIZE to
make sure we allocate enough space. */
if (MALLOC_ABI_ALIGNMENT >= required_align)
ask = size;
else
{
ask = expand_binop (Pmode, add_optab, size,
- GEN_INT (required_align / BITS_PER_UNIT - 1),
+ gen_int_mode (required_align / BITS_PER_UNIT - 1,
+ Pmode),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
must_align = true;
}
func = init_one_libfunc ("__morestack_allocate_stack_space");
space = emit_library_call_value (func, target, LCT_NORMAL, Pmode,
@@ -1477,21 +1478,24 @@ allocate_dynamic_stack_space (rtx size,
if (must_align)
{
/* CEIL_DIV_EXPR needs to worry about the addition overflowing,
but we know it can't. So add ourselves and then do
TRUNC_DIV_EXPR. */
target = expand_binop (Pmode, add_optab, target,
- GEN_INT (required_align / BITS_PER_UNIT - 1),
+ gen_int_mode (required_align / BITS_PER_UNIT - 1,
+ Pmode),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target,
- GEN_INT (required_align / BITS_PER_UNIT),
+ gen_int_mode (required_align / BITS_PER_UNIT,
+ Pmode),
NULL_RTX, 1);
target = expand_mult (Pmode, target,
- GEN_INT (required_align / BITS_PER_UNIT),
+ gen_int_mode (required_align / BITS_PER_UNIT,
+ Pmode),
NULL_RTX, 1);
}
/* Now that we've committed to a return value, mark its alignment. */
mark_reg_pointer (target, required_align);
/* Record the new stack level for nonlocal gotos. */
@@ -1665,15 +1669,15 @@ probe_stack_range (HOST_WIDE_INT first,
/* Jump to END_LAB if TEST_ADDR == LAST_ADDR. */
emit_cmp_and_jump_insns (test_addr, last_addr, EQ, NULL_RTX, Pmode, 1,
end_lab);
/* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL. */
temp = expand_binop (Pmode, STACK_GROW_OPTAB, test_addr,
- GEN_INT (PROBE_INTERVAL), test_addr,
+ gen_int_mode (PROBE_INTERVAL, Pmode), test_addr,
1, OPTAB_WIDEN);
gcc_assert (temp == test_addr);
/* Probe at TEST_ADDR. */
emit_stack_probe (test_addr);
Index: gcc/expmed.c
===================================================================
--- gcc/expmed.c 2013-09-09 10:49:45.228460835 +0100
+++ gcc/expmed.c 2013-09-09 10:55:59.751537354 +0100
@@ -3662,30 +3662,32 @@ expand_smod_pow2 (enum machine_mode mode
|| (set_src_cost (temp, optimize_insn_for_speed_p ())
> COSTS_N_INSNS (2)))
{
temp = expand_binop (mode, xor_optab, op0, signmask,
NULL_RTX, 1, OPTAB_LIB_WIDEN);
temp = expand_binop (mode, sub_optab, temp, signmask,
NULL_RTX, 1, OPTAB_LIB_WIDEN);
- temp = expand_binop (mode, and_optab, temp, GEN_INT (masklow),
+ temp = expand_binop (mode, and_optab, temp,
+ gen_int_mode (masklow, mode),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
temp = expand_binop (mode, xor_optab, temp, signmask,
NULL_RTX, 1, OPTAB_LIB_WIDEN);
temp = expand_binop (mode, sub_optab, temp, signmask,
NULL_RTX, 1, OPTAB_LIB_WIDEN);
}
else
{
signmask = expand_binop (mode, lshr_optab, signmask, shift,
NULL_RTX, 1, OPTAB_LIB_WIDEN);
signmask = force_reg (mode, signmask);
temp = expand_binop (mode, add_optab, op0, signmask,
NULL_RTX, 1, OPTAB_LIB_WIDEN);
- temp = expand_binop (mode, and_optab, temp, GEN_INT (masklow),
+ temp = expand_binop (mode, and_optab, temp,
+ gen_int_mode (masklow, mode),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
temp = expand_binop (mode, sub_optab, temp, signmask,
NULL_RTX, 1, OPTAB_LIB_WIDEN);
}
return temp;
}
}
@@ -3760,15 +3762,15 @@ expand_sdiv_pow2 (enum machine_mode mode
/* ??? emit_conditional_move forces a stack adjustment via
compare_from_rtx so, if the sequence is discarded, it will
be lost. Do it now instead. */
do_pending_stack_adjust ();
start_sequence ();
temp2 = copy_to_mode_reg (mode, op0);
- temp = expand_binop (mode, add_optab, temp2, GEN_INT (d-1),
+ temp = expand_binop (mode, add_optab, temp2, gen_int_mode (d - 1, mode),
NULL_RTX, 0, OPTAB_LIB_WIDEN);
temp = force_reg (mode, temp);
/* Construct "temp2 = (temp2 < 0) ? temp : temp2". */
temp2 = emit_conditional_move (temp2, LT, temp2, const0_rtx,
mode, temp, temp2, mode, 0);
if (temp2)
@@ -3787,28 +3789,28 @@ expand_sdiv_pow2 (enum machine_mode mode
{
int ushift = GET_MODE_BITSIZE (mode) - logd;
temp = gen_reg_rtx (mode);
temp = emit_store_flag (temp, LT, op0, const0_rtx, mode, 0, -1);
if (shift_cost (optimize_insn_for_speed_p (), mode, ushift)
> COSTS_N_INSNS (1))
- temp = expand_binop (mode, and_optab, temp, GEN_INT (d - 1),
+ temp = expand_binop (mode, and_optab, temp, gen_int_mode (d - 1, mode),
NULL_RTX, 0, OPTAB_LIB_WIDEN);
else
temp = expand_shift (RSHIFT_EXPR, mode, temp,
ushift, NULL_RTX, 1);
temp = expand_binop (mode, add_optab, temp, op0, NULL_RTX,
0, OPTAB_LIB_WIDEN);
return expand_shift (RSHIFT_EXPR, mode, temp, logd, NULL_RTX, 0);
}
label = gen_label_rtx ();
temp = copy_to_mode_reg (mode, op0);
do_cmp_and_jump (temp, const0_rtx, GE, mode, label);
- expand_inc (temp, GEN_INT (d - 1));
+ expand_inc (temp, gen_int_mode (d - 1, mode));
emit_label (label);
return expand_shift (RSHIFT_EXPR, mode, temp, logd, NULL_RTX, 0);
}
/* Emit the code to divide OP0 by OP1, putting the result in TARGET
if that is convenient, and returning where the result is.
You may request either the quotient or the remainder as the result;
@@ -4058,17 +4060,19 @@ expand_divmod (int rem_flag, enum tree_c
& GET_MODE_MASK (compute_mode));
if (EXACT_POWER_OF_2_OR_ZERO_P (d))
{
pre_shift = floor_log2 (d);
if (rem_flag)
{
+ unsigned HOST_WIDE_INT mask
+ = ((unsigned HOST_WIDE_INT) 1 << pre_shift) - 1;
remainder
= expand_binop (compute_mode, and_optab, op0,
- GEN_INT (((HOST_WIDE_INT) 1 <<
pre_shift) - 1),
+ gen_int_mode (mask, compute_mode),
remainder, 1,
OPTAB_LIB_WIDEN);
if (remainder)
return gen_lowpart (mode, remainder);
}
quotient = expand_shift (RSHIFT_EXPR, compute_mode, op0,
pre_shift, tquotient, 1);
@@ -4111,18 +4115,18 @@ expand_divmod (int rem_flag, enum tree_c
if (post_shift - 1 >= BITS_PER_WORD)
goto fail1;
extra_cost
= (shift_cost (speed, compute_mode, post_shift -
1)
+ shift_cost (speed, compute_mode, 1)
+ 2 * add_cost (speed, compute_mode));
- t1 = expmed_mult_highpart (compute_mode, op0,
- GEN_INT (ml),
- NULL_RTX, 1,
- max_cost - extra_cost);
+ t1 = expmed_mult_highpart
+ (compute_mode, op0,
+ gen_int_mode (ml, compute_mode),
+ NULL_RTX, 1, max_cost - extra_cost);
if (t1 == 0)
goto fail1;
t2 = force_operand (gen_rtx_MINUS (compute_mode,
op0, t1),
NULL_RTX);
t3 = expand_shift (RSHIFT_EXPR, compute_mode,
t2, 1, NULL_RTX, 1);
@@ -4143,18 +4147,18 @@ expand_divmod (int rem_flag, enum tree_c
t1 = expand_shift
(RSHIFT_EXPR, compute_mode, op0,
pre_shift, NULL_RTX, 1);
extra_cost
= (shift_cost (speed, compute_mode, pre_shift)
+ shift_cost (speed, compute_mode,
post_shift));
- t2 = expmed_mult_highpart (compute_mode, t1,
- GEN_INT (ml),
- NULL_RTX, 1,
- max_cost - extra_cost);
+ t2 = expmed_mult_highpart
+ (compute_mode, t1,
+ gen_int_mode (ml, compute_mode),
+ NULL_RTX, 1, max_cost - extra_cost);
if (t2 == 0)
goto fail1;
quotient = expand_shift
(RSHIFT_EXPR, compute_mode, t2,
post_shift, tquotient, 1);
}
}
@@ -4270,17 +4274,17 @@ expand_divmod (int rem_flag, enum tree_c
if (post_shift >= BITS_PER_WORD
|| size - 1 >= BITS_PER_WORD)
goto fail1;
extra_cost = (shift_cost (speed, compute_mode,
post_shift)
+ shift_cost (speed, compute_mode, size -
1)
+ add_cost (speed, compute_mode));
- t1 = expmed_mult_highpart (compute_mode, op0,
- GEN_INT (ml), NULL_RTX, 0,
- max_cost - extra_cost);
+ t1 = expmed_mult_highpart
+ (compute_mode, op0, gen_int_mode (ml, compute_mode),
+ NULL_RTX, 0, max_cost - extra_cost);
if (t1 == 0)
goto fail1;
t2 = expand_shift
(RSHIFT_EXPR, compute_mode, t1,
post_shift, NULL_RTX, 0);
t3 = expand_shift
(RSHIFT_EXPR, compute_mode, op0,
@@ -4364,17 +4368,20 @@ expand_divmod (int rem_flag, enum tree_c
/* We could just as easily deal with negative constants here,
but it does not seem worth the trouble for GCC 2.6. */
if (EXACT_POWER_OF_2_OR_ZERO_P (d))
{
pre_shift = floor_log2 (d);
if (rem_flag)
{
- remainder = expand_binop (compute_mode, and_optab, op0,
- GEN_INT (((HOST_WIDE_INT) 1
<< pre_shift) - 1),
- remainder, 0,
OPTAB_LIB_WIDEN);
+ unsigned HOST_WIDE_INT mask
+ = ((unsigned HOST_WIDE_INT) 1 << pre_shift) - 1;
+ remainder = expand_binop
+ (compute_mode, and_optab, op0,
+ gen_int_mode (mask, compute_mode),
+ remainder, 0, OPTAB_LIB_WIDEN);
if (remainder)
return gen_lowpart (mode, remainder);
}
quotient = expand_shift
(RSHIFT_EXPR, compute_mode, op0,
pre_shift, tquotient, 0);
}
@@ -4393,17 +4400,17 @@ expand_divmod (int rem_flag, enum tree_c
(RSHIFT_EXPR, compute_mode, op0,
size - 1, NULL_RTX, 0);
t2 = expand_binop (compute_mode, xor_optab, op0, t1,
NULL_RTX, 0, OPTAB_WIDEN);
extra_cost = (shift_cost (speed, compute_mode,
post_shift)
+ shift_cost (speed, compute_mode, size -
1)
+ 2 * add_cost (speed, compute_mode));
- t3 = expmed_mult_highpart (compute_mode, t2,
- GEN_INT (ml), NULL_RTX, 1,
- max_cost - extra_cost);
+ t3 = expmed_mult_highpart
+ (compute_mode, t2, gen_int_mode (ml, compute_mode),
+ NULL_RTX, 1, max_cost - extra_cost);
if (t3 != 0)
{
t4 = expand_shift
(RSHIFT_EXPR, compute_mode, t3,
post_shift, NULL_RTX, 1);
quotient = expand_binop (compute_mode, xor_optab,
t4, t1, tquotient, 0,
@@ -4533,15 +4540,15 @@ expand_divmod (int rem_flag, enum tree_c
if (op1_is_constant && EXACT_POWER_OF_2_OR_ZERO_P (INTVAL (op1)))
{
rtx t1, t2, t3;
unsigned HOST_WIDE_INT d = INTVAL (op1);
t1 = expand_shift (RSHIFT_EXPR, compute_mode, op0,
floor_log2 (d), tquotient, 1);
t2 = expand_binop (compute_mode, and_optab, op0,
- GEN_INT (d - 1),
+ gen_int_mode (d - 1, compute_mode),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
t3 = gen_reg_rtx (compute_mode);
t3 = emit_store_flag (t3, NE, t2, const0_rtx,
compute_mode, 1, 1);
if (t3 == 0)
{
rtx lab;
@@ -4630,15 +4637,15 @@ expand_divmod (int rem_flag, enum tree_c
languages (Ada). */
rtx t1, t2, t3;
unsigned HOST_WIDE_INT d = INTVAL (op1);
t1 = expand_shift (RSHIFT_EXPR, compute_mode, op0,
floor_log2 (d), tquotient, 0);
t2 = expand_binop (compute_mode, and_optab, op0,
- GEN_INT (d - 1),
+ gen_int_mode (d - 1, compute_mode),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
t3 = gen_reg_rtx (compute_mode);
t3 = emit_store_flag (t3, NE, t2, const0_rtx,
compute_mode, 1, 1);
if (t3 == 0)
{
rtx lab;
@@ -5473,15 +5480,15 @@ emit_store_flag (rtx target, enum rtx_co
&& rtx_cost (GEN_INT (normalizep), PLUS, 1,
optimize_insn_for_speed_p ()) == 0)
{
tem = emit_store_flag_1 (subtarget, rcode, op0, op1, mode, 0,
STORE_FLAG_VALUE, target_mode);
if (tem)
return expand_binop (target_mode, add_optab, tem,
- GEN_INT (normalizep),
+ gen_int_mode (normalizep, target_mode),
target, 0, OPTAB_WIDEN);
}
else if (!want_add
&& rtx_cost (trueval, XOR, 1,
optimize_insn_for_speed_p ()) == 0)
{
tem = emit_store_flag_1 (subtarget, rcode, op0, op1, mode, 0,
@@ -5577,15 +5584,16 @@ emit_store_flag (rtx target, enum rtx_co
&& rtx_cost (GEN_INT (normalizep), PLUS, 1,
optimize_insn_for_speed_p ()) == 0)
{
tem = emit_store_flag_1 (subtarget, rcode, op0, op1, mode, 0,
STORE_FLAG_VALUE, target_mode);
if (tem != 0)
tem = expand_binop (target_mode, add_optab, tem,
- GEN_INT (normalizep), target, 0, OPTAB_WIDEN);
+ gen_int_mode (normalizep, target_mode),
+ target, 0, OPTAB_WIDEN);
}
else if (!want_add
&& rtx_cost (trueval, XOR, 1,
optimize_insn_for_speed_p ()) == 0)
{
tem = emit_store_flag_1 (subtarget, rcode, op0, op1, mode, 0,
normalizep, target_mode);
Index: gcc/expr.c
===================================================================
--- gcc/expr.c 2013-09-09 10:49:45.230460851 +0100
+++ gcc/expr.c 2013-09-09 10:55:59.754537379 +0100
@@ -3128,15 +3128,15 @@ emit_move_resolve_push (enum machine_mod
gcc_assert (adjust == val || adjust == -val);
adjust = val;
}
/* Do not use anti_adjust_stack, since we don't want to update
stack_pointer_delta. */
temp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
- GEN_INT (adjust), stack_pointer_rtx,
+ gen_int_mode (adjust, Pmode), stack_pointer_rtx,
0, OPTAB_LIB_WIDEN);
if (temp != stack_pointer_rtx)
emit_move_insn (stack_pointer_rtx, temp);
switch (code)
{
case PRE_INC:
@@ -3639,15 +3639,16 @@ push_block (rtx size, int extra, int bel
anti_adjust_stack (plus_constant (Pmode, size, extra));
else if (REG_P (size) && extra == 0)
anti_adjust_stack (size);
else
{
temp = copy_to_mode_reg (Pmode, size);
if (extra != 0)
- temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
+ temp = expand_binop (Pmode, add_optab, temp,
+ gen_int_mode (extra, Pmode),
temp, 0, OPTAB_LIB_WIDEN);
anti_adjust_stack (temp);
}
#ifndef STACK_GROWS_DOWNWARD
if (0)
#else
@@ -3907,15 +3908,15 @@ emit_single_push_insn_1 (enum machine_mo
expand_binop (Pmode,
#ifdef STACK_GROWS_DOWNWARD
sub_optab,
#else
add_optab,
#endif
stack_pointer_rtx,
- GEN_INT (rounded_size),
+ gen_int_mode (rounded_size, Pmode),
NULL_RTX, 0, OPTAB_LIB_WIDEN));
offset = (HOST_WIDE_INT) padding_size;
#ifdef STACK_GROWS_DOWNWARD
if (STACK_PUSH_CODE == POST_DEC)
/* We have already decremented the stack pointer, so get the
previous value. */
@@ -4123,16 +4124,16 @@ emit_push_insn (rtx x, enum machine_mode
/* Deduct words put into registers from the size we must copy. */
if (partial != 0)
{
if (CONST_INT_P (size))
size = GEN_INT (INTVAL (size) - used);
else
size = expand_binop (GET_MODE (size), sub_optab, size,
- GEN_INT (used), NULL_RTX, 0,
- OPTAB_LIB_WIDEN);
+ gen_int_mode (used, GET_MODE (size)),
+ NULL_RTX, 0, OPTAB_LIB_WIDEN);
}
/* Get the address of the stack space.
In this case, we do not deal with EXTRA separately.
A single stack adjust will do. */
if (! args_addr)
{
@@ -4471,15 +4472,16 @@ optimize_bitfield_assignment_op (unsigne
set_mem_alias_set (str_rtx, 0);
set_mem_expr (str_rtx, 0);
}
binop = code == BIT_IOR_EXPR ? ior_optab : xor_optab;
if (bitpos + bitsize != str_bitsize)
{
- rtx mask = GEN_INT (((unsigned HOST_WIDE_INT) 1 << bitsize) - 1);
+ rtx mask = gen_int_mode (((unsigned HOST_WIDE_INT) 1 << bitsize) - 1,
+ str_mode);
value = expand_and (str_mode, value, mask, NULL_RTX);
}
value = expand_shift (LSHIFT_EXPR, str_mode, value, bitpos, NULL_RTX, 1);
result = expand_binop (str_mode, binop, str_rtx,
value, str_rtx, 1, OPTAB_WIDEN);
if (result != str_rtx)
emit_move_insn (str_rtx, result);
@@ -9853,15 +9855,16 @@ expand_expr_real_1 (tree exp, rtx target
if (DECL_BIT_FIELD (field))
{
HOST_WIDE_INT bitsize = TREE_INT_CST_LOW (DECL_SIZE
(field));
enum machine_mode imode = TYPE_MODE (TREE_TYPE (field));
if (TYPE_UNSIGNED (TREE_TYPE (field)))
{
- op1 = GEN_INT (((HOST_WIDE_INT) 1 << bitsize) - 1);
+ op1 = gen_int_mode (((HOST_WIDE_INT) 1 << bitsize) - 1,
+ imode);
op0 = expand_and (imode, op0, op1, target);
}
else
{
int count = GET_MODE_PRECISION (imode) - bitsize;
op0 = expand_shift (LSHIFT_EXPR, imode, op0, count,
Index: gcc/function.c
===================================================================
--- gcc/function.c 2013-09-08 17:18:39.707590244 +0100
+++ gcc/function.c 2013-09-09 10:55:59.756537396 +0100
@@ -1540,17 +1540,18 @@ instantiate_virtual_regs_in_insn (rtx in
new_rtx = instantiate_new_reg (SET_SRC (set), &offset);
if (new_rtx && offset != 0
&& REG_P (SET_DEST (set))
&& REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER)
{
start_sequence ();
- x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS,
- new_rtx, GEN_INT (offset), SET_DEST (set),
- 1, OPTAB_LIB_WIDEN);
+ x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS, new_rtx,
+ gen_int_mode (offset,
+ GET_MODE (SET_DEST (set))),
+ SET_DEST (set), 1, OPTAB_LIB_WIDEN);
if (x != SET_DEST (set))
emit_move_insn (SET_DEST (set), x);
seq = get_insns ();
end_sequence ();
emit_insn_before (seq, insn);
@@ -1662,32 +1663,33 @@ instantiate_virtual_regs_in_insn (rtx in
/* Careful, special mode predicates may have stuff in
insn_data[insn_code].operand[i].mode that isn't useful
to us for computing a new value. */
/* ??? Recognize address_operand and/or "p" constraints
to see if (plus new offset) is a valid before we put
this through expand_simple_binop. */
x = expand_simple_binop (GET_MODE (x), PLUS, new_rtx,
- GEN_INT (offset), NULL_RTX,
- 1, OPTAB_LIB_WIDEN);
+ gen_int_mode (offset, GET_MODE (x)),
+ NULL_RTX, 1, OPTAB_LIB_WIDEN);
seq = get_insns ();
end_sequence ();
emit_insn_before (seq, insn);
}
break;
case SUBREG:
new_rtx = instantiate_new_reg (SUBREG_REG (x), &offset);
if (new_rtx == NULL)
continue;
if (offset != 0)
{
start_sequence ();
- new_rtx = expand_simple_binop (GET_MODE (new_rtx), PLUS, new_rtx,
- GEN_INT (offset), NULL_RTX,
- 1, OPTAB_LIB_WIDEN);
+ new_rtx = expand_simple_binop
+ (GET_MODE (new_rtx), PLUS, new_rtx,
+ gen_int_mode (offset, GET_MODE (new_rtx)),
+ NULL_RTX, 1, OPTAB_LIB_WIDEN);
seq = get_insns ();
end_sequence ();
emit_insn_before (seq, insn);
}
x = simplify_gen_subreg (recog_data.operand_mode[i], new_rtx,
GET_MODE (new_rtx), SUBREG_BYTE (x));
gcc_assert (x);
Index: gcc/ifcvt.c
===================================================================
--- gcc/ifcvt.c 2013-09-08 17:18:39.707590244 +0100
+++ gcc/ifcvt.c 2013-09-09 10:55:59.760537428 +0100
@@ -1158,16 +1158,16 @@ noce_try_store_flag_constants (struct no
/* if (test) x = 3; else x = 4;
=> x = 3 + (test == 0); */
if (diff == STORE_FLAG_VALUE || diff == -STORE_FLAG_VALUE)
{
target = expand_simple_binop (mode,
(diff == STORE_FLAG_VALUE
? PLUS : MINUS),
- GEN_INT (ifalse), target, if_info->x, 0,
- OPTAB_WIDEN);
+ gen_int_mode (ifalse, mode), target,
+ if_info->x, 0, OPTAB_WIDEN);
}
/* if (test) x = 8; else x = 0;
=> x = (test != 0) << 3; */
else if (ifalse == 0 && (tmp = exact_log2 (itrue)) >= 0)
{
target = expand_simple_binop (mode, ASHIFT,
@@ -1176,28 +1176,28 @@ noce_try_store_flag_constants (struct no
}
/* if (test) x = -1; else x = b;
=> x = -(test != 0) | b; */
else if (itrue == -1)
{
target = expand_simple_binop (mode, IOR,
- target, GEN_INT (ifalse), if_info->x, 0,
- OPTAB_WIDEN);
+ target, gen_int_mode (ifalse, mode),
+ if_info->x, 0, OPTAB_WIDEN);
}
/* if (test) x = a; else x = b;
=> x = (-(test != 0) & (b - a)) + a; */
else
{
target = expand_simple_binop (mode, AND,
- target, GEN_INT (diff), if_info->x, 0,
- OPTAB_WIDEN);
+ target, gen_int_mode (diff, mode),
+ if_info->x, 0, OPTAB_WIDEN);
if (target)
target = expand_simple_binop (mode, PLUS,
- target, GEN_INT (ifalse),
+ target, gen_int_mode (ifalse, mode),
if_info->x, 0, OPTAB_WIDEN);
}
if (! target)
{
end_sequence ();
return FALSE;
Index: gcc/loop-unroll.c
===================================================================
--- gcc/loop-unroll.c 2013-09-08 17:18:39.707590244 +0100
+++ gcc/loop-unroll.c 2013-09-09 10:55:59.757537404 +0100
@@ -1162,16 +1162,15 @@ unroll_loop_runtime_iterations (struct l
if (tmp != niter)
emit_move_insn (niter, tmp);
/* Count modulo by ANDing it with max_unroll; we use the fact that
the number of unrollings is a power of two, and thus this is correct
even if there is overflow in the computation. */
niter = expand_simple_binop (desc->mode, AND,
- niter,
- GEN_INT (max_unroll),
+ niter, gen_int_mode (max_unroll, desc->mode),
NULL_RTX, 0, OPTAB_LIB_WIDEN);
init_code = get_insns ();
end_sequence ();
unshare_all_rtl_in_chain (init_code);
/* Precondition the loop. */
Index: gcc/modulo-sched.c
===================================================================
--- gcc/modulo-sched.c 2013-09-09 10:49:45.230460851 +0100
+++ gcc/modulo-sched.c 2013-09-09 10:55:59.759537420 +0100
@@ -1144,16 +1144,17 @@ generate_prolog_epilog (partial_schedule
{
/* Generate instructions at the beginning of the prolog to
adjust the loop count by STAGE_COUNT. If loop count is constant
(count_init), this constant is adjusted by STAGE_COUNT in
generate_prolog_epilog function. */
rtx sub_reg = NULL_RTX;
- sub_reg = expand_simple_binop (GET_MODE (count_reg), MINUS,
- count_reg, GEN_INT (last_stage),
+ sub_reg = expand_simple_binop (GET_MODE (count_reg), MINUS, count_reg,
+ gen_int_mode (last_stage,
+ GET_MODE (count_reg)),
count_reg, 1, OPTAB_DIRECT);
gcc_assert (REG_P (sub_reg));
if (REGNO (sub_reg) != REGNO (count_reg))
emit_move_insn (count_reg, sub_reg);
}
for (i = 0; i < last_stage; i++)
Index: gcc/optabs.c
===================================================================
--- gcc/optabs.c 2013-09-08 17:18:39.707590244 +0100
+++ gcc/optabs.c 2013-09-09 10:55:59.760537428 +0100
@@ -1559,15 +1559,15 @@ expand_binop (enum machine_mode mode, op
if (CONST_INT_P (op1))
newop1 = GEN_INT (bits - INTVAL (op1));
else if (targetm.shift_truncation_mask (mode) == bits - 1)
newop1 = negate_rtx (GET_MODE (op1), op1);
else
newop1 = expand_binop (GET_MODE (op1), sub_optab,
- GEN_INT (bits), op1,
+ gen_int_mode (bits, GET_MODE (op1)), op1,
NULL_RTX, unsignedp, OPTAB_DIRECT);
temp = expand_binop_directly (mode, otheroptab, op0, newop1,
target, unsignedp, methods, last);
if (temp)
return temp;
}
@@ -2535,18 +2535,20 @@ widen_leading (enum machine_mode mode, r
if (target == 0)
target = gen_reg_rtx (mode);
xop0 = widen_operand (op0, wider_mode, mode,
unoptab != clrsb_optab, false);
temp = expand_unop (wider_mode, unoptab, xop0, NULL_RTX,
unoptab != clrsb_optab);
if (temp != 0)
- temp = expand_binop (wider_mode, sub_optab, temp,
- GEN_INT (GET_MODE_PRECISION (wider_mode)
- - GET_MODE_PRECISION (mode)),
- target, true, OPTAB_DIRECT);
+ temp = expand_binop
+ (wider_mode, sub_optab, temp,
+ gen_int_mode (GET_MODE_PRECISION (wider_mode)
+ - GET_MODE_PRECISION (mode),
+ wider_mode),
+ target, true, OPTAB_DIRECT);
if (temp == 0)
delete_insns_since (last);
return temp;
}
}
}
@@ -2597,15 +2599,15 @@ expand_doubleword_clz (enum machine_mode
of bits in the high word. */
emit_label (hi0_label);
temp = expand_unop_direct (word_mode, clz_optab, sublo, 0, true);
if (!temp)
goto fail;
temp = expand_binop (word_mode, add_optab, temp,
- GEN_INT (GET_MODE_BITSIZE (word_mode)),
+ gen_int_mode (GET_MODE_BITSIZE (word_mode), word_mode),
result, true, OPTAB_DIRECT);
if (!temp)
goto fail;
if (temp != result)
convert_move (result, temp, true);
emit_label (after_label);
@@ -2753,15 +2755,16 @@ expand_ctz (enum machine_mode mode, rtx
temp = expand_unop_direct (mode, neg_optab, op0, NULL_RTX, true);
if (temp)
temp = expand_binop (mode, and_optab, op0, temp, NULL_RTX,
true, OPTAB_DIRECT);
if (temp)
temp = expand_unop_direct (mode, clz_optab, temp, NULL_RTX, true);
if (temp)
- temp = expand_binop (mode, sub_optab, GEN_INT (GET_MODE_PRECISION (mode) -
1),
+ temp = expand_binop (mode, sub_optab,
+ gen_int_mode (GET_MODE_PRECISION (mode) - 1, mode),
temp, target,
true, OPTAB_DIRECT);
if (temp == 0)
{
end_sequence ();
return 0;
}
@@ -2834,15 +2837,15 @@ expand_ffs (enum machine_mode mode, rtx
convert_move (temp, GEN_INT (-1), false);
emit_label (nonzero_label);
}
/* temp now has a value in the range -1..bitsize-1. ffs is supposed
to produce a value in the range 0..bitsize. */
- temp = expand_binop (mode, add_optab, temp, GEN_INT (1),
+ temp = expand_binop (mode, add_optab, temp, gen_int_mode (1, mode),
target, false, OPTAB_DIRECT);
if (!temp)
goto fail;
seq = get_insns ();
end_sequence ();
@@ -3304,18 +3307,20 @@ expand_unop (enum machine_mode mode, opt
temp = expand_unop (wider_mode, unoptab, xop0, NULL_RTX,
unsignedp);
/* If we are generating clz using wider mode, adjust the
result. Similarly for clrsb. */
if ((unoptab == clz_optab || unoptab == clrsb_optab)
&& temp != 0)
- temp = expand_binop (wider_mode, sub_optab, temp,
- GEN_INT (GET_MODE_PRECISION (wider_mode)
- - GET_MODE_PRECISION (mode)),
- target, true, OPTAB_DIRECT);
+ temp = expand_binop
+ (wider_mode, sub_optab, temp,
+ gen_int_mode (GET_MODE_PRECISION (wider_mode)
+ - GET_MODE_PRECISION (mode),
+ wider_mode),
+ target, true, OPTAB_DIRECT);
/* Likewise for bswap. */
if (unoptab == bswap_optab && temp != 0)
{
gcc_assert (GET_MODE_PRECISION (wider_mode)
== GET_MODE_BITSIZE (wider_mode)
&& GET_MODE_PRECISION (mode)
