On Sun, Oct 1, 2017 at 6:13 PM, Richard Sandiford
<richard.sandif...@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.sandif...@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));
> }
