Re: Allow some NOP conversions in (X+CST1)+CST2 in match.pd

[Jakub Jelinek <jakub@redhat.com>]

On Sun, May 21, 2017 at 09:22:56PM +0200, Marc Glisse wrote:
> generalizing a bit one transformation, to avoid a regression with another
> patch I am working on. Handling conversions always gets messy :-( It would
> have been easier to stick to scalars and wide_int, but since the existing
> transformation handles vectors, I didn't want to regress.
> 
> Bootstrap+testsuite on powerpc64le-unknown-linux-gnu.
> 
> 2017-05-22  Marc Glisse  <marc.glisse@inria.fr>
> 
> gcc/
> 	* match.pd ((A +- CST1) +- CST2): Allow some conversions.
> 	* tree.c (drop_tree_overflow): Handle COMPLEX_CST and VECTOR_CST.
> 
> gcc/testsuite/
> 	* gcc.dg/tree-ssa/addadd.c: New file.

After discussions in PR80887, I've reverted the match.pd part and xfailed
the test, because it breaks bootstrap and will take a while to resolve
properly.

2017-05-27  Jakub Jelinek  <jakub@redhat.com>

	PR bootstrap/80887
	Revert:
	2017-05-25  Marc Glisse  <marc.glisse@inria.fr>

	* match.pd ((A +- CST1) +- CST2): Allow some conversions.

	* gcc.dg/tree-ssa/addadd.c: Xfail all scan-tree-dump*.

--- gcc/match.pd	(revision 248448)
+++ gcc/match.pd	(revision 248447)
@@ -1299,39 +1299,15 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
   /* (A +- CST1) +- CST2 -> A + CST3  */
   (for outer_op (plus minus)
    (for inner_op (plus minus)
-	neg_inner_op (minus plus)
     (simplify
-     (outer_op (convert? (inner_op @0 CONSTANT_CLASS_P@1)) CONSTANT_CLASS_P@2)
-     (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
-      /* If one of the types wraps, use that one.  */
-      (if (!ANY_INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_WRAPS (type))
-       (if (outer_op == PLUS_EXPR)
-	(plus (convert @0) (inner_op @2 (convert @1)))
-	(minus (convert @0) (neg_inner_op @2 (convert @1))))
-       (if (!ANY_INTEGRAL_TYPE_P (TREE_TYPE (@0))
-	    || TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0)))
-	(if (outer_op == PLUS_EXPR)
-	 (convert (plus @0 (inner_op (convert @2) @1)))
-	 (convert (minus @0 (neg_inner_op (convert @2) @1))))
-	/* If the constant operation overflows we cannot do the transform
-	   directly as we would introduce undefined overflow, for example
-	   with (a - 1) + INT_MIN.  */
-	(if (types_match (type, @0))
-	 (with { tree cst = const_binop (outer_op == inner_op
-					 ? PLUS_EXPR : MINUS_EXPR,
-					 type, @1, @2); }
-	  (if (cst && !TREE_OVERFLOW (cst))
-	   (inner_op @0 { cst; } )
-	   /* X+INT_MAX+1 is X-INT_MIN.  */
-	   (if (INTEGRAL_TYPE_P (type) && cst
-		&& wi::eq_p (cst, wi::min_value (type)))
-	    (neg_inner_op @0 { wide_int_to_tree (type, cst); })
-	    /* Last resort, use some unsigned type.  */
-	    (with { tree utype = unsigned_type_for (type); }
-	     (convert (inner_op
-		       (convert:utype @0)
-		       (convert:utype
-			{ drop_tree_overflow (cst); }))))))))))))))
+     (outer_op (inner_op @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
+     /* If the constant operation overflows we cannot do the transform
+	as we would introduce undefined overflow, for example
+	with (a - 1) + INT_MIN.  */
+     (with { tree cst = const_binop (outer_op == inner_op
+				     ? PLUS_EXPR : MINUS_EXPR, type, @1, @2); }
+      (if (cst && !TREE_OVERFLOW (cst))
+       (inner_op @0 { cst; } ))))))
 
   /* (CST1 - A) +- CST2 -> CST3 - A  */
   (for outer_op (plus minus)
--- gcc/testsuite/gcc.dg/tree-ssa/addadd.c	(revision 248532)
+++ gcc/testsuite/gcc.dg/tree-ssa/addadd.c	(working copy)
@@ -29,6 +29,6 @@ void j(S*x){
   *x += __INT_MAX__;
 }
 
-/* { dg-final { scan-tree-dump-times " \\+ 24;" 2 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "\\(unsigned int\\)" 2 "optimized" } } */
-/* { dg-final { scan-tree-dump-not "2147483647" "optimized" } } */
+/* { dg-final { scan-tree-dump-times " \\+ 24;" 2 "optimized" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "\\(unsigned int\\)" 2 "optimized" { xfail *-*-* }  } } */
+/* { dg-final { scan-tree-dump-not "2147483647" "optimized" { xfail *-*-* }  } } */


	Jakub