Patchwork [2/4] Using gen_int_mode instead of GEN_INT

login
register
mail settings
Submitter Richard Sandiford
Date Sept. 9, 2013, 10:24 a.m.
Message ID <87d2oigunj.fsf@talisman.default>
Download mbox | patch
Permalink /patch/273543/
State New
Headers show

Comments

Richard Sandiford - Sept. 9, 2013, 10:24 a.m.
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.
Richard Guenther - Sept. 9, 2013, 11:29 a.m.
On Mon, Sep 9, 2013 at 12:24 PM, Richard Sandiford
<rdsandiford@googlemail.com> wrote:
> Similar to patch 1, but here the calls are all to expand_* routines.
>
> Tested in the same way as before.  OK to install?

Ok.

Thanks,
Richard.

> 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)

Patch

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)