[2/4] Using gen_int_mode instead of GEN_INT

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.

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)