diff mbox

Remove match.pd pattern dups in favor of using :c

Message ID alpine.LSU.2.11.1606011228230.1493@t29.fhfr.qr
State New
Headers show

Commit Message

Richard Biener June 1, 2016, 10:29 a.m. UTC 
The following uses the now available possibility to use :c on relational
compares.

Bootstrapped and tested on x86_64-unknown-linux-gnu, applied.

Richard.

2016-06-01  Richard Biener  <rguenther@suse.de>

	* match.pd ((A & B) - (A & ~B) -> B - (A ^ B)): Add missing :c.
	(relational patterns): Use :c to avoid pattern duplications.

Comments

Alexander Monakov June 1, 2016, 10:37 a.m. UTC | #1 
Hi,

On Wed, 1 Jun 2016, Richard Biener wrote:
> 2016-06-01  Richard Biener  <rguenther@suse.de>
> 
> 	* match.pd ((A & B) - (A & ~B) -> B - (A ^ B)): Add missing :c.
> 	(relational patterns): Use :c to avoid pattern duplications.

Should the same treatment be applied to recently added IFN_MUL_OVERFLOW
patterns (lines 2625-2643 in current match.pd)?

Thanks.
Alexander
Richard Biener June 1, 2016, 10:39 a.m. UTC | #2 
On Wed, 1 Jun 2016, Alexander Monakov wrote:

> Hi,
> 
> On Wed, 1 Jun 2016, Richard Biener wrote:
> > 2016-06-01  Richard Biener  <rguenther@suse.de>
> > 
> > 	* match.pd ((A & B) - (A & ~B) -> B - (A ^ B)): Add missing :c.
> > 	(relational patterns): Use :c to avoid pattern duplications.
> 
> Should the same treatment be applied to recently added IFN_MUL_OVERFLOW
> patterns (lines 2625-2643 in current match.pd)?

Ah, yeah - I missed those appearantly.

Richard.
diff mbox

Patch

Index: gcc/match.pd
===================================================================
--- gcc/match.pd	(revision 236877)
+++ gcc/match.pd	(working copy)
@@ -493,7 +493,7 @@  DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 
 /* Fold (A & B) - (A & ~B) into B - (A ^ B).  */
 (simplify
- (minus (bit_and:s @0 @1) (bit_and:cs @0 (bit_not @1)))
+ (minus (bit_and:cs @0 @1) (bit_and:cs @0 (bit_not @1)))
   (minus @1 (bit_xor @0 @1)))
 
 /* Simplify (X & ~Y) | (~X & Y) -> X ^ Y.  */
@@ -2584,18 +2606,7 @@  DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 (for cmp (lt le ge gt)
      out (gt gt le le)
  (simplify
-  (cmp (plus@2 @0 INTEGER_CST@1) @0)
-  (if (TYPE_UNSIGNED (TREE_TYPE (@0))
-       && TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0))
-       && wi::ne_p (@1, 0)
-       && single_use (@2))
-   (out @0 { wide_int_to_tree (TREE_TYPE (@0), wi::max_value
-	       (TYPE_PRECISION (TREE_TYPE (@0)), UNSIGNED) - @1); }))))
-/* A CMP A + CST  ->  A CMP' CST' */
-(for cmp (gt ge le lt)
-     out (gt gt le le)
- (simplify
-  (cmp @0 (plus@2 @0 INTEGER_CST@1))
+  (cmp:c (plus@2 @0 INTEGER_CST@1) @0)
   (if (TYPE_UNSIGNED (TREE_TYPE (@0))
        && TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0))
        && wi::ne_p (@1, 0)
@@ -2608,35 +2619,19 @@  DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
    expects the long form, so we restrict the transformation for now.  */
 (for cmp (gt le)
  (simplify
-  (cmp (minus@2 @0 @1) @0)
+  (cmp:c (minus@2 @0 @1) @0)
   (if (single_use (@2)
        && ANY_INTEGRAL_TYPE_P (TREE_TYPE (@0))
        && TYPE_UNSIGNED (TREE_TYPE (@0))
        && TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0)))
    (cmp @1 @0))))
-(for cmp (lt ge)
- (simplify
-  (cmp @0 (minus@2 @0 @1))
-  (if (single_use (@2)
-       && ANY_INTEGRAL_TYPE_P (TREE_TYPE (@0))
-       && TYPE_UNSIGNED (TREE_TYPE (@0))
-       && TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0)))
-   (cmp @0 @1))))
 
 /* Testing for overflow is unnecessary if we already know the result.  */
-/* A < A - B  */
-(for cmp (lt ge)
-     out (ne eq)
- (simplify
-  (cmp @0 (realpart (IFN_SUB_OVERFLOW@2 @0 @1)))
-  (if (TYPE_UNSIGNED (TREE_TYPE (@0))
-       && types_match (TREE_TYPE (@0), TREE_TYPE (@1)))
-   (out (imagpart @2) { build_zero_cst (TREE_TYPE (@0)); }))))
 /* A - B > A  */
 (for cmp (gt le)
      out (ne eq)
  (simplify
-  (cmp (realpart (IFN_SUB_OVERFLOW@2 @0 @1)) @0)
+  (cmp:c (realpart (IFN_SUB_OVERFLOW@2 @0 @1)) @0)
   (if (TYPE_UNSIGNED (TREE_TYPE (@0))
        && types_match (TREE_TYPE (@0), TREE_TYPE (@1)))
    (out (imagpart @2) { build_zero_cst (TREE_TYPE (@0)); }))))
@@ -2644,15 +2639,7 @@  DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 (for cmp (lt ge)
      out (ne eq)
  (simplify
-  (cmp (realpart (IFN_ADD_OVERFLOW:c@2 @0 @1)) @0)
-  (if (TYPE_UNSIGNED (TREE_TYPE (@0))
-       && types_match (TREE_TYPE (@0), TREE_TYPE (@1)))
-   (out (imagpart @2) { build_zero_cst (TREE_TYPE (@0)); }))))
-/* A > A + B  */
-(for cmp (gt le)
-     out (ne eq)
- (simplify
-  (cmp @0 (realpart (IFN_ADD_OVERFLOW:c@2 @0 @1)))
+  (cmp:c (realpart (IFN_ADD_OVERFLOW:c@2 @0 @1)) @0)
   (if (TYPE_UNSIGNED (TREE_TYPE (@0))
        && types_match (TREE_TYPE (@0), TREE_TYPE (@1)))
    (out (imagpart @2) { build_zero_cst (TREE_TYPE (@0)); }))))