Fix mismatched precisions in tree arithmetic

The tree wi:: decompose routine wasn't asserting that the requested
precision matched the tree's precision.  This could make a difference
for unsigned trees that are exactly N HWIs wide and that have the upper
bit set, since we then need an extra zero HWI when extending it to wider
precisions (as for wi::to_widest).

This patch adds the assert and fixes the fallout shown by the testsuite.
Go seems to be unaffected.

Other fixed-precision decompose routines already had an assert.

Tested on aarch64-linux-gnu, x86_64-linux-gnu and powerpc64le-linux-gnu.
Also tested by comparing the testsuite assembly output on at least one
target per CPU directory.  OK to install?

Richard


2017-10-01  Richard Sandiford  <richard.sandiford@linaro.org>

gcc/
	* tree.h (wi::int_traits <const_tree>::decompose): Assert that the
	requested precision matches the type's.
	* calls.c (alloc_max_size): Calculate the new candidate size as
	a widest_int and use wi::to_widest when comparing it with the
	current candidate size.
	* gimple-ssa-warn-alloca.c (pass_walloca::execute): Compare with
	zero rather than integer_zero_node.
	* match.pd: Check for a no-op conversion before using wi::add
	rather than after.  Use tree_to_uhwi when summing small shift
	counts into an unsigned int.

gcc/c-family/
	* c-warn.c (warn_tautological_bitwise_comparison): Use wi::to_widest
	when combining the original unconverted comparison operands.

gcc/cp/
	* constexpr.c (cxx_eval_store_expression): Use wi::to_widest
	when comparing the array bounds with an ARRAY_REF index.

gcc/ada/
	* gcc-interface/decl.c (annotate_value): Use wi::to_widest when
	handling the form (plus/mult (convert @0) @1).

On Sun, Oct 1, 2017 at 6:13 PM, Richard Sandiford
<richard.sandiford@linaro.org> wrote:
> The tree wi:: decompose routine wasn't asserting that the requested
> precision matched the tree's precision.  This could make a difference
> for unsigned trees that are exactly N HWIs wide and that have the upper
> bit set, since we then need an extra zero HWI when extending it to wider
> precisions (as for wi::to_widest).
>
> This patch adds the assert and fixes the fallout shown by the testsuite.
> Go seems to be unaffected.
>
> Other fixed-precision decompose routines already had an assert.
>
> Tested on aarch64-linux-gnu, x86_64-linux-gnu and powerpc64le-linux-gnu.
> Also tested by comparing the testsuite assembly output on at least one
> target per CPU directory.  OK to install?

Ok.

Thanks,
Richard.

> Richard
>
>
> 2017-10-01  Richard Sandiford  <richard.sandiford@linaro.org>
>
> gcc/
>         * tree.h (wi::int_traits <const_tree>::decompose): Assert that the
>         requested precision matches the type's.
>         * calls.c (alloc_max_size): Calculate the new candidate size as
>         a widest_int and use wi::to_widest when comparing it with the
>         current candidate size.
>         * gimple-ssa-warn-alloca.c (pass_walloca::execute): Compare with
>         zero rather than integer_zero_node.
>         * match.pd: Check for a no-op conversion before using wi::add
>         rather than after.  Use tree_to_uhwi when summing small shift
>         counts into an unsigned int.
>
> gcc/c-family/
>         * c-warn.c (warn_tautological_bitwise_comparison): Use wi::to_widest
>         when combining the original unconverted comparison operands.
>
> gcc/cp/
>         * constexpr.c (cxx_eval_store_expression): Use wi::to_widest
>         when comparing the array bounds with an ARRAY_REF index.
>
> gcc/ada/
>         * gcc-interface/decl.c (annotate_value): Use wi::to_widest when
>         handling the form (plus/mult (convert @0) @1).
>
> Index: gcc/tree.h
> ===================================================================
> --- gcc/tree.h  2017-09-25 13:33:39.989814299 +0100
> +++ gcc/tree.h  2017-10-01 17:08:55.827120507 +0100
> @@ -5176,6 +5176,7 @@ wi::int_traits <const_tree>::get_precisi
>  wi::int_traits <const_tree>::decompose (HOST_WIDE_INT *,
>                                         unsigned int precision, const_tree x)
>  {
> +  gcc_checking_assert (precision == TYPE_PRECISION (TREE_TYPE (x)));
>    return wi::storage_ref (&TREE_INT_CST_ELT (x, 0), TREE_INT_CST_NUNITS (x),
>                           precision);
>  }
> Index: gcc/calls.c
> ===================================================================
> --- gcc/calls.c 2017-09-21 12:13:48.336399601 +0100
> +++ gcc/calls.c 2017-10-01 17:08:55.825112782 +0100
> @@ -1252,9 +1252,8 @@ alloc_max_size (void)
>
>               if (unit)
>                 {
> -                 wide_int w = wi::uhwi (limit, HOST_BITS_PER_WIDE_INT + 64);
> -                 w *= unit;
> -                 if (wi::ltu_p (w, alloc_object_size_limit))
> +                 widest_int w = wi::mul (limit, unit);
> +                 if (w < wi::to_widest (alloc_object_size_limit))
>                     alloc_object_size_limit = wide_int_to_tree (ssizetype, w);
>                 }
>             }
> Index: gcc/gimple-ssa-warn-alloca.c
> ===================================================================
> --- gcc/gimple-ssa-warn-alloca.c        2017-03-28 16:19:28.000000000 +0100
> +++ gcc/gimple-ssa-warn-alloca.c        2017-10-01 17:08:55.826116645 +0100
> @@ -491,7 +491,7 @@ pass_walloca::execute (function *fun)
>                               is_vla ? G_("argument to variable-length array "
>                                           "may be too large")
>                               : G_("argument to %<alloca%> may be too large"))
> -                 && t.limit != integer_zero_node)
> +                 && t.limit != 0)
>                 {
>                   print_decu (t.limit, buff);
>                   inform (loc, G_("limit is %u bytes, but argument "
> @@ -504,7 +504,7 @@ pass_walloca::execute (function *fun)
>                               is_vla ? G_("argument to variable-length array "
>                                           "is too large")
>                               : G_("argument to %<alloca%> is too large"))
> -                 && t.limit != integer_zero_node)
> +                 && t.limit != 0)
>                 {
>                   print_decu (t.limit, buff);
>                   inform (loc, G_("limit is %u bytes, but argument is %s"),
> Index: gcc/match.pd
> ===================================================================
> --- gcc/match.pd        2017-09-25 13:57:11.698158636 +0100
> +++ gcc/match.pd        2017-10-01 17:08:55.827120507 +0100
> @@ -358,8 +358,8 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
>    (div (convert? (bit_and @0 INTEGER_CST@1)) INTEGER_CST@2)
>    (if (integer_pow2p (@2)
>         && tree_int_cst_sgn (@2) > 0
> -       && wi::add (@2, @1) == 0
> -       && tree_nop_conversion_p (type, TREE_TYPE (@0)))
> +       && tree_nop_conversion_p (type, TREE_TYPE (@0))
> +       && wi::add (@2, @1) == 0)
>     (rshift (convert @0) { build_int_cst (integer_type_node,
>                                          wi::exact_log2 (@2)); }))))
>
> @@ -1871,7 +1871,8 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
>          && wi::lt_p (@1, prec, TYPE_SIGN (TREE_TYPE (@1)))
>          && wi::ge_p (@2, 0, TYPE_SIGN (TREE_TYPE (@2)))
>         && wi::lt_p (@2, prec, TYPE_SIGN (TREE_TYPE (@2))))
> -    (with { unsigned int low = wi::add (@1, @2).to_uhwi (); }
> +    (with { unsigned int low = (tree_to_uhwi (@1)
> +                               + tree_to_uhwi (@2)); }
>       /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
>          being well defined.  */
>       (if (low >= prec)
> Index: gcc/c-family/c-warn.c
> ===================================================================
> --- gcc/c-family/c-warn.c       2017-09-05 20:55:56.402037612 +0100
> +++ gcc/c-family/c-warn.c       2017-10-01 17:08:55.824108920 +0100
> @@ -355,15 +355,17 @@ warn_tautological_bitwise_comparison (lo
>    else
>      return;
>
> -  wide_int res;
> +  /* Note that the two operands are from before the usual integer
> +     conversions, so their types might not be the same.  */
> +  widest_int res;
>    if (TREE_CODE (bitop) == BIT_AND_EXPR)
> -    res = wi::bit_and (bitopcst, cst);
> +    res = wi::to_widest (bitopcst) & wi::to_widest (cst);
>    else
> -    res = wi::bit_or (bitopcst, cst);
> +    res = wi::to_widest (bitopcst) | wi::to_widest (cst);
>
>    /* For BIT_AND only warn if (CST2 & CST1) != CST1, and
>       for BIT_OR only if (CST2 | CST1) != CST1.  */
> -  if (res == cst)
> +  if (res == wi::to_widest (cst))
>      return;
>
>    if (code == EQ_EXPR)
> Index: gcc/cp/constexpr.c
> ===================================================================
> --- gcc/cp/constexpr.c  2017-09-16 21:38:21.073925724 +0100
> +++ gcc/cp/constexpr.c  2017-10-01 17:08:55.826116645 +0100
> @@ -3379,7 +3379,7 @@ cxx_eval_store_expression (const constex
>           VERIFY_CONSTANT (nelts);
>           gcc_assert (TREE_CODE (nelts) == INTEGER_CST
>                       && TREE_CODE (TREE_OPERAND (probe, 1)) == INTEGER_CST);
> -         if (wi::eq_p (TREE_OPERAND (probe, 1), nelts))
> +         if (wi::to_widest (TREE_OPERAND (probe, 1)) == wi::to_widest (nelts))
>             {
>               diag_array_subscript (ctx, ary, TREE_OPERAND (probe, 1));
>               *non_constant_p = true;
> Index: gcc/ada/gcc-interface/decl.c
> ===================================================================
> --- gcc/ada/gcc-interface/decl.c        2017-09-11 17:10:55.549140040 +0100
> +++ gcc/ada/gcc-interface/decl.c        2017-10-01 17:08:55.823105057 +0100
> @@ -8153,11 +8153,13 @@ annotate_value (tree gnu_size)
>             {
>               tree inner_op_op1 = TREE_OPERAND (inner_op, 1);
>               tree gnu_size_op1 = TREE_OPERAND (gnu_size, 1);
> -             wide_int op1;
> +             widest_int op1;
>               if (TREE_CODE (gnu_size) == MULT_EXPR)
> -               op1 = wi::mul (inner_op_op1, gnu_size_op1);
> +               op1 = (wi::to_widest (inner_op_op1)
> +                      * wi::to_widest (gnu_size_op1));
>               else
> -               op1 = wi::add (inner_op_op1, gnu_size_op1);
> +               op1 = (wi::to_widest (inner_op_op1)
> +                      + wi::to_widest (gnu_size_op1));
>               ops[1] = UI_From_gnu (wide_int_to_tree (sizetype, op1));
>               ops[0] = annotate_value (TREE_OPERAND (inner_op, 0));
>             }