tree-ssa-ccp.c (get_symbol_constant_value): Export.

2008-03-15  Richard Guenther  <rguenther@suse.de>

	* tree-ssa-ccp.c (get_symbol_constant_value): Export.
	(fold_const_aggregate_ref): Likewise.
	(get_value): Return NULL if we don't have any values.
	(ccp_finalize): Set const_val to NULL after freeing it.
	* tree-flow.h (get_symbol_constant_value): Declare.
	(fold_const_aggregate_ref): Likewise.
	* tree-ssa-sccvn.c (try_to_simplify): Use them.

	* gcc.dg/pr23911.c: Adjust testcase.
	* gcc.dg/tree-ssa/pr14841.c: Likewise.
	* gcc.dg/tree-ssa/20030922-2.c: Likewise.

From-SVN: r133251

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index b0e25a461bf2a1d77e8745eaacb6e0dff3b9394d..ba568d83e6bd9e9e69e023bd47286f1252821388 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2008-03-15  Richard Guenther  <rguenther@suse.de>
+
+       * tree-ssa-ccp.c (get_symbol_constant_value): Export.
+       (fold_const_aggregate_ref): Likewise.
+       (get_value): Return NULL if we don't have any values.
+       (ccp_finalize): Set const_val to NULL after freeing it.
+       * tree-flow.h (get_symbol_constant_value): Declare.
+       (fold_const_aggregate_ref): Likewise.
+       * tree-ssa-sccvn.c (try_to_simplify): Use them.
+
 2008-03-15  Richard Guenther  <rguenther@suse.de>
 
        PR middle-end/35593

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index f453ce1c2c3076ad07746356f33f3b447c27dbe4..48445d95e98b1e4693a075b3f1ee9301faeadc5f 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,9 @@
+2008-03-15  Richard Guenther  <rguenther@suse.de>
+
+       * gcc.dg/pr23911.c: Adjust testcase.
+       * gcc.dg/tree-ssa/pr14841.c: Likewise.
+       * gcc.dg/tree-ssa/20030922-2.c: Likewise.
+
 2008-03-15  Richard Guenther  <rguenther@suse.de>
 
        PR middle-end/35593

diff --git a/gcc/testsuite/gcc.dg/pr23911.c b/gcc/testsuite/gcc.dg/pr23911.c
index 9c8fad341ba183427f89c72cfc4d036487dd0e38..b77dbaab91013831e58e0529b00af6699359b202 100644 (file)
--- a/gcc/testsuite/gcc.dg/pr23911.c
+++ b/gcc/testsuite/gcc.dg/pr23911.c
@@ -1,7 +1,7 @@
 /* This was a missed optimization in tree constant propagation
    that CSE would catch later on.  */
 /* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-store_ccp" } */
+/* { dg-options "-O -fdump-tree-dce2" } */
 
 double _Complex *a; 
 static const double _Complex b[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
@@ -14,9 +14,8 @@ test (void)
   return; 
 } 
 
-/* After store_ccp, there should not be any assignments from real or
-   imaginary parts anymore.  The constants should be loaded from b and
-   propagated into the elements of a.  */
-/* { dg-final { scan-tree-dump-times "= CR" 0 "store_ccp" } } */
-/* { dg-final { scan-tree-dump-times "= CI" 0 "store_ccp" } } */
-/* { dg-final { cleanup-tree-dump "store_ccp" } } */
+/* After DCE2 which runs after FRE, the expressions should be fully
+   constant folded.  There should be no loads from b left.  */
+/* { dg-final { scan-tree-dump-times "__complex__ \\\(1.0e\\\+0, 0.0\\\)" 2 "dce2" } } */
+/* { dg-final { scan-tree-dump-times "= b" 0 "dce2" } } */
+/* { dg-final { cleanup-tree-dump "dce2" } } */

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/20030922-2.c b/gcc/testsuite/gcc.dg/tree-ssa/20030922-2.c
index 88431123e8e22d33128d591b50680282dd5501b1..9a787bd21bade535660a8b332c18d00b5153aea0 100644 (file)
--- a/gcc/testsuite/gcc.dg/tree-ssa/20030922-2.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/20030922-2.c
@@ -7,8 +7,8 @@ struct rtx_def
 {
   int bb;
 };
-static int *block_to_bb;
-static int target_bb;
+int *block_to_bb;
+int target_bb;
 
 int
 rgn_rank (rtx insn1, rtx insn2)

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr14841.c b/gcc/testsuite/gcc.dg/tree-ssa/pr14841.c
index 05ceeb279e93302de42274cf8069c5802b97b843..cc6e0158b67dc1dcfe2916c23a1c029d3e3c928b 100644 (file)
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr14841.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr14841.c
@@ -2,8 +2,8 @@
    Make sure that we can fold a possible nested reference into a
    constant aggregate.  */
 
-/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-store_ccp-details" } */
+/* { dg-do link } */
+/* { dg-options "-O" } */
 
 struct car {
   int speed;
@@ -25,5 +25,5 @@ foo (void)
     link_error ();
 }
 
-/* { dg-final { scan-tree-dump-times "Folded statement: if " 1 "store_ccp"} } */
-/* { dg-final { cleanup-tree-dump "store_ccp" } } */
+int main () { return 0; }
+

diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h
index 274e740496ed8dfa604b734a8965ec213b896812..fddd1dc71d0a671e741f95b5a0ca56e065ab0f74 100644 (file)
--- a/gcc/tree-flow.h
+++ b/gcc/tree-flow.h
@@ -940,6 +940,8 @@ void set_current_def (tree, tree);
 /* In tree-ssa-ccp.c  */
 bool fold_stmt (tree *);
 bool fold_stmt_inplace (tree);
+tree get_symbol_constant_value (tree);
+tree fold_const_aggregate_ref (tree);
 tree widen_bitfield (tree, tree, tree);
 
 /* In tree-vrp.c  */

diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 8b8a902169ee3a4d7e00510b61e0a9f12303d354..a1eaab2ca66b7e4864bdbc8c51cc6ecbca5c0bda 100644 (file)
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -295,23 +295,22 @@ ccp_decl_initial_min_invariant (tree t)
 /* If SYM is a constant variable with known value, return the value.
    NULL_TREE is returned otherwise.  */
 
-static tree
+tree
 get_symbol_constant_value (tree sym)
 {
   if (TREE_STATIC (sym)
       && TREE_READONLY (sym)
-      && !MTAG_P (sym)
-      /* Check if a read-only definition may be overridden at
-        link and run time.  */
-      && targetm.binds_local_p (sym))
+      && !MTAG_P (sym))
     {
       tree val = DECL_INITIAL (sym);
       if (val
          && ccp_decl_initial_min_invariant (val))
        return val;
       /* Variables declared 'const' without an initializer
-        have zero as the intializer.  */
+        have zero as the intializer if they may not be
+        overridden at link or run time.  */
       if (!val
+         && targetm.binds_local_p (sym)
           && (INTEGRAL_TYPE_P (TREE_TYPE (sym))
               || SCALAR_FLOAT_TYPE_P (TREE_TYPE (sym))))
         return fold_convert (TREE_TYPE (sym), integer_zero_node);
@@ -406,8 +405,12 @@ get_default_value (tree var)
 static inline prop_value_t *
 get_value (tree var)
 {
-  prop_value_t *val = &const_val[SSA_NAME_VERSION (var)];
+  prop_value_t *val;
 
+  if (const_val == NULL)
+    return NULL;
+
+  val = &const_val[SSA_NAME_VERSION (var)];
   if (val->lattice_val == UNINITIALIZED)
     *val = get_default_value (var);
 
@@ -722,6 +725,7 @@ ccp_finalize (void)
   bool something_changed = substitute_and_fold (const_val, false);
 
   free (const_val);
+  const_val = NULL;
   return something_changed;;
 }
 
@@ -1026,7 +1030,7 @@ ccp_fold (tree stmt)
    ARRAY_REF or COMPONENT_REF into constant aggregates.  Return
    NULL_TREE otherwise.  */
 
-static tree
+tree
 fold_const_aggregate_ref (tree t)
 {
   prop_value_t *value;

diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 3b42c241fb9bcfeed8e8e42c122f5f0d1d35d4a2..b10d3e31a85dadf465d889b522afa6e51f55fc89 100644 (file)
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -1597,48 +1597,46 @@ simplify_unary_expression (tree rhs)
 static tree
 try_to_simplify (tree stmt, tree rhs)
 {
+  tree tem;
+
   /* For stores we can end up simplifying a SSA_NAME rhs.  Just return
      in this case, there is no point in doing extra work.  */
   if (TREE_CODE (rhs) == SSA_NAME)
     return rhs;
-  else
+
+  switch (TREE_CODE_CLASS (TREE_CODE (rhs)))
     {
-      switch (TREE_CODE_CLASS (TREE_CODE (rhs)))
-       {
-         /* For references, see if we find a result for the lookup,
-            and use it if we do.  */
-       case tcc_declaration:
-         /* Pull out any truly constant values.  */
-         if (TREE_READONLY (rhs)
-             && TREE_STATIC (rhs)
-             && DECL_INITIAL (rhs)
-             && valid_gimple_expression_p (DECL_INITIAL (rhs)))
-           return DECL_INITIAL (rhs);
-
-           /* Fallthrough. */
-       case tcc_reference:
-         /* Do not do full-blown reference lookup here.
-            ???  But like for tcc_declaration, we should simplify
-                 from constant initializers.  */
-
-         /* Fallthrough for some codes that can operate on registers.  */
-         if (!(TREE_CODE (rhs) == REALPART_EXPR
-               || TREE_CODE (rhs) == IMAGPART_EXPR
-               || TREE_CODE (rhs) == VIEW_CONVERT_EXPR))
-           break;
-         /* We could do a little more with unary ops, if they expand
-            into binary ops, but it's debatable whether it is worth it. */
-       case tcc_unary:
-         return simplify_unary_expression (rhs);
-         break;
-       case tcc_comparison:
-       case tcc_binary:
-         return simplify_binary_expression (stmt, rhs);
-         break;
-       default:
-         break;
-       }
+    case tcc_declaration:
+      tem = get_symbol_constant_value (rhs);
+      if (tem)
+       return tem;
+      break;
+
+    case tcc_reference:
+      /* Do not do full-blown reference lookup here, but simplify
+        reads from constant aggregates.  */
+      tem = fold_const_aggregate_ref (rhs);
+      if (tem)
+       return tem;
+
+      /* Fallthrough for some codes that can operate on registers.  */
+      if (!(TREE_CODE (rhs) == REALPART_EXPR
+           || TREE_CODE (rhs) == IMAGPART_EXPR
+           || TREE_CODE (rhs) == VIEW_CONVERT_EXPR))
+       break;
+      /* We could do a little more with unary ops, if they expand
+        into binary ops, but it's debatable whether it is worth it. */
+    case tcc_unary:
+      return simplify_unary_expression (rhs);
+      break;
+    case tcc_comparison:
+    case tcc_binary:
+      return simplify_binary_expression (stmt, rhs);
+      break;
+    default:
+      break;
     }
+
   return rhs;
 }