[GSoC][match-and-simplify] split match.pd

[Prathamesh Kulkarni <bilbotheelffriend at gmail dot com>]

I have split match.pd in this patch.
Not sure if I have written the ChangeLog correctly though...

* match-bitwise.pd: New file.
* match-plusminus.pd: Likewise.
* match-constant-folding.pd: Likewise.
* match-builtin.pd: Likewise.
* match-rotate.pd): New file.
                            Adjust to use wi::eq_p and wi::add.

* (match.pd): Move plus-minus patterns to ...
      (match-pluminus.pd): ... here.
                    Move bitwise paterns to ...
      (match-bitwise.pd): ... here.
                    Move constant folding patterns to ...
      (match-constant-folding.pd): ... here.
                    Move patterns on built-in functions to ...
      (match-builtin.pd): ... here.
                    Move rotate patterns to ...
      (match-rotate.pd): ... here.
                    Include match-plusminus.pd.
                    Include match-bitwise.pd.
                    Include match-constant-folding.pd.
                    Include match-builtin.pd.
                    Include match-rotate.pd.

Thanks,
Prathamesh

Index: gcc/match-bitwise.pd
===================================================================
--- gcc/match-bitwise.pd	(revision 0)
+++ gcc/match-bitwise.pd	(working copy)
@@ -0,0 +1,102 @@
+/* match-and-simplify patterns for simplify_bitwise_binary
+   Copyright (C) 2014 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+/* TODO bitwise patterns:
+1] x & x -> x
+2] x & 0 -> 0
+3] x & -1 -> x
+4] x & ~x -> 0
+5] ~x & ~y -> ~(x | y)
+6] ~x | ~y -> ~(x & y)
+7] x & (~x | y) -> y & x
+8] (x | CST1) & CST2  ->  (x & CST2) | (CST1 & CST2)
+9] x ^ x -> 0
+10] x ^ ~0 -> ~x
+11] (x | y) & x -> x
+12] (x & y) | x -> x
+13] (~x | y) & x -> x & y
+14] (~x & y) | x -> x | y
+15] ((a & b) & ~a) & ~b -> 0
+16] ~~x -> x
+*/
+
+/* x & x -> x */
+(match_and_simplify
+  (bit_and integral_op_p@0 @0)
+  @0)
+
+/* x & ~x -> 0 */
+(match_and_simplify
+  (bit_and:c integral_op_p@0 (bit_not @0))
+  { build_int_cst (type, 0); })
+
+/* ~x & ~y -> ~(x | y) */
+(match_and_simplify
+  (bit_and (bit_not integral_op_p@0) (bit_not @1))
+  (bit_not (bit_ior @0 @1)))
+
+/* ~x | ~y -> ~(x & y) */
+(match_and_simplify
+  (bit_ior (bit_not integral_op_p@0) (bit_not @1))
+  (bit_not (bit_and @0 @1)))
+
+/* x & (~x | y) -> y & x */
+(match_and_simplify
+  (bit_and:c integral_op_p@0 (bit_ior:c (bit_not @0) @1))
+  (bit_and @1 @0))
+
+/* (x | CST1) & CST2 -> (x & CST2) | (CST1 & CST2) */
+(match_and_simplify
+  (bit_and (bit_ior integral_op_p@0 INTEGER_CST_P@1) INTEGER_CST_P@2)
+  (bit_ior (bit_and @0 @2) (bit_and @1 @2)))
+
+/* x ^ ~0 -> ~x */
+(match_and_simplify
+  (bit_xor @0 integer_all_onesp@1)
+  (bit_not @0))
+
+/* (x | y) & x -> x */
+(match_and_simplify
+  (bit_and:c (bit_ior integral_op_p@0 @1) @0)
+  @0)
+
+/* (x & y) | x -> x */
+(match_and_simplify
+  (bit_ior:c (bit_and integral_op_p@0 @1) @0)
+  @0)
+
+/* (~x | y) & x -> x & y */
+(match_and_simplify
+  (bit_and:c (bit_ior:c (bit_not integral_op_p@0) @1) @0)
+  (bit_and @0 @1))
+
+/* (~x & y) | x -> x | y */
+(match_and_simplify
+  (bit_ior:c (bit_and:c (bit_not integral_op_p@0) @1) @0)
+  (bit_ior @0 @1))
+
+/* ~~x -> x */
+(match_and_simplify
+  (bit_not (bit_not integral_op_p@0))
+  @0)
+
+/* ((a & b) & ~a) -> 0 */
+(match_and_simplify
+  (bit_and:c (bit_and integral_op_p@0 @1) (bit_not @0))
+  { build_int_cst (type, 0); })
Index: gcc/match-builtin.pd
===================================================================
--- gcc/match-builtin.pd	(revision 0)
+++ gcc/match-builtin.pd	(working copy)
@@ -0,0 +1,44 @@
+/* match-and-simplify patterns for builtin functions
+   Copyright (C) 2014 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+
+/* One builtin function to atom.  */
+(match_and_simplify
+  (BUILT_IN_SQRT (mult @0 @0))
+  @0)
+/* One builtin function to builtin function.  */
+(match_and_simplify
+  (BUILT_IN_CABS (complex:c @0 real_zerop))
+  (BUILT_IN_FABS @0))
+/* One builtin function to expr.  */
+(match_and_simplify
+  (BUILT_IN_CABS (complex @0 @0))
+  (mult (BUILT_IN_FABS @0) { build_real (TREE_TYPE (@0), real_value_truncate (TYPE_MODE (TREE_TYPE (@0)), dconst_sqrt2 ())); }))
+/* One nested fn.  */
+(match_and_simplify
+  (mult:c (BUILT_IN_POW @0 @1) @0)
+  (BUILT_IN_POW @0 (PLUS_EXPR @1 { build_one_cst (TREE_TYPE (@1)); })))
+(match_and_simplify
+  (BUILT_IN_POW @0 REAL_CST_P@1)
+  /* This needs to be conditionalized on flag_unsafe_math_optimizations,
+     but we keep it for now to exercise function re-optimization.
+     It makes gcc.dg/pr43419.c FAIL execution though.  */
+  (if (REAL_VALUES_EQUAL (TREE_REAL_CST (@1), dconsthalf)))
+  (BUILT_IN_SQRT @0))
+
Index: gcc/match-constant-folding.pd
===================================================================
--- gcc/match-constant-folding.pd	(revision 0)
+++ gcc/match-constant-folding.pd	(working copy)
@@ -0,0 +1,66 @@
+/* match-and-simplify patterns for simple constant foldings to substitute gimple_fold_stmt_to_constant_2
+   Copyright (C) 2014 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+(for op in plus pointer_plus minus bit_ior bit_xor
+  (match_and_simplify
+    (op @0 integer_zerop)
+    @0))
+
+(match_and_simplify
+  (minus @0 @0)
+  { build_zero_cst (type); })
+
+(match_and_simplify
+  (mult @0 integer_zerop@1)
+  @1)
+
+/* Make sure to preserve divisions by zero.  This is the reason why
+   we don't simplify x / x to 1 or 0 / x to 0.  */
+(for op in mult trunc_div ceil_div floor_div round_div
+  (match_and_simplify
+    (op @0 integer_onep)
+    @0))
+
+(match_and_simplify
+  (trunc_mod @0 integer_onep)
+  { build_zero_cst (type); })
+/* Same applies to modulo operations, but fold is inconsistent here
+   and simplifies 0 % x to 0.  */
+(match_and_simplify
+  (trunc_mod integer_zerop@0 @1)
+  (if (!integer_zerop (@1)))
+  @0)
+
+(match_and_simplify
+  (bit_ior @0 integer_all_onesp@1)
+  @1)
+
+(match_and_simplify
+  (bit_and @0 integer_all_onesp)
+  @0)
+
+(match_and_simplify
+  (bit_and @0 integer_zerop@1)
+  @1)
+
+(match_and_simplify
+  (bit_xor @0 @0)
+  { build_zero_cst (type); })
+
+
Index: gcc/match.pd
===================================================================
--- gcc/match.pd	(revision 213234)
+++ gcc/match.pd	(working copy)
@@ -21,48 +21,6 @@ You should have received a copy of the G
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
-/* Simple constant foldings to substitute gimple_fold_stmt_to_constant_2.  */
-(for op in plus pointer_plus minus bit_ior bit_xor
-  (match_and_simplify
-    (op @0 integer_zerop)
-    @0))
-
-(match_and_simplify
-  (minus @0 @0)
-  { build_zero_cst (type); })
-
-(match_and_simplify
-  (mult @0 integer_zerop@1)
-  @1)
-
-/* Make sure to preserve divisions by zero.  This is the reason why
-   we don't simplify x / x to 1 or 0 / x to 0.  */
-(for op in mult trunc_div ceil_div floor_div round_div
-  (match_and_simplify
-    (op @0 integer_onep)
-    @0))
-
-(match_and_simplify
-  (trunc_mod @0 integer_onep)
-  { build_zero_cst (type); })
-/* Same applies to modulo operations, but fold is inconsistent here
-   and simplifies 0 % x to 0.  */
-(match_and_simplify
-  (trunc_mod integer_zerop@0 @1)
-  (if (!integer_zerop (@1)))
-  @0)
-(match_and_simplify
-  (bit_ior @0 integer_all_onesp@1)
-  @1)
-(match_and_simplify
-  (bit_and @0 integer_all_onesp)
-  @0)
-(match_and_simplify
-  (bit_and @0 integer_zerop@1)
-  @1)
-(match_and_simplify
-  (bit_xor @0 @0)
-  { build_zero_cst (type); })
 /* tree-ssa/ifc-pr44710.c requires a < b ? c : d to fold to 1.
    ???  probably runs into issue of recursive folding of a < b op0.  */
 /* tree-ssa/ssa-ccp-16.c wants to fold "hello"[i_2] to 0
@@ -98,96 +56,6 @@ along with GCC; see the file COPYING3.
 #endif
 
 
-/* Transforms formerly done by tree-ssa-forwprop.c:associate_plusminus  */
-
-/* ???  Have match_and_simplify groups guarded with common
-   predicates on the outermost type?  */
-
-/* Contract negates.  */
-(match_and_simplify
-  (plus:c @0 (negate @1))
-  (if (!TYPE_SATURATING (type)))
-  (minus @0 @1))
-(match_and_simplify
-  (minus @0 (negate @1))
-  (if (!TYPE_SATURATING (type)))
-  (plus @0 @1))
-
-
-/* Match patterns that allow contracting a plus-minus pair
-   irrespective of overflow issues.
-   ???  !TYPE_SATURATING condition missing.
-   ???  !FLOAT_TYPE_P && !FIXED_POINT_TYPE_P condition missing
-   because of saturation to +-Inf.  */
-
-(if (!TYPE_SATURATING (type)
-    && !FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type))
-  (match_and_simplify
-    (minus (plus @0 @1) @0)
-    @1)
-
-  (match_and_simplify
-    (minus (minus @0 @1) @0)
-    (negate @1))
-
-  (match_and_simplify
-    (minus (plus @0 @1) @1)
-    @0)
-
-  (match_and_simplify
-    (plus:c (minus @0 @1) @1)
-    @0))
-
-/* (CST +- A) +- CST -> CST' +- A.  */
-/* match_and_simplify handles constant folding for us so we can
-   implement these as re-association patterns.
-   Watch out for operand order and constant canonicalization
-   we do!  A - CST -> A + -CST, CST + A -> A + CST.  */
-(match_and_simplify
-  (plus (plus @0 INTEGER_CST_P@1) INTEGER_CST_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.  */
-  (if (!TREE_OVERFLOW (@1 = int_const_binop (PLUS_EXPR, @1, @2))))
-  (plus @0 @1))
-(match_and_simplify
-  (plus (minus INTEGER_CST_P@0 @1) INTEGER_CST_P@2)
-  (minus (plus @0 @2) @1))
-/* TODO:
-   (A +- CST) +- CST  ->  A +- CST
-   ~A + A             ->  -1
-   ~A + 1             ->  -A
-   A - (A +- B)       ->  -+ B
-   A +- (B +- A)      ->  +- B
-   CST +- (CST +- A)  ->  CST +- A
-   CST +- (A +- CST)  ->  CST +- A
-   A + ~A             ->  -1
-   (T)(P + A) - (T)P  -> (T)A
- */
-
-/* ~A + A -> -1 */
-(match_and_simplify
-  (plus:c (bit_not @0) @0)
-  { build_all_ones_cst (type); })
-
-/* ~A + 1 -> -A */
-(match_and_simplify
-  (plus (bit_not integral_op_p@0) integer_onep)
-  (negate @0)) 
-
-/* A - (A +- B) -> -+ B */
-(match_and_simplify
-  (minus @0 (plus:c @0 @1))
-  (negate @1))
-(match_and_simplify
-  (minus @0 (minus @0 @1))
-  @1)
-
-/* (T)(P + A) - (T)P -> (T) A */
-(match_and_simplify
-  (minus (convert (pointer_plus @0 @1))
-	 (convert @0))
-  (convert @1)) 
 
 /* Patterns required to avoid SCCVN testsuite regressions.  */
 
@@ -233,124 +101,11 @@ along with GCC; see the file COPYING3.
   (fma INTEGER_CST_P@0 INTEGER_CST_P@1 @3)
   (plus (mult @0 @1) @3))
 
-/* One builtin function to atom.  */
-(match_and_simplify
-  (BUILT_IN_SQRT (mult @0 @0))
-  @0)
-/* One builtin function to builtin function.  */
-(match_and_simplify
-  (BUILT_IN_CABS (complex:c @0 real_zerop))
-  (BUILT_IN_FABS @0))
-/* One builtin function to expr.  */
-(match_and_simplify
-  (BUILT_IN_CABS (complex @0 @0))
-  (mult (BUILT_IN_FABS @0) { build_real (TREE_TYPE (@0), real_value_truncate (TYPE_MODE (TREE_TYPE (@0)), dconst_sqrt2 ())); }))
-/* One nested fn.  */
-(match_and_simplify
-  (mult:c (BUILT_IN_POW @0 @1) @0)
-  (BUILT_IN_POW @0 (PLUS_EXPR @1 { build_one_cst (TREE_TYPE (@1)); })))
-(match_and_simplify
-  (BUILT_IN_POW @0 REAL_CST_P@1)
-  /* This needs to be conditionalized on flag_unsafe_math_optimizations,
-     but we keep it for now to exercise function re-optimization.
-     It makes gcc.dg/pr43419.c FAIL execution though.  */
-  (if (REAL_VALUES_EQUAL (TREE_REAL_CST (@1), dconsthalf)))
-  (BUILT_IN_SQRT @0))
-
-/* TODO bitwise patterns:
-1] x & x -> x
-2] x & 0 -> 0
-3] x & -1 -> x
-4] x & ~x -> 0
-5] ~x & ~y -> ~(x | y)
-6] ~x | ~y -> ~(x & y)
-7] x & (~x | y) -> y & x
-8] (x | CST1) & CST2  ->  (x & CST2) | (CST1 & CST2)
-9] x ^ x -> 0
-10] x ^ ~0 -> ~x
-11] (x | y) & x -> x
-12] (x & y) | x -> x
-13] (~x | y) & x -> x & y
-14] (~x & y) | x -> x | y
-15] ((a & b) & ~a) & ~b -> 0
-16] ~~x -> x
-*/
-
-/* x & x -> x */
-(match_and_simplify
-  (bit_and integral_op_p@0 @0)
-  @0)
-
-/* x & ~x -> 0 */
-(match_and_simplify
-  (bit_and:c integral_op_p@0 (bit_not @0))
-  { build_int_cst (type, 0); })
-
-/* ~x & ~y -> ~(x | y) */
-(match_and_simplify
-  (bit_and (bit_not integral_op_p@0) (bit_not @1))
-  (bit_not (bit_ior @0 @1)))
-
-/* ~x | ~y -> ~(x & y) */
-(match_and_simplify
-  (bit_ior (bit_not integral_op_p@0) (bit_not @1))
-  (bit_not (bit_and @0 @1)))
-
-/* x & (~x | y) -> y & x */
-(match_and_simplify
-  (bit_and:c integral_op_p@0 (bit_ior:c (bit_not @0) @1))
-  (bit_and @1 @0))
-
-/* (x | CST1) & CST2 -> (x & CST2) | (CST1 & CST2) */
-(match_and_simplify
-  (bit_and (bit_ior integral_op_p@0 INTEGER_CST_P@1) INTEGER_CST_P@2)
-  (bit_ior (bit_and @0 @2) (bit_and @1 @2)))
-
-/* x ^ ~0 -> ~x */
-(match_and_simplify
-  (bit_xor @0 integer_all_onesp@1)
-  (bit_not @0))
-
-/* (x | y) & x -> x */
-(match_and_simplify
-  (bit_and:c (bit_ior integral_op_p@0 @1) @0)
-  @0)
-
-/* (x & y) | x -> x */
-(match_and_simplify
-  (bit_ior:c (bit_and integral_op_p@0 @1) @0)
-  @0)
-
-/* (~x | y) & x -> x & y */
-(match_and_simplify
-  (bit_and:c (bit_ior:c (bit_not integral_op_p@0) @1) @0)
-  (bit_and @0 @1))
-
-/* (~x & y) | x -> x | y */
-(match_and_simplify
-  (bit_ior:c (bit_and:c (bit_not integral_op_p@0) @1) @0)
-  (bit_ior @0 @1))
-
-/* ~~x -> x */
-(match_and_simplify
-  (bit_not (bit_not integral_op_p@0))
-  @0)
-
-/* ((a & b) & ~a) -> 0 */
-(match_and_simplify
-  (bit_and:c (bit_and integral_op_p@0 @1) (bit_not @0))
-  { build_int_cst (type, 0); })
-
-/* (x << CNT1) OP (x >> CNT2) -> x r<< CNT1 OP being +, |, ^ */
-(for op in plus bit_ior bit_xor 
-(match_and_simplify
-  (op:c (lshift @0 INTEGER_CST_P@1) (rshift @0 INTEGER_CST_P@2))
-  (if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
-      && TYPE_PRECISION (type) == GET_MODE_PRECISION (TYPE_MODE (type))
-      && tree_fits_uhwi_p (@1) && tree_fits_uhwi_p (@2)
-      && tree_to_uhwi (@1) + tree_to_uhwi (@2) == TYPE_PRECISION (type)))
-  (lrotate @0 @1)))
-
+#include "match-plusminus.pd"
+#include "match-bitwise.pd"
+#include "match-rotate.pd"
+#include "match-builtin.pd"
+#include "match-constant-folding.pd"
 
 /* ????s
 
Index: gcc/match-plusminus.pd
===================================================================
--- gcc/match-plusminus.pd	(revision 0)
+++ gcc/match-plusminus.pd	(working copy)
@@ -0,0 +1,108 @@
+/* match-and-simplify patterns for associate_plusminus
+   Copyright (C) 2014 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+/* ???  Have match_and_simplify groups guarded with common
+   predicates on the outermost type?  */
+
+/* Contract negates.  */
+(match_and_simplify
+  (plus:c @0 (negate @1))
+  (if (!TYPE_SATURATING (type)))
+  (minus @0 @1))
+(match_and_simplify
+  (minus @0 (negate @1))
+  (if (!TYPE_SATURATING (type)))
+  (plus @0 @1))
+
+
+/* Match patterns that allow contracting a plus-minus pair
+   irrespective of overflow issues.
+   ???  !TYPE_SATURATING condition missing.
+   ???  !FLOAT_TYPE_P && !FIXED_POINT_TYPE_P condition missing
+   because of saturation to +-Inf.  */
+
+(if (!TYPE_SATURATING (type)
+    && !FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type))
+  (match_and_simplify
+    (minus (plus @0 @1) @0)
+    @1)
+
+  (match_and_simplify
+    (minus (minus @0 @1) @0)
+    (negate @1))
+
+  (match_and_simplify
+    (minus (plus @0 @1) @1)
+    @0)
+
+  (match_and_simplify
+    (plus:c (minus @0 @1) @1)
+    @0))
+
+/* (CST +- A) +- CST -> CST' +- A.  */
+/* match_and_simplify handles constant folding for us so we can
+   implement these as re-association patterns.
+   Watch out for operand order and constant canonicalization
+   we do!  A - CST -> A + -CST, CST + A -> A + CST.  */
+(match_and_simplify
+  (plus (plus @0 INTEGER_CST_P@1) INTEGER_CST_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.  */
+  (if (!TREE_OVERFLOW (@1 = int_const_binop (PLUS_EXPR, @1, @2))))
+  (plus @0 @1))
+(match_and_simplify
+  (plus (minus INTEGER_CST_P@0 @1) INTEGER_CST_P@2)
+  (minus (plus @0 @2) @1))
+/* TODO:
+   (A +- CST) +- CST  ->  A +- CST
+   ~A + A             ->  -1
+   ~A + 1             ->  -A
+   A - (A +- B)       ->  -+ B
+   A +- (B +- A)      ->  +- B
+   CST +- (CST +- A)  ->  CST +- A
+   CST +- (A +- CST)  ->  CST +- A
+   A + ~A             ->  -1
+   (T)(P + A) - (T)P  -> (T)A
+ */
+
+/* ~A + A -> -1 */
+(match_and_simplify
+  (plus:c (bit_not @0) @0)
+  { build_all_ones_cst (type); })
+
+/* ~A + 1 -> -A */
+(match_and_simplify
+  (plus (bit_not integral_op_p@0) integer_onep)
+  (negate @0)) 
+
+/* A - (A +- B) -> -+ B */
+(match_and_simplify
+  (minus @0 (plus:c @0 @1))
+  (negate @1))
+(match_and_simplify
+  (minus @0 (minus @0 @1))
+  @1)
+
+/* (T)(P + A) - (T)P -> (T) A */
+(match_and_simplify
+  (minus (convert (pointer_plus @0 @1))
+	 (convert @0))
+  (convert @1)) 
+
Index: gcc/match-rotate.pd
===================================================================
--- gcc/match-rotate.pd	(revision 0)
+++ gcc/match-rotate.pd	(working copy)
@@ -0,0 +1,29 @@
+/* match-and-simplify patterns for simplify_rotate
+   Copyright (C) 2014 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+
+/* (x << CNT1) OP (x >> CNT2) -> x r<< CNT1 OP being +, |, ^ */
+(for op in plus bit_ior bit_xor 
+(match_and_simplify
+  (op:c (lshift @0 INTEGER_CST_P@1) (rshift @0 INTEGER_CST_P@2))
+  (if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
+      && TYPE_PRECISION (type) == GET_MODE_PRECISION (TYPE_MODE (type))
+      && tree_fits_uhwi_p (@1) && tree_fits_uhwi_p (@2)
+      && wi::eq_p (TYPE_PRECISION (type), wi::add (@1, @2))))
+  (lrotate @0 @1)))