Add a wi::to_wide helper function

As Richard says, we ought to have a convenient way of converting
an INTEGER_CST to a wide_int of a particular precision without
having to extract the sign of the INTEGER_CST's type each time.
This patch adds a wi::to_wide helper for that, alongside the
existing wi::to_offset and wi::to_widest.

Tested on x86_64-linux-gnu and aarch64-linux-gnu.  OK to install?

Thanks,
Richard


gcc/
	* tree.h (wi::to_wide): New function.
	* expr.c (expand_expr_real_1): Use wi::to_wide.
	* fold-const.c (int_const_binop_1): Likewise.
	(extract_muldiv_1): Likewise.

gcc/c-family/
	* c-common.c (shorten_compare): Use wi::to_wide.

On Fri, Apr 29, 2016 at 2:32 PM, Richard Sandiford
<richard.sandiford@arm.com> wrote:
> As Richard says, we ought to have a convenient way of converting
> an INTEGER_CST to a wide_int of a particular precision without
> having to extract the sign of the INTEGER_CST's type each time.
> This patch adds a wi::to_wide helper for that, alongside the
> existing wi::to_offset and wi::to_widest.
>
> Tested on x86_64-linux-gnu and aarch64-linux-gnu.  OK to install?

Ok.

Thanks,
Richard.

> Thanks,
> Richard
>
>
> gcc/
>         * tree.h (wi::to_wide): New function.
>         * expr.c (expand_expr_real_1): Use wi::to_wide.
>         * fold-const.c (int_const_binop_1): Likewise.
>         (extract_muldiv_1): Likewise.
>
> gcc/c-family/
>         * c-common.c (shorten_compare): Use wi::to_wide.
>
> Index: gcc/tree.h
> ===================================================================
> --- gcc/tree.h
> +++ gcc/tree.h
> @@ -5211,6 +5211,8 @@ namespace wi
>    to_widest (const_tree);
>
>    generic_wide_int <extended_tree <ADDR_MAX_PRECISION> > to_offset (const_tree);
> +
> +  wide_int to_wide (const_tree, unsigned int);
>  }
>
>  inline unsigned int
> @@ -5240,6 +5242,16 @@ wi::to_offset (const_tree t)
>    return t;
>  }
>
> +/* Convert INTEGER_CST T to a wide_int of precision PREC, extending or
> +   truncating as necessary.  When extending, use sign extension if T's
> +   type is signed and zero extension if T's type is unsigned.  */
> +
> +inline wide_int
> +wi::to_wide (const_tree t, unsigned int prec)
> +{
> +  return wide_int::from (t, prec, TYPE_SIGN (TREE_TYPE (t)));
> +}
> +
>  template <int N>
>  inline wi::extended_tree <N>::extended_tree (const_tree t)
>    : m_t (t)
> Index: gcc/expr.c
> ===================================================================
> --- gcc/expr.c
> +++ gcc/expr.c
> @@ -9729,10 +9729,9 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
>           GET_MODE_PRECISION (TYPE_MODE (type)), we need to extend from
>           the former to the latter according to the signedness of the
>           type. */
> -      temp = immed_wide_int_const (wide_int::from
> +      temp = immed_wide_int_const (wi::to_wide
>                                    (exp,
> -                                   GET_MODE_PRECISION (TYPE_MODE (type)),
> -                                   TYPE_SIGN (type)),
> +                                   GET_MODE_PRECISION (TYPE_MODE (type))),
>                                    TYPE_MODE (type));
>        return temp;
>
> Index: gcc/fold-const.c
> ===================================================================
> --- gcc/fold-const.c
> +++ gcc/fold-const.c
> @@ -963,8 +963,7 @@ int_const_binop_1 (enum tree_code code, const_tree arg1, const_tree parg2,
>    signop sign = TYPE_SIGN (type);
>    bool overflow = false;
>
> -  wide_int arg2 = wide_int::from (parg2, TYPE_PRECISION (type),
> -                                 TYPE_SIGN (TREE_TYPE (parg2)));
> +  wide_int arg2 = wi::to_wide (parg2, TYPE_PRECISION (type));
>
>    switch (code)
>      {
> @@ -6394,10 +6393,8 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
>           bool overflow_mul_p;
>           signop sign = TYPE_SIGN (ctype);
>           unsigned prec = TYPE_PRECISION (ctype);
> -         wide_int mul = wi::mul (wide_int::from (op1, prec,
> -                                                 TYPE_SIGN (TREE_TYPE (op1))),
> -                                 wide_int::from (c, prec,
> -                                                 TYPE_SIGN (TREE_TYPE (c))),
> +         wide_int mul = wi::mul (wi::to_wide (op1, prec),
> +                                 wi::to_wide (c, prec),
>                                   sign, &overflow_mul_p);
>           overflow_p = TREE_OVERFLOW (c) | TREE_OVERFLOW (op1);
>           if (overflow_mul_p
> Index: gcc/c-family/c-common.c
> ===================================================================
> --- gcc/c-family/c-common.c
> +++ gcc/c-family/c-common.c
> @@ -4012,10 +4012,9 @@ shorten_compare (location_t loc, tree *op0_ptr, tree *op1_ptr,
>           /* Convert primop1 to target type, but do not introduce
>              additional overflow.  We know primop1 is an int_cst.  */
>           primop1 = force_fit_type (*restype_ptr,
> -                                   wide_int::from
> -                                     (primop1,
> -                                      TYPE_PRECISION (*restype_ptr),
> -                                      TYPE_SIGN (TREE_TYPE (primop1))),
> +                                   wi::to_wide
> +                                    (primop1,
> +                                     TYPE_PRECISION (*restype_ptr)),
>                                     0, TREE_OVERFLOW (primop1));
>         }
>        if (type != *restype_ptr)