Hi!
As the testcase shows, we have some regressions in constexpr folding in GCC
5+.
One issue is that fold_binary_loc attempts to swap operands of comparison
operators only if one of them is constant, most of the optimizations in
there are written for constant in arg1 and therefore ok, but the two checks
have both operands non-constant and were just folding a.e + 1 != a.e and
not a.e + 1 != a.e.
Another issue is that fold_comparison does not optimize this, even when it
has code to do so. For ADDR_EXPR it uses get_inner_reference, but for
POINTER_PLUS_EXPR if the first operand of it is ADDR_EXPR does not use
get_inner_reference, therefore in this case we have base a in one case and
base a.e in another case.
Fixed thusly, bootstrapped/regtested on x86_64-linux and i686-linux, ok for
trunk?
2015-12-22 Jakub Jelinek <ja...@redhat.com>
PR c++/67376
* fold-const.c (size_low_cst): Removed.
(fold_comparison): For POINTER_PLUS_EXPR where base is ADDR_EXPR
call get_inner_reference and handle INDIRECT_REF base of it. Use
offset_int for computation of the bitpos.
(fold_binary_loc) <case EQ_EXPR, NE_EXPR>: Formatting
fixes for X +- Y CMP X and C - X CMP X folding. Add X CMP X +- Y
and X CMP C - X folding.
* g++.dg/cpp0x/constexpr-67376.C: New test.
--- gcc/fold-const.c.jj 2015-12-07 22:04:39.000000000 +0100
+++ gcc/fold-const.c 2015-12-22 14:18:50.099415697 +0100
@@ -8266,20 +8266,6 @@ pointer_may_wrap_p (tree base, tree offs
return total.to_uhwi () > (unsigned HOST_WIDE_INT) size;
}
-/* Return the HOST_WIDE_INT least significant bits of T, a sizetype
- kind INTEGER_CST. This makes sure to properly sign-extend the
- constant. */
-
-static HOST_WIDE_INT
-size_low_cst (const_tree t)
-{
- HOST_WIDE_INT w = TREE_INT_CST_ELT (t, 0);
- int prec = TYPE_PRECISION (TREE_TYPE (t));
- if (prec < HOST_BITS_PER_WIDE_INT)
- return sext_hwi (w, prec);
- return w;
-}
-
/* Subroutine of fold_binary. This routine performs all of the
transformations that are common to the equality/inequality
operators (EQ_EXPR and NE_EXPR) and the ordering operators
@@ -8408,18 +8394,30 @@ fold_comparison (location_t loc, enum tr
STRIP_SIGN_NOPS (base0);
if (TREE_CODE (base0) == ADDR_EXPR)
{
- base0 = TREE_OPERAND (base0, 0);
- indirect_base0 = true;
+ base0
+ = get_inner_reference (TREE_OPERAND (base0, 0),
+ &bitsize, &bitpos0, &offset0, &mode,
+ &unsignedp, &reversep, &volatilep,
+ false);
+ if (TREE_CODE (base0) == INDIRECT_REF)
+ base0 = TREE_OPERAND (base0, 0);
+ else
+ indirect_base0 = true;
}
- offset0 = TREE_OPERAND (arg0, 1);
- if (tree_fits_shwi_p (offset0))
- {
- HOST_WIDE_INT off = size_low_cst (offset0);
- if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
- * BITS_PER_UNIT)
- / BITS_PER_UNIT == (HOST_WIDE_INT) off)
+ if (offset0 == NULL_TREE || integer_zerop (offset0))
+ offset0 = TREE_OPERAND (arg0, 1);
+ else
+ offset0 = size_binop (PLUS_EXPR, offset0,
+ TREE_OPERAND (arg0, 1));
+ if (TREE_CODE (offset0) == INTEGER_CST)
+ {
+ offset_int tem = wi::sext (wi::to_offset (offset0),
+ TYPE_PRECISION (sizetype));
+ tem = wi::lshift (tem, LOG2_BITS_PER_UNIT);
+ tem += bitpos0;
+ if (wi::fits_shwi_p (tem))
{
- bitpos0 = off * BITS_PER_UNIT;
+ bitpos0 = tem.to_shwi ();
offset0 = NULL_TREE;
}
}
@@ -8443,18 +8441,30 @@ fold_comparison (location_t loc, enum tr
STRIP_SIGN_NOPS (base1);
if (TREE_CODE (base1) == ADDR_EXPR)
{
- base1 = TREE_OPERAND (base1, 0);
- indirect_base1 = true;
+ base1
+ = get_inner_reference (TREE_OPERAND (base1, 0),
+ &bitsize, &bitpos1, &offset1, &mode,
+ &unsignedp, &reversep, &volatilep,
+ false);
+ if (TREE_CODE (base1) == INDIRECT_REF)
+ base1 = TREE_OPERAND (base1, 0);
+ else
+ indirect_base1 = true;
}
- offset1 = TREE_OPERAND (arg1, 1);
- if (tree_fits_shwi_p (offset1))
- {
- HOST_WIDE_INT off = size_low_cst (offset1);
- if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
- * BITS_PER_UNIT)
- / BITS_PER_UNIT == (HOST_WIDE_INT) off)
+ if (offset1 == NULL_TREE || integer_zerop (offset1))
+ offset1 = TREE_OPERAND (arg1, 1);
+ else
+ offset1 = size_binop (PLUS_EXPR, offset1,
+ TREE_OPERAND (arg1, 1));
+ if (TREE_CODE (offset1) == INTEGER_CST)
+ {
+ offset_int tem = wi::sext (wi::to_offset (offset1),
+ TYPE_PRECISION (sizetype));
+ tem = wi::lshift (tem, LOG2_BITS_PER_UNIT);
+ tem += bitpos1;
+ if (wi::fits_shwi_p (tem))
{
- bitpos1 = off * BITS_PER_UNIT;
+ bitpos1 = tem.to_shwi ();
offset1 = NULL_TREE;
}
}
@@ -10547,12 +10557,27 @@ fold_binary_loc (location_t loc,
|| POINTER_TYPE_P (TREE_TYPE (arg0))))
{
tree val = TREE_OPERAND (arg0, 1);
- return omit_two_operands_loc (loc, type,
- fold_build2_loc (loc, code, type,
- val,
- build_int_cst (TREE_TYPE (val),
- 0)),
- TREE_OPERAND (arg0, 0), arg1);
+ val = fold_build2_loc (loc, code, type, val,
+ build_int_cst (TREE_TYPE (val), 0));
+ return omit_two_operands_loc (loc, type, val,
+ TREE_OPERAND (arg0, 0), arg1);
+ }
+
+ /* Transform comparisons of the form X CMP X +- Y to Y CMP 0. */
+ if ((TREE_CODE (arg1) == PLUS_EXPR
+ || TREE_CODE (arg1) == POINTER_PLUS_EXPR
+ || TREE_CODE (arg1) == MINUS_EXPR)
+ && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1,
+ 0)),
+ arg0, 0)
+ && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
+ || POINTER_TYPE_P (TREE_TYPE (arg1))))
+ {
+ tree val = TREE_OPERAND (arg1, 1);
+ val = fold_build2_loc (loc, code, type, val,
+ build_int_cst (TREE_TYPE (val), 0));
+ return omit_two_operands_loc (loc, type, val,
+ TREE_OPERAND (arg1, 0), arg0);
}
/* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
@@ -10562,12 +10587,22 @@ fold_binary_loc (location_t loc,
1)),
arg1, 0)
&& wi::extract_uhwi (TREE_OPERAND (arg0, 0), 0, 1) == 1)
- {
- return omit_two_operands_loc (loc, type,
- code == NE_EXPR
- ? boolean_true_node : boolean_false_node,
- TREE_OPERAND (arg0, 1), arg1);
- }
+ return omit_two_operands_loc (loc, type,
+ code == NE_EXPR
+ ? boolean_true_node : boolean_false_node,
+ TREE_OPERAND (arg0, 1), arg1);
+
+ /* Transform comparisons of the form X CMP C - X if C % 2 == 1. */
+ if (TREE_CODE (arg1) == MINUS_EXPR
+ && TREE_CODE (TREE_OPERAND (arg1, 0)) == INTEGER_CST
+ && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1,
+ 1)),
+ arg0, 0)
+ && wi::extract_uhwi (TREE_OPERAND (arg1, 0), 0, 1) == 1)
+ return omit_two_operands_loc (loc, type,
+ code == NE_EXPR
+ ? boolean_true_node : boolean_false_node,
+ TREE_OPERAND (arg1, 1), arg0);
/* If this is an EQ or NE comparison with zero and ARG0 is
(1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
--- gcc/testsuite/g++.dg/cpp0x/constexpr-67376.C.jj 2015-12-22
11:31:34.937974400 +0100
+++ gcc/testsuite/g++.dg/cpp0x/constexpr-67376.C 2015-12-22
14:21:51.678892129 +0100
@@ -0,0 +1,17 @@
+// PR c++/67376
+// { dg-do compile { target c++11 } }
+
+struct A { int e[2]; };
+constexpr A a { { 0, 1 } };
+static_assert (a.e + 1 != a.e, "");
+static_assert (a.e != a.e + 1, "");
+static_assert (a.e + 2 != a.e, "");
+static_assert (a.e != a.e + 2, "");
+static_assert (a.e + 1 > a.e, "");
+static_assert (a.e < a.e + 1, "");
+static_assert (a.e + 2 > a.e, "");
+static_assert (a.e < a.e + 2, "");
+static_assert (a.e + 1 >= a.e, "");
+static_assert (a.e <= a.e + 1, "");
+static_assert (a.e + 2 >= a.e, "");
+static_assert (a.e <= a.e + 2, "");
Jakub
