gimple-match.h (gimple_match_op::resimplify): New.

2019-07-09  Richard Biener  <rguenther@suse.de>

	* gimple-match.h (gimple_match_op::resimplify): New.
	(gimple_resimplify1, gimple_resimplify2, gimple_resimplify3,
	gimple_resimplify4, gimple_resimplify5): Remove.
	* gimple-match-head.c (gimple_resimplify1, gimple_resimplify2,
	gimple_resimplify3, gimple_resimplify4, gimple_resimplify5):
	Make static.
	(gimple_match_op::resimplify): New.
	* tree-ssa-sccvn.c (vn_nary_build_or_lookup_1): Valueize
	according to availability.  Use gimple_match_op::resimplify.

From-SVN: r273302

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 5a6a7f432b460a2524b534baf7734d1477d60b4e..271a27abfc68e98c12ebd478cb18850587cb1d6c 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,15 @@
+2019-07-09  Richard Biener  <rguenther@suse.de>
+
+       * gimple-match.h (gimple_match_op::resimplify): New.
+       (gimple_resimplify1, gimple_resimplify2, gimple_resimplify3,
+       gimple_resimplify4, gimple_resimplify5): Remove.
+       * gimple-match-head.c (gimple_resimplify1, gimple_resimplify2,
+       gimple_resimplify3, gimple_resimplify4, gimple_resimplify5):
+       Make static.
+       (gimple_match_op::resimplify): New.
+       * tree-ssa-sccvn.c (vn_nary_build_or_lookup_1): Valueize
+       according to availability.  Use gimple_match_op::resimplify. 
+
 2019-07-09  Eric Botcazou  <ebotcazou@adacore.com>
 
        * ira-emit.c (emit_moves): Skip DEBUG_INSNs when setting the location.

diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c
index df9f0c50590943597f3127a428a57a9a42387f3d..53278168a59f5ac10ce6760f04fd42589a0792e7 100644 (file)
--- a/gcc/gimple-match-head.c
+++ b/gcc/gimple-match-head.c
@@ -57,6 +57,16 @@ static bool gimple_simplify (gimple_match_op *, gimple_seq *, tree (*)(tree),
                             code_helper, tree, tree, tree, tree, tree);
 static bool gimple_simplify (gimple_match_op *, gimple_seq *, tree (*)(tree),
                             code_helper, tree, tree, tree, tree, tree, tree);
+static bool gimple_resimplify1 (gimple_seq *, gimple_match_op *,
+                               tree (*)(tree));
+static bool gimple_resimplify2 (gimple_seq *, gimple_match_op *,
+                               tree (*)(tree));
+static bool gimple_resimplify3 (gimple_seq *, gimple_match_op *,
+                               tree (*)(tree));
+static bool gimple_resimplify4 (gimple_seq *, gimple_match_op *,
+                               tree (*)(tree));
+static bool gimple_resimplify5 (gimple_seq *, gimple_match_op *,
+                               tree (*)(tree));
 
 const unsigned int gimple_match_op::MAX_NUM_OPS;
 
@@ -173,7 +183,7 @@ maybe_resimplify_conditional_op (gimple_seq *seq, gimple_match_op *res_op,
    RES_OP with a simplified and/or canonicalized result and
    returns whether any change was made.  */
 
-bool
+static bool
 gimple_resimplify1 (gimple_seq *seq, gimple_match_op *res_op,
                    tree (*valueize)(tree))
 {
@@ -233,7 +243,7 @@ gimple_resimplify1 (gimple_seq *seq, gimple_match_op *res_op,
    RES_OP with a simplified and/or canonicalized result and
    returns whether any change was made.  */
 
-bool
+static bool
 gimple_resimplify2 (gimple_seq *seq, gimple_match_op *res_op,
                    tree (*valueize)(tree))
 {
@@ -305,7 +315,7 @@ gimple_resimplify2 (gimple_seq *seq, gimple_match_op *res_op,
    RES_OP with a simplified and/or canonicalized result and
    returns whether any change was made.  */
 
-bool
+static bool
 gimple_resimplify3 (gimple_seq *seq, gimple_match_op *res_op,
                    tree (*valueize)(tree))
 {
@@ -376,7 +386,7 @@ gimple_resimplify3 (gimple_seq *seq, gimple_match_op *res_op,
    RES_OP with a simplified and/or canonicalized result and
    returns whether any change was made.  */
 
-bool
+static bool
 gimple_resimplify4 (gimple_seq *seq, gimple_match_op *res_op,
                    tree (*valueize)(tree))
 {
@@ -417,7 +427,7 @@ gimple_resimplify4 (gimple_seq *seq, gimple_match_op *res_op,
    RES_OP with a simplified and/or canonicalized result and
    returns whether any change was made.  */
 
-bool
+static bool
 gimple_resimplify5 (gimple_seq *seq, gimple_match_op *res_op,
                    tree (*valueize)(tree))
 {
@@ -439,6 +449,30 @@ gimple_resimplify5 (gimple_seq *seq, gimple_match_op *res_op,
   return false;
 }
 
+/* Match and simplify the toplevel valueized operation THIS.
+   Replaces THIS with a simplified and/or canonicalized result and
+   returns whether any change was made.  */
+
+bool
+gimple_match_op::resimplify (gimple_seq *seq, tree (*valueize)(tree))
+{
+  switch (num_ops)
+    {
+    case 1:
+      return gimple_resimplify1 (seq, this, valueize);
+    case 2:
+      return gimple_resimplify2 (seq, this, valueize);
+    case 3:
+      return gimple_resimplify3 (seq, this, valueize);
+    case 4:
+      return gimple_resimplify4 (seq, this, valueize);
+    case 5:
+      return gimple_resimplify5 (seq, this, valueize);
+    default:
+      gcc_unreachable ();
+    }
+}
+
 /* If in GIMPLE the operation described by RES_OP should be single-rhs,
    build a GENERIC tree for that expression and update RES_OP accordingly.  */
 

diff --git a/gcc/gimple-match.h b/gcc/gimple-match.h
index 22fa86c3a7c7cfe11d2056619ce30b985ec80f2b..ad7f73040f12fc2876e98319688488cde01cba83 100644 (file)
--- a/gcc/gimple-match.h
+++ b/gcc/gimple-match.h
@@ -105,6 +105,8 @@ struct gimple_match_op
 
   tree op_or_null (unsigned int) const;
 
+  bool resimplify (gimple_seq *, tree (*)(tree));
+
   /* The maximum value of NUM_OPS.  */
   static const unsigned int MAX_NUM_OPS = 5;
 
@@ -331,11 +333,6 @@ extern tree (*mprts_hook) (gimple_match_op *);
 
 bool gimple_simplify (gimple *, gimple_match_op *, gimple_seq *,
                      tree (*)(tree), tree (*)(tree));
-bool gimple_resimplify1 (gimple_seq *, gimple_match_op *, tree (*)(tree));
-bool gimple_resimplify2 (gimple_seq *, gimple_match_op *, tree (*)(tree));
-bool gimple_resimplify3 (gimple_seq *, gimple_match_op *, tree (*)(tree));
-bool gimple_resimplify4 (gimple_seq *, gimple_match_op *, tree (*)(tree));
-bool gimple_resimplify5 (gimple_seq *, gimple_match_op *, tree (*)(tree));
 tree maybe_push_res_to_seq (gimple_match_op *, gimple_seq *,
                            tree res = NULL_TREE);
 void maybe_build_generic_op (gimple_match_op *);

diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 627ee8fecb2cf4d21ba0afd9c04d582f6151910b..9186f15e39b2cc7373b7c6db180d66892514826a 100644 (file)
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -1968,21 +1968,25 @@ vn_nary_build_or_lookup_1 (gimple_match_op *res_op, bool insert)
        RCODE (OPS...).
      So first simplify and lookup this expression to see if it
      is already available.  */
-  mprts_hook = vn_lookup_simplify_result;
+  /* For simplification valueize.  */
+  unsigned i;
+  for (i = 0; i < res_op->num_ops; ++i)
+    if (TREE_CODE (res_op->ops[i]) == SSA_NAME)
+      {
+       tree tem = vn_valueize (res_op->ops[i]);
+       if (!tem)
+         break;
+       res_op->ops[i] = tem;
+      }
+  /* If valueization of an operand fails (it is not available), skip
+     simplification.  */
   bool res = false;
-  switch (TREE_CODE_LENGTH ((tree_code) res_op->code))
+  if (i == res_op->num_ops)
     {
-    case 1:
-      res = gimple_resimplify1 (NULL, res_op, vn_valueize);
-      break;
-    case 2:
-      res = gimple_resimplify2 (NULL, res_op, vn_valueize);
-      break;
-    case 3:
-      res = gimple_resimplify3 (NULL, res_op, vn_valueize);
-      break;
+      mprts_hook = vn_lookup_simplify_result;
+      res = res_op->resimplify (NULL, vn_valueize);
+      mprts_hook = NULL;
     }
-  mprts_hook = NULL;
   gimple *new_stmt = NULL;
   if (res
       && gimple_simplified_result_is_gimple_val (res_op))