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.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)); }