genmatch.c (add_operator): Treat ADDR_EXPR as atom.

2015-06-29  Richard Biener  <rguenther@suse.de>

	* genmatch.c (add_operator): Treat ADDR_EXPR as atom.
	* fold-const.c (fold_binary_loc): Move &A - &B simplification
	via ptr_difference_const ...
	* match.pd: ... here.
	When matching (X ^ Y) == Y also match with swapped operands.

From-SVN: r225115

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f891d4471d70a74c86a2438d6b4edcf36b228d1e..976e6894fa2c6c14c5d281fa0f9ad16de666a380 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2015-06-29  Richard Biener  <rguenther@suse.de>
+
+       * genmatch.c (add_operator): Treat ADDR_EXPR as atom.
+       * fold-const.c (fold_binary_loc): Move &A - &B simplification
+       via ptr_difference_const ...
+       * match.pd: ... here.
+       When matching (X ^ Y) == Y also match with swapped operands.
+
 2015-06-29  Richard Biener  <rguenther@suse.de>
 
        * lto-streamer.h (LTO_major_version): Bump to 5.

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 6f12dd04c6e676c3d5d3f415c2e47b4eda74ae61..7b9502e2d38d56683c47137c06114bf52072457b 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -10618,16 +10618,6 @@ fold_binary_loc (location_t loc,
                            fold_convert_loc (loc, type,
                                              negate_expr (arg1)));
 
-      /* Try folding difference of addresses.  */
-      {
-       HOST_WIDE_INT diff;
-
-       if ((TREE_CODE (arg0) == ADDR_EXPR
-            || TREE_CODE (arg1) == ADDR_EXPR)
-           && ptr_difference_const (arg0, arg1, &diff))
-         return build_int_cst_type (type, diff);
-      }
-
       /* Fold &a[i] - &a[j] to i-j.  */
       if (TREE_CODE (arg0) == ADDR_EXPR
          && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF

diff --git a/gcc/genmatch.c b/gcc/genmatch.c
index 195dc3cf3bc75e794f6211572a1e26d74dceb74c..2bd61d3f06be028898b4772e58e5d9f5d1d44642 100644 (file)
--- a/gcc/genmatch.c
+++ b/gcc/genmatch.c
@@ -324,6 +324,9 @@ add_operator (enum tree_code code, const char *id,
       /* And allow CONSTRUCTOR for vector initializers.  */
       && !(code == CONSTRUCTOR))
     return;
+  /* Treat ADDR_EXPR as atom, thus don't allow matching its operand.  */
+  if (code == ADDR_EXPR)
+    nargs = 0;
   operator_id *op = new operator_id (code, id, nargs, tcc);
   id_base **slot = operators->find_slot_with_hash (op, op->hashval, INSERT);
   if (*slot)

diff --git a/gcc/match.pd b/gcc/match.pd
index b2f8429c1204bf3b01ae8c4bb2ea2395c7e58c6d..0189a966bc8d5d57879319b7deccb39ae022db09 100644 (file)
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -545,6 +545,21 @@ along with GCC; see the file COPYING3.  If not see
   (with { tree algn = wide_int_to_tree (TREE_TYPE (@0), wi::bit_not (@1)); }
    (bit_and @0 { algn; })))
 
+/* Try folding difference of addresses.  */
+(simplify
+ (minus (convert ADDR_EXPR@0) (convert @1))
+ (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
+  (with { HOST_WIDE_INT diff; }
+   (if (ptr_difference_const (@0, @1, &diff))
+    { build_int_cst_type (type, diff); }))))
+(simplify
+ (minus (convert @0) (convert ADDR_EXPR@1))
+ (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
+  (with { HOST_WIDE_INT diff; }
+   (if (ptr_difference_const (@0, @1, &diff))
+    { build_int_cst_type (type, diff); }))))
+
+
 
 /* We can't reassociate at all for saturating types.  */
 (if (!TYPE_SATURATING (type))
@@ -1229,7 +1244,7 @@ along with GCC; see the file COPYING3.  If not see
  /* (X ^ Y) == Y becomes X == 0.
     Likewise (X ^ Y) == X becomes Y == 0.  */
  (simplify
-  (cmp (bit_xor:c @0 @1) @0)
+  (cmp:c (bit_xor:c @0 @1) @0)
   (cmp @1 { build_zero_cst (TREE_TYPE (@1)); }))
 
  /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2).  */