From: Richard Guenther <richard.guenther@gmail.com>
To: Anatoly Sokolov <aesok@post.ru>
Cc: gcc-patches@gcc.gnu.org
Subject: Re: Remove notrunc argument from the const_binop
Date: Wed, 23 Jun 2010 09:54:00 -0000 [thread overview]
Message-ID: <AANLkTinBFQ9OfdAm5JqNS_8oCQbtXGCiTBdcxNix4EYG@mail.gmail.com> (raw)
In-Reply-To: <796351358.20100623004007@post.ru>
2010/6/22 Anatoly Sokolov <aesok@post.ru>:
> Hi Richard.
>
> 2010/6/17 Richard Guenther:
>> If you don't have enough stuff on your list, something that I have
>> noticed again is the notrunc parameter to int_const_binop. It
>> ought to go and we should always truncate - I believe nearly
>> all callers call int_const_binop with zero ...
>
> In const_binop function the int_const_binop calls with non-zero notrunc
> argument, the notrunc argument of the const_binop propagate to the
> int_const_binop. But the const_binop itself calls with zero notrunc
> argument for all non recursive calls and propagate notrunc for recursive
> calls.
>
> Can me remove notrunc argument from the const_binop function?
I would say so.
> Bootstrapped/regtested on x86_64-unknown-linux-gnu for c, c++ and ada.
This is ok.
Thanks,
Richard.
> * fold-const.c (const_binop): Remove 'notrunc' argement. Adjust
> recursive call and call to 'int_const_binop.
> (build_range_check, fold_cond_expr_with_comparison, unextend,
> fold_truthop, extract_muldiv_1, fold_comparison, fold_binary_loc,
> multiple_of_p): Adjust calls to const_binop
>
>
> Index: gcc/fold-const.c
> ===================================================================
> --- gcc/fold-const.c (revision 161218)
> +++ gcc/fold-const.c (working copy)
> @@ -97,7 +97,7 @@
> static tree negate_expr (tree);
> static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
> static tree associate_trees (location_t, tree, tree, enum tree_code, tree);
> -static tree const_binop (enum tree_code, tree, tree, int);
> +static tree const_binop (enum tree_code, tree, tree);
> static enum comparison_code comparison_to_compcode (enum tree_code);
> static enum tree_code compcode_to_comparison (enum comparison_code);
> static int operand_equal_for_comparison_p (tree, tree, tree);
> @@ -1087,12 +1087,10 @@
> /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
> constant. We assume ARG1 and ARG2 have the same data type, or at least
> are the same kind of constant and the same machine mode. Return zero if
> - combining the constants is not allowed in the current operating mode.
> + combining the constants is not allowed in the current operating mode. */
>
> - If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
> -
> static tree
> -const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
> +const_binop (enum tree_code code, tree arg1, tree arg2)
> {
> /* Sanity check for the recursive cases. */
> if (!arg1 || !arg2)
> @@ -1102,7 +1100,7 @@
> STRIP_NOPS (arg2);
>
> if (TREE_CODE (arg1) == INTEGER_CST)
> - return int_const_binop (code, arg1, arg2, notrunc);
> + return int_const_binop (code, arg1, arg2, 0);
>
> if (TREE_CODE (arg1) == REAL_CST)
> {
> @@ -1236,8 +1234,8 @@
> {
> case PLUS_EXPR:
> case MINUS_EXPR:
> - real = const_binop (code, r1, r2, notrunc);
> - imag = const_binop (code, i1, i2, notrunc);
> + real = const_binop (code, r1, r2);
> + imag = const_binop (code, i1, i2);
> break;
>
> case MULT_EXPR:
> @@ -1247,13 +1245,11 @@
> mpc_mul);
>
> real = const_binop (MINUS_EXPR,
> - const_binop (MULT_EXPR, r1, r2, notrunc),
> - const_binop (MULT_EXPR, i1, i2, notrunc),
> - notrunc);
> + const_binop (MULT_EXPR, r1, r2),
> + const_binop (MULT_EXPR, i1, i2));
> imag = const_binop (PLUS_EXPR,
> - const_binop (MULT_EXPR, r1, i2, notrunc),
> - const_binop (MULT_EXPR, i1, r2, notrunc),
> - notrunc);
> + const_binop (MULT_EXPR, r1, i2),
> + const_binop (MULT_EXPR, i1, r2));
> break;
>
> case RDIV_EXPR:
> @@ -1277,22 +1273,19 @@
> */
> tree magsquared
> = const_binop (PLUS_EXPR,
> - const_binop (MULT_EXPR, r2, r2, notrunc),
> - const_binop (MULT_EXPR, i2, i2, notrunc),
> - notrunc);
> + const_binop (MULT_EXPR, r2, r2),
> + const_binop (MULT_EXPR, i2, i2));
> tree t1
> = const_binop (PLUS_EXPR,
> - const_binop (MULT_EXPR, r1, r2, notrunc),
> - const_binop (MULT_EXPR, i1, i2, notrunc),
> - notrunc);
> + const_binop (MULT_EXPR, r1, r2),
> + const_binop (MULT_EXPR, i1, i2));
> tree t2
> = const_binop (MINUS_EXPR,
> - const_binop (MULT_EXPR, i1, r2, notrunc),
> - const_binop (MULT_EXPR, r1, i2, notrunc),
> - notrunc);
> + const_binop (MULT_EXPR, i1, r2),
> + const_binop (MULT_EXPR, r1, i2));
>
> - real = const_binop (code, t1, magsquared, notrunc);
> - imag = const_binop (code, t2, magsquared, notrunc);
> + real = const_binop (code, t1, magsquared);
> + imag = const_binop (code, t2, magsquared);
> }
> else
> {
> @@ -1314,18 +1307,16 @@
> ti = (ai * ratio) - ar;
> tr = tr / div;
> ti = ti / div; */
> - tree ratio = const_binop (code, r2, i2, notrunc);
> + tree ratio = const_binop (code, r2, i2);
> tree div = const_binop (PLUS_EXPR, i2,
> - const_binop (MULT_EXPR, r2, ratio,
> - notrunc),
> - notrunc);
> - real = const_binop (MULT_EXPR, r1, ratio, notrunc);
> - real = const_binop (PLUS_EXPR, real, i1, notrunc);
> - real = const_binop (code, real, div, notrunc);
> + const_binop (MULT_EXPR, r2, ratio));
> + real = const_binop (MULT_EXPR, r1, ratio);
> + real = const_binop (PLUS_EXPR, real, i1);
> + real = const_binop (code, real, div);
>
> - imag = const_binop (MULT_EXPR, i1, ratio, notrunc);
> - imag = const_binop (MINUS_EXPR, imag, r1, notrunc);
> - imag = const_binop (code, imag, div, notrunc);
> + imag = const_binop (MULT_EXPR, i1, ratio);
> + imag = const_binop (MINUS_EXPR, imag, r1);
> + imag = const_binop (code, imag, div);
> }
> else
> {
> @@ -1336,19 +1327,17 @@
> ti = b - (a * ratio);
> tr = tr / div;
> ti = ti / div; */
> - tree ratio = const_binop (code, i2, r2, notrunc);
> + tree ratio = const_binop (code, i2, r2);
> tree div = const_binop (PLUS_EXPR, r2,
> - const_binop (MULT_EXPR, i2, ratio,
> - notrunc),
> - notrunc);
> + const_binop (MULT_EXPR, i2, ratio));
>
> - real = const_binop (MULT_EXPR, i1, ratio, notrunc);
> - real = const_binop (PLUS_EXPR, real, r1, notrunc);
> - real = const_binop (code, real, div, notrunc);
> + real = const_binop (MULT_EXPR, i1, ratio);
> + real = const_binop (PLUS_EXPR, real, r1);
> + real = const_binop (code, real, div);
>
> - imag = const_binop (MULT_EXPR, r1, ratio, notrunc);
> - imag = const_binop (MINUS_EXPR, i1, imag, notrunc);
> - imag = const_binop (code, imag, div, notrunc);
> + imag = const_binop (MULT_EXPR, r1, ratio);
> + imag = const_binop (MINUS_EXPR, i1, imag);
> + imag = const_binop (code, imag, div);
> }
> }
> break;
> @@ -1394,7 +1383,7 @@
> elements2 = TREE_CHAIN (elements2);
> }
>
> - elem = const_binop (code, elem1, elem2, notrunc);
> + elem = const_binop (code, elem1, elem2);
>
> /* It is possible that const_binop cannot handle the given
> code and return NULL_TREE */
> @@ -3490,9 +3479,9 @@
>
> /* Make the mask to be used against the extracted field. */
> mask = build_int_cst_type (unsigned_type, -1);
> - mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
> + mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize));
> mask = const_binop (RSHIFT_EXPR, mask,
> - size_int (nbitsize - lbitsize - lbitpos), 0);
> + size_int (nbitsize - lbitsize - lbitpos));
>
> if (! const_p)
> /* If not comparing with constant, just rework the comparison
> @@ -3525,7 +3514,7 @@
> if (! integer_zerop (const_binop (RSHIFT_EXPR,
> fold_convert_loc (loc,
> unsigned_type, rhs),
> - size_int (lbitsize), 0)))
> + size_int (lbitsize))))
> {
> warning (0, "comparison is always %d due to width of bit-field",
> code == NE_EXPR);
> @@ -3536,7 +3525,7 @@
> {
> tree tem = const_binop (RSHIFT_EXPR,
> fold_convert_loc (loc, signed_type, rhs),
> - size_int (lbitsize - 1), 0);
> + size_int (lbitsize - 1));
> if (! integer_zerop (tem) && ! integer_all_onesp (tem))
> {
> warning (0, "comparison is always %d due to width of bit-field",
> @@ -3565,8 +3554,8 @@
> rhs = const_binop (BIT_AND_EXPR,
> const_binop (LSHIFT_EXPR,
> fold_convert_loc (loc, unsigned_type, rhs),
> - size_int (lbitpos), 0),
> - mask, 0);
> + size_int (lbitpos)),
> + mask);
>
> lhs = build2 (code, compare_type,
> build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
> @@ -3652,8 +3641,8 @@
>
> mask = build_int_cst_type (unsigned_type, -1);
>
> - mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
> - mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
> + mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize));
> + mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize));
>
> /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
> if (and_mask != 0)
> @@ -3681,9 +3670,8 @@
> tree_int_cst_equal (mask,
> const_binop (RSHIFT_EXPR,
> const_binop (LSHIFT_EXPR, tmask,
> - size_int (precision - size),
> - 0),
> - size_int (precision - size), 0));
> + size_int (precision - size)),
> + size_int (precision - size)));
> }
>
> /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
> @@ -4283,7 +4271,7 @@
> low = fold_convert_loc (loc, etype, low);
> exp = fold_convert_loc (loc, etype, exp);
>
> - value = const_binop (MINUS_EXPR, high, low, 0);
> + value = const_binop (MINUS_EXPR, high, low);
>
>
> if (POINTER_TYPE_P (etype))
> @@ -4786,7 +4774,7 @@
> OEP_ONLY_CONST)
> && operand_equal_p (arg01,
> const_binop (PLUS_EXPR, arg2,
> - build_int_cst (type, 1), 0),
> + build_int_cst (type, 1)),
> OEP_ONLY_CONST))
> {
> tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
> @@ -4804,7 +4792,7 @@
> OEP_ONLY_CONST)
> && operand_equal_p (arg01,
> const_binop (MINUS_EXPR, arg2,
> - build_int_cst (type, 1), 0),
> + build_int_cst (type, 1)),
> OEP_ONLY_CONST))
> {
> tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
> @@ -4822,7 +4810,7 @@
> OEP_ONLY_CONST)
> && operand_equal_p (arg01,
> const_binop (MINUS_EXPR, arg2,
> - build_int_cst (type, 1), 0),
> + build_int_cst (type, 1)),
> OEP_ONLY_CONST))
> {
> tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
> @@ -4838,7 +4826,7 @@
> OEP_ONLY_CONST)
> && operand_equal_p (arg01,
> const_binop (PLUS_EXPR, arg2,
> - build_int_cst (type, 1), 0),
> + build_int_cst (type, 1)),
> OEP_ONLY_CONST))
> {
> tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
> @@ -4970,8 +4958,8 @@
> /* We work by getting just the sign bit into the low-order bit, then
> into the high-order bit, then sign-extend. We then XOR that value
> with C. */
> - temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
> - temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
> + temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1));
> + temp = const_binop (BIT_AND_EXPR, temp, size_int (1));
>
> /* We must use a signed type in order to get an arithmetic right shift.
> However, we must also avoid introducing accidental overflows, so that
> @@ -4982,18 +4970,16 @@
> if (TYPE_UNSIGNED (type))
> temp = fold_convert (signed_type_for (type), temp);
>
> - temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
> - temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
> + temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1));
> + temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1));
> if (mask != 0)
> temp = const_binop (BIT_AND_EXPR, temp,
> - fold_convert (TREE_TYPE (c), mask),
> - 0);
> + fold_convert (TREE_TYPE (c), mask));
> /* If necessary, convert the type back to match the type of C. */
> if (TYPE_UNSIGNED (type))
> temp = fold_convert (type, temp);
>
> - return fold_convert (type,
> - const_binop (BIT_XOR_EXPR, c, temp, 0));
> + return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp));
> }
>
> /* For an expression that has the form
> @@ -5330,19 +5316,18 @@
> }
>
> ll_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, ll_mask),
> - size_int (xll_bitpos), 0);
> + size_int (xll_bitpos));
> rl_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, rl_mask),
> - size_int (xrl_bitpos), 0);
> + size_int (xrl_bitpos));
>
> if (l_const)
> {
> l_const = fold_convert_loc (loc, lntype, l_const);
> l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
> - l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
> + l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos));
> if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
> fold_build1_loc (loc, BIT_NOT_EXPR,
> - lntype, ll_mask),
> - 0)))
> + lntype, ll_mask))))
> {
> warning (0, "comparison is always %d", wanted_code == NE_EXPR);
>
> @@ -5353,11 +5338,10 @@
> {
> r_const = fold_convert_loc (loc, lntype, r_const);
> r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
> - r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
> + r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos));
> if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
> fold_build1_loc (loc, BIT_NOT_EXPR,
> - lntype, rl_mask),
> - 0)))
> + lntype, rl_mask))))
> {
> warning (0, "comparison is always %d", wanted_code == NE_EXPR);
>
> @@ -5398,18 +5382,18 @@
>
> lr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
> rntype, lr_mask),
> - size_int (xlr_bitpos), 0);
> + size_int (xlr_bitpos));
> rr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
> rntype, rr_mask),
> - size_int (xrr_bitpos), 0);
> + size_int (xrr_bitpos));
>
> /* Make a mask that corresponds to both fields being compared.
> Do this for both items being compared. If the operands are the
> same size and the bits being compared are in the same position
> then we can do this by masking both and comparing the masked
> results. */
> - ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
> - lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
> + ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
> + lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask);
> if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
> {
> lhs = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
> @@ -5448,9 +5432,9 @@
> MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
>
> ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
> - size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
> + size_int (MIN (xll_bitpos, xrl_bitpos)));
> lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
> - size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
> + size_int (MIN (xlr_bitpos, xrr_bitpos)));
>
> /* Convert to the smaller type before masking out unwanted bits. */
> type = lntype;
> @@ -5487,10 +5471,10 @@
> common between the masks, those bits of the constants must be the same.
> If not, the condition is always false. Test for this to avoid generating
> incorrect code below. */
> - result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
> + result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask);
> if (! integer_zerop (result)
> - && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
> - const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
> + && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const),
> + const_binop (BIT_AND_EXPR, result, r_const)) != 1)
> {
> if (wanted_code == NE_EXPR)
> {
> @@ -5511,7 +5495,7 @@
> result = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
> ll_unsignedp || rl_unsignedp);
>
> - ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
> + ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
> if (! all_ones_mask_p (ll_mask, lnbitsize))
> {
> result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
> @@ -5519,7 +5503,7 @@
> }
>
> result = build2 (wanted_code, truth_type, result,
> - const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
> + const_binop (BIT_IOR_EXPR, l_const, r_const));
>
> fold_truthop_exit:
> SET_EXPR_LOCATION (result, loc);
> @@ -5702,9 +5686,9 @@
> /* For a constant, we can always simplify if we are a multiply
> or (for divide and modulus) if it is a multiple of our constant. */
> if (code == MULT_EXPR
> - || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
> + || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c)))
> return const_binop (code, fold_convert (ctype, t),
> - fold_convert (ctype, c), 0);
> + fold_convert (ctype, c));
> break;
>
> CASE_CONVERT: case NON_LVALUE_EXPR:
> @@ -5812,7 +5796,7 @@
> && 0 != (t1 = fold_convert (ctype,
> const_binop (LSHIFT_EXPR,
> size_one_node,
> - op1, 0)))
> + op1)))
> && !TREE_OVERFLOW (t1))
> return extract_muldiv (build2 (tcode == LSHIFT_EXPR
> ? MULT_EXPR : FLOOR_DIV_EXPR,
> @@ -5880,10 +5864,10 @@
> /* If it's a multiply or a division/modulus operation of a multiple
> of our constant, do the operation and verify it doesn't overflow. */
> if (code == MULT_EXPR
> - || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
> + || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
> {
> op1 = const_binop (code, fold_convert (ctype, op1),
> - fold_convert (ctype, c), 0);
> + fold_convert (ctype, c));
> /* We allow the constant to overflow with wrapping semantics. */
> if (op1 == 0
> || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
> @@ -5931,7 +5915,7 @@
> || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
> && TYPE_IS_SIZETYPE (TREE_TYPE (t))))
> && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
> - && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
> + && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
> {
> *strict_overflow_p = true;
> return omit_one_operand (type, integer_zero_node, op0);
> @@ -5987,23 +5971,23 @@
> && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
> && code != MULT_EXPR)))
> {
> - if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
> + if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
> {
> if (TYPE_OVERFLOW_UNDEFINED (ctype))
> *strict_overflow_p = true;
> return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
> fold_convert (ctype,
> const_binop (TRUNC_DIV_EXPR,
> - op1, c, 0)));
> + op1, c)));
> }
> - else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
> + else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1)))
> {
> if (TYPE_OVERFLOW_UNDEFINED (ctype))
> *strict_overflow_p = true;
> return fold_build2 (code, ctype, fold_convert (ctype, op0),
> fold_convert (ctype,
> const_binop (TRUNC_DIV_EXPR,
> - c, op1, 0)));
> + c, op1)));
> }
> }
> break;
> @@ -9015,7 +8999,7 @@
> && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
> && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
> ? MINUS_EXPR : PLUS_EXPR,
> - arg1, TREE_OPERAND (arg0, 1), 0))
> + arg1, TREE_OPERAND (arg0, 1)))
> && !TREE_OVERFLOW (tem))
> return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
>
> @@ -9028,7 +9012,7 @@
> && TREE_CODE (arg0) == MINUS_EXPR
> && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
> && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
> - arg1, 0))
> + arg1))
> && !TREE_OVERFLOW (tem))
> return fold_build2_loc (loc, swap_tree_comparison (code), type,
> TREE_OPERAND (arg0, 1), tem);
> @@ -9449,7 +9433,7 @@
> /* Make sure type and arg0 have the same saturating flag. */
> gcc_assert (TYPE_SATURATING (type)
> == TYPE_SATURATING (TREE_TYPE (arg0)));
> - tem = const_binop (code, arg0, arg1, 0);
> + tem = const_binop (code, arg0, arg1);
> }
> else if (kind == tcc_comparison)
> tem = fold_relational_const (code, type, arg0, arg1);
> @@ -9708,7 +9692,7 @@
> && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
> && integer_zerop (const_binop (BIT_AND_EXPR,
> TREE_OPERAND (arg0, 1),
> - TREE_OPERAND (arg1, 1), 0)))
> + TREE_OPERAND (arg1, 1))))
> {
> code = BIT_IOR_EXPR;
> goto bit_ior;
> @@ -10430,7 +10414,7 @@
> && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
> {
> tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
> - arg1, 0);
> + arg1);
> if (tem)
> return fold_build2_loc (loc, RDIV_EXPR, type, tem,
> TREE_OPERAND (arg0, 1));
> @@ -10799,7 +10783,7 @@
> && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
> && integer_zerop (const_binop (BIT_AND_EXPR,
> TREE_OPERAND (arg0, 1),
> - TREE_OPERAND (arg1, 1), 0)))
> + TREE_OPERAND (arg1, 1))))
> {
> code = BIT_IOR_EXPR;
> goto bit_ior;
> @@ -11255,7 +11239,7 @@
> {
> if (flag_reciprocal_math
> && 0 != (tem = const_binop (code, build_real (type, dconst1),
> - arg1, 0)))
> + arg1)))
> return fold_build2_loc (loc, MULT_EXPR, type, arg0, tem);
> /* Find the reciprocal if optimizing and the result is exact. */
> if (optimize)
> @@ -11292,7 +11276,7 @@
> && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
> {
> tree tem = const_binop (RDIV_EXPR, arg0,
> - TREE_OPERAND (arg1, 1), 0);
> + TREE_OPERAND (arg1, 1));
> if (tem)
> return fold_build2_loc (loc, RDIV_EXPR, type, tem,
> TREE_OPERAND (arg1, 0));
> @@ -11727,7 +11711,7 @@
> {
> tree tem = build_int_cst (TREE_TYPE (arg1),
> TYPE_PRECISION (type));
> - tem = const_binop (MINUS_EXPR, tem, arg1, 0);
> + tem = const_binop (MINUS_EXPR, tem, arg1);
> return fold_build2_loc (loc, RROTATE_EXPR, type, op0, tem);
> }
>
> @@ -12074,7 +12058,7 @@
> ? MINUS_EXPR : PLUS_EXPR,
> fold_convert_loc (loc, TREE_TYPE (arg0),
> arg1),
> - TREE_OPERAND (arg0, 1), 0))
> + TREE_OPERAND (arg0, 1)))
> && !TREE_OVERFLOW (tem))
> return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
>
> @@ -12810,14 +12794,14 @@
> {
> case GT_EXPR:
> arg1 = const_binop (PLUS_EXPR, arg1,
> - build_int_cst (TREE_TYPE (arg1), 1), 0);
> + build_int_cst (TREE_TYPE (arg1), 1));
> return fold_build2_loc (loc, EQ_EXPR, type,
> fold_convert_loc (loc,
> TREE_TYPE (arg1), arg0),
> arg1);
> case LE_EXPR:
> arg1 = const_binop (PLUS_EXPR, arg1,
> - build_int_cst (TREE_TYPE (arg1), 1), 0);
> + build_int_cst (TREE_TYPE (arg1), 1));
> return fold_build2_loc (loc, NE_EXPR, type,
> fold_convert_loc (loc, TREE_TYPE (arg1),
> arg0),
> @@ -12851,13 +12835,13 @@
> switch (code)
> {
> case GE_EXPR:
> - arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
> + arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
> return fold_build2_loc (loc, NE_EXPR, type,
> fold_convert_loc (loc,
> TREE_TYPE (arg1), arg0),
> arg1);
> case LT_EXPR:
> - arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
> + arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
> return fold_build2_loc (loc, EQ_EXPR, type,
> fold_convert_loc (loc, TREE_TYPE (arg1),
> arg0),
> @@ -14176,7 +14160,7 @@
> && 0 != (t1 = fold_convert (type,
> const_binop (LSHIFT_EXPR,
> size_one_node,
> - op1, 0)))
> + op1)))
> && !TREE_OVERFLOW (t1))
> return multiple_of_p (type, t1, bottom);
> }
>
>
> Anatoly.
>
>
prev parent reply other threads:[~2010-06-23 9:17 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2010-06-22 22:07 Anatoly Sokolov
2010-06-23 9:54 ` Richard Guenther [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=AANLkTinBFQ9OfdAm5JqNS_8oCQbtXGCiTBdcxNix4EYG@mail.gmail.com \
--to=richard.guenther@gmail.com \
--cc=aesok@post.ru \
--cc=gcc-patches@gcc.gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).