re PR middle-end/67891 (FAIL: gcc.dg/pr43300.c (internal compiler error) on alpha...

2015-10-09  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/67891
	* gimple-match.h (gimple_simplified_result_is_gimple_val):
	New helper.
	(gimple_resimplify1): Declare.
	(gimple_resimplify2): Likewise.
	(gimple_resimplify3): Likewise.
	* gimple-match-head.c (gimple_resimplify1): Export.
	(gimple_resimplify2): Likewise.
	(gimple_resimplify3): Likewise.
	(maybe_push_res_to_seq): Use gimple_simplified_result_is_gimple_val.
	* gimple-fold.c (gimple_fold_stmt_to_constant_1): Likewise.
	* tree-ssa-sccvn.c (visit_reference_op_load): Use gimple_resimplify1
	to avoid creating stmts without VN info.

	* gcc.dg/tree-ssa/pr67891.c: New testcase.

From-SVN: r228635

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index a1b9d1ba4899d983b526f80d7d267751e3459dcd..108cbdf5cf28e7f7c3a97fedae16d6de29387204 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,19 @@
+2015-10-09  Richard Biener  <rguenther@suse.de>
+
+       PR tree-optimization/67891
+       * gimple-match.h (gimple_simplified_result_is_gimple_val):
+       New helper.
+       (gimple_resimplify1): Declare.
+       (gimple_resimplify2): Likewise.
+       (gimple_resimplify3): Likewise.
+       * gimple-match-head.c (gimple_resimplify1): Export.
+       (gimple_resimplify2): Likewise.
+       (gimple_resimplify3): Likewise.
+       (maybe_push_res_to_seq): Use gimple_simplified_result_is_gimple_val.
+       * gimple-fold.c (gimple_fold_stmt_to_constant_1): Likewise.
+       * tree-ssa-sccvn.c (visit_reference_op_load): Use gimple_resimplify1
+       to avoid creating stmts without VN info.
+
 2015-10-08  Jan Hubicka  <hubicka@ucw.cz>
 
        * ipa-icf.c (sem_item::compare_symbol_references): Fix use

diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 0292f0495097fe6d494a206dd7e25eab29d797a4..ee2a320c1fcbd8eaacf531c8f053a332d15760f3 100644 (file)
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -4926,10 +4926,7 @@ gimple_fold_stmt_to_constant_1 (gimple *stmt, tree (*valueize) (tree),
   if (gimple_simplify (stmt, &rcode, ops, NULL, gvalueize, valueize))
     {
       tree res = NULL_TREE;
-      if (rcode.is_tree_code ()
-         && (TREE_CODE_LENGTH ((tree_code) rcode) == 0
-             || ((tree_code) rcode) == ADDR_EXPR)
-         && is_gimple_val (ops[0]))
+      if (gimple_simplified_result_is_gimple_val (rcode, ops))
        res = ops[0];
       else if (mprts_hook)
        res = mprts_hook (rcode, gimple_expr_type (stmt), ops);

diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c
index cab77a4e18db931e2df5a1f1e7f09eab5a48966f..16d8c5b7eb1ae62e7c4fb6ca1e0c9417ef601926 100644 (file)
--- a/gcc/gimple-match-head.c
+++ b/gcc/gimple-match-head.c
@@ -83,7 +83,7 @@ constant_for_folding (tree t)
    *RES_CODE and *RES_OPS with a simplified and/or canonicalized
    result and returns whether any change was made.  */
 
-static bool
+bool
 gimple_resimplify1 (gimple_seq *seq,
                    code_helper *res_code, tree type, tree *res_ops,
                    tree (*valueize)(tree))
@@ -139,7 +139,7 @@ gimple_resimplify1 (gimple_seq *seq,
    *RES_CODE and *RES_OPS with a simplified and/or canonicalized
    result and returns whether any change was made.  */
 
-static bool
+bool
 gimple_resimplify2 (gimple_seq *seq,
                    code_helper *res_code, tree type, tree *res_ops,
                    tree (*valueize)(tree))
@@ -208,7 +208,7 @@ gimple_resimplify2 (gimple_seq *seq,
    *RES_CODE and *RES_OPS with a simplified and/or canonicalized
    result and returns whether any change was made.  */
 
-static bool
+bool
 gimple_resimplify3 (gimple_seq *seq,
                    code_helper *res_code, tree type, tree *res_ops,
                    tree (*valueize)(tree))
@@ -308,9 +308,7 @@ maybe_push_res_to_seq (code_helper rcode, tree type, tree *ops,
   if (rcode.is_tree_code ())
     {
       if (!res
-         && (TREE_CODE_LENGTH ((tree_code) rcode) == 0
-             || ((tree_code) rcode) == ADDR_EXPR)
-         && is_gimple_val (ops[0]))
+         && gimple_simplified_result_is_gimple_val (rcode, ops))
        return ops[0];
       if (mprts_hook)
        {

diff --git a/gcc/gimple-match.h b/gcc/gimple-match.h
index 4663a34b8f9d0ede5a5cb4cbd1b94d5b7b5e8736..632e9a53d1c217ea7e880b73f808e0d370ade8cd 100644 (file)
--- a/gcc/gimple-match.h
+++ b/gcc/gimple-match.h
@@ -40,10 +40,28 @@ private:
   int rep;
 };
 
+/* Return whether OPS[0] with CODE is a non-expression result and
+   a gimple value.  */
+
+inline bool
+gimple_simplified_result_is_gimple_val (code_helper code, tree *ops)
+{
+  return (code.is_tree_code ()
+         && (TREE_CODE_LENGTH ((tree_code) code) == 0
+             || ((tree_code) code) == ADDR_EXPR)
+         && is_gimple_val (ops[0]));
+}
+
 extern tree (*mprts_hook) (code_helper, tree, tree *);
 
 bool gimple_simplify (gimple *, code_helper *, tree *, gimple_seq *,
                      tree (*)(tree), tree (*)(tree));
+bool gimple_resimplify1 (gimple_seq *, code_helper *, tree, tree *,
+                        tree (*)(tree));
+bool gimple_resimplify2 (gimple_seq *, code_helper *, tree, tree *,
+                        tree (*)(tree));
+bool gimple_resimplify3 (gimple_seq *, code_helper *, tree, tree *,
+                        tree (*)(tree));
 tree maybe_push_res_to_seq (code_helper, tree, tree *,
                            gimple_seq *, tree res = NULL_TREE);
 void maybe_build_generic_op (enum tree_code, tree, tree *, tree, tree);

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 378f8cda26f7b95a970ed4e1a2051c636be38da7..6ce8fab13935c300c0de10a498d22df04089c04a 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2015-10-09  Richard Biener  <rguenther@suse.de>
+
+       PR tree-optimization/67891
+       * gcc.dg/tree-ssa/pr67891.c: New testcase.
+
 2015-10-08  Richard Sandiford  <richard.sandiford@arm.com>
 
        * gcc.dg/builtins-47.c: Test the optimized dump instead.

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr67891.c b/gcc/testsuite/gcc.dg/tree-ssa/pr67891.c
new file mode 100644 (file)
index 0000000..792690e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr67891.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre1" } */
+
+unsigned int a, *b;
+unsigned short c;
+int d;
+
+void 
+fn1 ()
+{
+  b = &d;
+  *b = c = a; 
+  *b = d;
+}
+
+/* We should remove all loads but that from a.  */
+/* { dg-final { scan-tree-dump-not "= \[dbc\];" "fre1" } } */

diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 0432a5db82c6017a63f2a1a39125af97a10c8d37..f2eb213e96f8e3afe99e0ee955b602b2a9343e0c 100644 (file)
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -3043,38 +3043,41 @@ visit_reference_op_load (tree lhs, tree op, gimple *stmt)
         of VIEW_CONVERT_EXPR <TREE_TYPE (result)> (result).
         So first simplify and lookup this expression to see if it
         is already available.  */
-      gimple_seq stmts = NULL;
       mprts_hook = vn_lookup_simplify_result;
-      tree val = gimple_simplify (VIEW_CONVERT_EXPR, TREE_TYPE (op),
-                                 result, &stmts, vn_valueize);
+      code_helper rcode = VIEW_CONVERT_EXPR;
+      tree ops[3] = { result };
+      bool res = gimple_resimplify1 (NULL, &rcode, TREE_TYPE (op), ops,
+                                    vn_valueize);
       mprts_hook = NULL;
-      if (!val)
+      gimple *new_stmt = NULL;
+      if (res
+         && gimple_simplified_result_is_gimple_val (rcode, ops))
+       /* The expression is already available.  */
+       result = ops[0];
+      else
        {
-         val = vn_nary_op_lookup_pieces (1, VIEW_CONVERT_EXPR,
-                                         TREE_TYPE (op), &result, NULL);
+         tree val = vn_lookup_simplify_result (rcode, TREE_TYPE (op), ops);
          if (!val)
            {
-             val = make_ssa_name (TREE_TYPE (op));
-             gimple *new_stmt = gimple_build_assign (val, VIEW_CONVERT_EXPR,
-                                                     build1 (VIEW_CONVERT_EXPR,
-                                                             TREE_TYPE (op),
-                                                             result));
-             gimple_seq_add_stmt_without_update (&stmts, new_stmt);
+             gimple_seq stmts = NULL;
+             result = maybe_push_res_to_seq (rcode, TREE_TYPE (op), ops,
+                                             &stmts);
+             gcc_assert (result && gimple_seq_singleton_p (stmts));
+             new_stmt = gimple_seq_first_stmt (stmts);
            }
+         else
+           /* The expression is already available.  */
+           result = val;
        }
-      if (gimple_seq_empty_p (stmts))
-       /* The expression is already available.  */
-       result = val;
-      else
+      if (new_stmt)
        {
-         gcc_assert (gimple_seq_singleton_p (stmts));
          /* The expression is not yet available, value-number lhs to
             the new SSA_NAME we created.  */
-         result = val;
          /* Initialize value-number information properly.  */
          VN_INFO_GET (result)->valnum = result;
          VN_INFO (result)->value_id = get_next_value_id ();
-         VN_INFO (result)->expr = stmts;
+         gimple_seq_add_stmt_without_update (&VN_INFO (result)->expr,
+                                             new_stmt);
          VN_INFO (result)->needs_insertion = true;
          /* As all "inserted" statements are singleton SCCs, insert
             to the valid table.  This is strictly needed to
@@ -3086,18 +3089,17 @@ visit_reference_op_load (tree lhs, tree op, gimple *stmt)
          if (current_info == optimistic_info)
            {
              current_info = valid_info;
-             vn_nary_op_insert_stmt (gimple_seq_first_stmt (stmts), result);
+             vn_nary_op_insert_stmt (new_stmt, result);
              current_info = optimistic_info;
            }
          else
-           vn_nary_op_insert_stmt (gimple_seq_first_stmt (stmts), result);
+           vn_nary_op_insert_stmt (new_stmt, result);
          if (dump_file && (dump_flags & TDF_DETAILS))
            {
              fprintf (dump_file, "Inserting name ");
              print_generic_expr (dump_file, result, 0);
              fprintf (dump_file, " for expression ");
-             print_gimple_expr (dump_file, gimple_seq_first_stmt (stmts),
-                                0, TDF_SLIM);
+             print_gimple_expr (dump_file, new_stmt, 0, TDF_SLIM);
              fprintf (dump_file, "\n");
            }
        }