tree.h (tree_expr_nonzero_p): Export.

2005-07-20  James A. Morrison  <phython@gcc.gnu.org>

        * tree.h (tree_expr_nonzero_p): Export.
        * fold-const.c (tree_expr_nonzero_p): Likewise.
        Return true for CALL_EXPRs that are alloca calls.
        (fold_binary): Use omit_one_operand when checking EQ_EXPRs or NE_EXPRs
        against zero.
        * tree-flow.h (expr_computes_nonzero): Remove.
        * tree-vrp.c (expr_computes_nonzero): Remove.
        (vrp_expr_computes_nonzero): Use tree_expr_nonzero_p.
        (extract_range_from_unary_expr): Likewise.
        * tree-ssa-dom.c (record_equivalences_from_stmt): Use
        tree_expr_nonzero_p.

From-SVN: r102201

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index da0313f1915ac0cdeaedfb50ba8d7fe4b3562247..ba47d056cbf81ae2c3d997b57189b93bb6d8540b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,17 @@
+2005-07-20  James A. Morrison  <phython@gcc.gnu.org>
+
+       * tree.h (tree_expr_nonzero_p): Export.
+       * fold-const.c (tree_expr_nonzero_p): Likewise.
+       Return true for CALL_EXPRs that are alloca calls.
+       (fold_binary): Use omit_one_operand when checking EQ_EXPRs or NE_EXPRs
+       against zero.
+       * tree-flow.h (expr_computes_nonzero): Remove.
+       * tree-vrp.c (expr_computes_nonzero): Remove.
+       (vrp_expr_computes_nonzero): Use tree_expr_nonzero_p.
+       (extract_range_from_unary_expr): Likewise.
+       * tree-ssa-dom.c (record_equivalences_from_stmt): Use
+       tree_expr_nonzero_p.
+
 2005-07-20  Bernd Schmidt  <bernd.schmidt@analog.com>
 
        * config/bfin/bfin-protos.h (legitimize_pic_address): Don't declare.

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index e9d88d1e6c3441b6928e71014f6cc4b5dc6b9669..7b83eb3ef5f835351f25fabc7b542147cb9c81f3 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -132,7 +132,6 @@ static bool reorder_operands_p (tree, tree);
 static tree fold_negate_const (tree, tree);
 static tree fold_not_const (tree, tree);
 static tree fold_relational_const (enum tree_code, tree, tree, tree);
-static bool tree_expr_nonzero_p (tree);
 
 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
@@ -9694,10 +9693,12 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
        }
 
       if ((code == EQ_EXPR || code == NE_EXPR)
-         && !TREE_SIDE_EFFECTS (arg0)
          && integer_zerop (arg1)
          && tree_expr_nonzero_p (arg0))
-       return constant_boolean_node (code==NE_EXPR, type);
+        {
+         tree res = constant_boolean_node (code==NE_EXPR, type);
+         return omit_one_operand (type, res, arg0);
+       }
 
       t1 = fold_relational_const (code, type, arg0, arg1);
       return t1 == NULL_TREE ? NULL_TREE : t1;
@@ -10797,7 +10798,7 @@ tree_expr_nonnegative_p (tree t)
    For floating point we further ensure that T is not denormal.
    Similar logic is present in nonzero_address in rtlanal.h.  */
 
-static bool
+bool
 tree_expr_nonzero_p (tree t)
 {
   tree type = TREE_TYPE (t);
@@ -10904,6 +10905,9 @@ tree_expr_nonzero_p (tree t)
       return tree_expr_nonzero_p (TREE_OPERAND (t, 1))
             || tree_expr_nonzero_p (TREE_OPERAND (t, 0));
 
+    case CALL_EXPR:
+      return alloca_call_p (t);
+
     default:
       break;
     }

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index ab5287beb73ed5d7d039b55555e037f566fe1c28..acbc2d6bc0a07b5defbc125d720449877bb288f8 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2005-07-20  James A. Morrison  <phython@gcc.gnu.org>
+
+       * gcc.dg/fold-alloc-1.c: New test.
+
 2005-07-20  Kazu Hirata  <kazu@codesourcery.com>
 
        * gcc.dg/20020312-2.c, gcc.dg/sibcall-3.c, gcc.dg/sibcall-4.c,

diff --git a/gcc/testsuite/gcc.dg/fold-alloca-1.c b/gcc/testsuite/gcc.dg/fold-alloca-1.c
new file mode 100644 (file)
index 0000000..735a22f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/fold-alloca-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-useless" } */
+
+void *alloca (__SIZE_TYPE__);
+void link_error ();
+
+int main (int argc, char *argv[]) {
+       char *foo;
+       if ((foo = alloca(argc)) == 0)
+         link_error ();
+       return 0;
+}
+/* { dg-final { scan-tree-dump-times "link_error" 0 "useless" } } */
+/* { dg-final { cleanup-tree-dump "useless" } } */

diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h
index da49ed199e9d77dd2715ee50c055b37f5da7a4f4..16bcb803c3eacfbd6ed1661090f36aa9c4928c77 100644 (file)
--- a/gcc/tree-flow.h
+++ b/gcc/tree-flow.h
@@ -659,7 +659,6 @@ bool fold_stmt_inplace (tree);
 tree widen_bitfield (tree, tree, tree);
 
 /* In tree-vrp.c  */
-bool expr_computes_nonzero (tree);
 tree vrp_evaluate_conditional (tree, bool);
 void simplify_stmt_using_ranges (tree);
 

diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 2514a49fc5d11b6e69a04125e2e993297d134722..7b79c79caa3758aa5336ac1ef97ad7ee17c13cc6 100644 (file)
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -2633,7 +2633,7 @@ record_equivalences_from_stmt (tree stmt,
              || is_gimple_min_invariant (rhs)))
        SSA_NAME_VALUE (lhs) = rhs;
 
-      if (expr_computes_nonzero (rhs))
+      if (tree_expr_nonzero_p (rhs))
        record_var_is_nonzero (lhs);
     }
 

diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index a42a21a882e8783f31cb5b0612cc0a88153a3c7d..e7d877d7d58f31d4359cabc2f6e06f238e20abcb 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -95,36 +95,6 @@ static sbitmap blocks_visited;
 static value_range_t **vr_value;
 
 
-/* Return true if EXPR computes a non-zero value.  */
-
-bool
-expr_computes_nonzero (tree expr)
-{
-  /* Type casts won't change anything, so just strip them.  */
-  STRIP_NOPS (expr);
-
-  /* Calling alloca, guarantees that the value is non-NULL.  */
-  if (alloca_call_p (expr))
-    return true;
-
-  /* The address of a non-weak symbol is never NULL, unless the user
-     has requested not to remove NULL pointer checks.  */
-  if (flag_delete_null_pointer_checks
-      && TREE_CODE (expr) == ADDR_EXPR
-      && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (expr, 0))
-      && !DECL_WEAK (TREE_OPERAND (expr, 0)))
-    return true;
-
-  /* IOR of any value with a nonzero value will result in a nonzero
-     value.  */
-  if (TREE_CODE (expr) == BIT_IOR_EXPR
-      && integer_nonzerop (TREE_OPERAND (expr, 1)))
-    return true;
-
-  return false;
-}
-
-
 /* Return true if ARG is marked with the nonnull attribute in the
    current function signature.  */
 
@@ -393,13 +363,13 @@ symbolic_range_p (value_range_t *vr)
 }
 
 
-/* Like expr_computes_nonzero, but this function uses value ranges
+/* Like tree_expr_nonzero_p, but this function uses value ranges
    obtained so far.  */
 
 static bool
 vrp_expr_computes_nonzero (tree expr)
 {
-  if (expr_computes_nonzero (expr))
+  if (tree_expr_nonzero_p (expr))
     return true;
 
   /* If we have an expression of the form &X->a, then the expression
@@ -1319,7 +1289,7 @@ extract_range_from_unary_expr (value_range_t *vr, tree expr)
      determining if it evaluates to NULL [0, 0] or non-NULL (~[0, 0]).  */
   if (POINTER_TYPE_P (TREE_TYPE (expr)) || POINTER_TYPE_P (TREE_TYPE (op0)))
     {
-      if (range_is_nonnull (&vr0) || expr_computes_nonzero (expr))
+      if (range_is_nonnull (&vr0) || tree_expr_nonzero_p (expr))
        set_value_range_to_nonnull (vr, TREE_TYPE (expr));
       else if (range_is_null (&vr0))
        set_value_range_to_null (vr, TREE_TYPE (expr));

diff --git a/gcc/tree.h b/gcc/tree.h
index b9cd508edd0af730fffd0b900b68663490d37856..10472fe839b51aeef9ca81a5c0abb3f3646d6a0e 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -3851,6 +3851,8 @@ extern enum tree_code swap_tree_comparison (enum tree_code);
 extern bool ptr_difference_const (tree, tree, HOST_WIDE_INT *);
 extern enum tree_code invert_tree_comparison (enum tree_code, bool);
 
+extern bool tree_expr_nonzero_p (tree);
+
 /* In builtins.c */
 extern tree fold_builtin (tree, tree, bool);
 extern tree fold_builtin_fputs (tree, bool, bool, tree);