OSDN Git Service

2006-02-26 Roger Sayle <roger@eyesopen.com>
authorsayle <sayle@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 26 Feb 2006 15:36:52 +0000 (15:36 +0000)
committersayle <sayle@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 26 Feb 2006 15:36:52 +0000 (15:36 +0000)
    James A. Morrison  <phython@gcc.gnu.org>

PR middle-end/21137
* fold-const.c (fold_binary) <EQ_EXPR>:  Fold ((X>>C1)&C2) eq/ne 0,
when C2 is a power of two, as either (X&(C2<<C1)) eq/ne 0 if the
new constant C2<<C1, or as (X<0) or (X,false) depending upon the
signedness of the shift operation.

* gcc.dg/fold-eqandshift-1.c: New test case.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@111453 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/fold-const.c
gcc/testsuite/ChangeLog
gcc/testsuite/gcc.dg/fold-eqandshift-1.c [new file with mode: 0644]

index 84c278d..ead872d 100644 (file)
@@ -1,3 +1,12 @@
+2006-02-26  Roger Sayle  <roger@eyesopen.com>
+           James A. Morrison  <phython@gcc.gnu.org>
+
+       PR middle-end/21137
+       * fold-const.c (fold_binary) <EQ_EXPR>:  Fold ((X>>C1)&C2) eq/ne 0,
+       when C2 is a power of two, as either (X&(C2<<C1)) eq/ne 0 if the
+       new constant C2<<C1, or as (X<0) or (X,false) depending upon the
+       signedness of the shift operation.
+
 2006-02-26  Dorit Nuzman  <dorit@il.ibm.com>
 
        PR tree-optimization/26359
index 3c3852b..7eb4d91 100644 (file)
@@ -9653,6 +9653,52 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
                              fold_convert (newtype, arg1));
        }
 
+      /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
+        C1 is a valid shift constant, and C2 is a power of two, i.e.
+        a single bit.  */
+      if (TREE_CODE (arg0) == BIT_AND_EXPR
+         && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
+         && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
+            == INTEGER_CST
+         && integer_pow2p (TREE_OPERAND (arg0, 1))
+         && integer_zerop (arg1))
+       {
+         tree itype = TREE_TYPE (arg0);
+         unsigned HOST_WIDE_INT prec = TYPE_PRECISION (itype);
+         tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
+
+         /* Check for a valid shift count.  */
+         if (TREE_INT_CST_HIGH (arg001) == 0
+             && TREE_INT_CST_LOW (arg001) < prec)
+           {
+             tree arg01 = TREE_OPERAND (arg0, 1);
+             tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
+             unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
+             /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
+                can be rewritten as (X & (C2 << C1)) != 0.  */
+             if ((log2 + TREE_INT_CST_LOW (arg01)) < prec)
+               {
+                 tem = fold_build2 (LSHIFT_EXPR, itype, arg01, arg001);
+                 tem = fold_build2 (BIT_AND_EXPR, itype, arg000, tem);
+                 return fold_build2 (code, type, tem, arg1);
+               }
+             /* Otherwise, for signed (arithmetic) shifts,
+                ((X >> C1) & C2) != 0 is rewritten as X < 0, and
+                ((X >> C1) & C2) == 0 is rewritten as X >= 0.  */
+             else if (!TYPE_UNSIGNED (itype))
+               return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
+                                   arg000, build_int_cst (itype, 0));
+             /* Otherwise, of unsigned (logical) shifts,
+                ((X >> C1) & C2) != 0 is rewritten as (X,false), and
+                ((X >> C1) & C2) == 0 is rewritten as (X,true).  */
+             else
+               return omit_one_operand (type,
+                                        code == EQ_EXPR ? integer_one_node
+                                                        : integer_zero_node,
+                                        arg000);
+           }
+       }
+
       /* If this is an NE comparison of zero with an AND of one, remove the
         comparison since the AND will give the correct value.  */
       if (code == NE_EXPR
index 3040961..deb3000 100644 (file)
@@ -1,3 +1,8 @@
+2006-02-26  Roger Sayle  <roger@eyesopen.com>
+
+       PR middle-end/21137
+       * gcc.dg/fold-eqandshift-1.c: New test case.
+
 2006-02-26  Dorit Nuzman  <dorit@il.ibm.com>
 
        PR tree-optimization/25125
diff --git a/gcc/testsuite/gcc.dg/fold-eqandshift-1.c b/gcc/testsuite/gcc.dg/fold-eqandshift-1.c
new file mode 100644 (file)
index 0000000..6de7116
--- /dev/null
@@ -0,0 +1,46 @@
+/* PR middle-end/21137  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+extern void foo();
+
+void test1(int a)
+{
+  if ((a >> 3) & 1)
+    foo ();
+}
+
+void test2(int b)
+{
+  if ((b >> 3) & 4)
+    foo ();
+}
+
+int test3(int c)
+{
+  return (c >> 3) & 1;
+}
+
+int test4(int d)
+{
+  return (d >> 3) & 4;
+}
+
+#if 0
+void test5(int e)
+{
+  if ((e >> 31) & 64)
+    foo();
+}
+
+void test6(unsigned int f)
+{
+  if ((f >> 31) & 64)
+    foo();
+}
+#endif
+
+/* { dg-final { scan-tree-dump-times "\\(a \& 8\\) != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(b \& 32\\) != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "c >> 3 \& 1" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "d >> 3 \& 4" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */