re PR tree-optimization/72866 (Compile time hog w/ -O3 (-Ofast))

	PR tree-optimization/72866
	* tree-vect-patterns.c (search_type_for_mask): Turn into
	a small wrapper, move all code to ...
	(search_type_for_mask_1): ... this new function.  Add caching
	and adjust recursive calls.

	* gcc.dg/vect/pr72866.c: New test.

From-SVN: r239856

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 3e394ccbcfe0c04de98355803067650bfbf41961..f9f91690d5ba2adc64c64f080ad25788a8940add 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,11 @@
 2016-08-30  Jakub Jelinek  <jakub@redhat.com>
 
+       PR tree-optimization/72866
+       * tree-vect-patterns.c (search_type_for_mask): Turn into
+       a small wrapper, move all code to ...
+       (search_type_for_mask_1): ... this new function.  Add caching
+       and adjust recursive calls.
+
        PR debug/77363
        * dwarf2out.c (modified_type_die): Use lookup_type_die (type)
        instead of lookup_type_die (type_main_variant (type)) even for array

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 4f6142aca6b4b9a99dc9dd2c94a5b9fc80d5d748..1691cff63a171832920a1a13ce33ba3c709f4edc 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,5 +1,8 @@
 2016-08-30  Jakub Jelinek  <jakub@redhat.com>
 
+       PR tree-optimization/72866
+       * gcc.dg/vect/pr72866.c: New test.
+
        PR debug/77363
        * g++.dg/debug/dwarf2/pr77363.C: New test.
 

diff --git a/gcc/testsuite/gcc.dg/vect/pr72866.c b/gcc/testsuite/gcc.dg/vect/pr72866.c
new file mode 100644 (file)
index 0000000..a2ccbbb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr72866.c
@@ -0,0 +1,19 @@
+/* PR tree-optimization/72866 */
+/* { dg-do compile } */
+
+unsigned int dl;
+int rx, lb;
+
+void
+fo (int jv, int be)
+{
+  const unsigned int xw = 16;
+  unsigned int ya, wo;
+
+  for (ya = 0; ya < 2; ++ya)
+    for (wo = 0; wo < xw; ++wo)
+      {
+       dl += (jv ? be : rx);
+       rx += ((lb == 0) + 1);
+      }
+}

diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c
index 2457844857df38786650d84e8e972808f77636b9..7e6e45d1d54051e8377bf7c72cc6fba063b4c35b 100644 (file)
--- a/gcc/tree-vect-patterns.c
+++ b/gcc/tree-vect-patterns.c
@@ -3459,13 +3459,11 @@ adjust_bool_stmts (hash_set <gimple *> &bool_stmt_set,
   return gimple_assign_lhs (pattern_stmt);
 }
 
-/* Return the proper type for converting bool VAR into
-   an integer value or NULL_TREE if no such type exists.
-   The type is chosen so that converted value has the
-   same number of elements as VAR's vector type.  */
+/* Helper for search_type_for_mask.  */
 
 static tree
-search_type_for_mask (tree var, vec_info *vinfo)
+search_type_for_mask_1 (tree var, vec_info *vinfo,
+                       hash_map<gimple *, tree> &cache)
 {
   gimple *def_stmt;
   enum vect_def_type dt;
@@ -3490,6 +3488,10 @@ search_type_for_mask (tree var, vec_info *vinfo)
   if (!is_gimple_assign (def_stmt))
     return NULL_TREE;
 
+  tree *c = cache.get (def_stmt);
+  if (c)
+    return *c;
+
   rhs_code = gimple_assign_rhs_code (def_stmt);
   rhs1 = gimple_assign_rhs1 (def_stmt);
 
@@ -3498,14 +3500,15 @@ search_type_for_mask (tree var, vec_info *vinfo)
     case SSA_NAME:
     case BIT_NOT_EXPR:
     CASE_CONVERT:
-      res = search_type_for_mask (rhs1, vinfo);
+      res = search_type_for_mask_1 (rhs1, vinfo, cache);
       break;
 
     case BIT_AND_EXPR:
     case BIT_IOR_EXPR:
     case BIT_XOR_EXPR:
-      res = search_type_for_mask (rhs1, vinfo);
-      res2 = search_type_for_mask (gimple_assign_rhs2 (def_stmt), vinfo);
+      res = search_type_for_mask_1 (rhs1, vinfo, cache);
+      res2 = search_type_for_mask_1 (gimple_assign_rhs2 (def_stmt), vinfo,
+                                    cache);
       if (!res || (res2 && TYPE_PRECISION (res) > TYPE_PRECISION (res2)))
        res = res2;
       break;
@@ -3517,8 +3520,9 @@ search_type_for_mask (tree var, vec_info *vinfo)
 
          if (TREE_CODE (TREE_TYPE (rhs1)) == BOOLEAN_TYPE)
            {
-             res = search_type_for_mask (rhs1, vinfo);
-             res2 = search_type_for_mask (gimple_assign_rhs2 (def_stmt), vinfo);
+             res = search_type_for_mask_1 (rhs1, vinfo, cache);
+             res2 = search_type_for_mask_1 (gimple_assign_rhs2 (def_stmt),
+                                            vinfo, cache);
              if (!res || (res2 && TYPE_PRECISION (res) > TYPE_PRECISION (res2)))
                res = res2;
              break;
@@ -3526,12 +3530,18 @@ search_type_for_mask (tree var, vec_info *vinfo)
 
          comp_vectype = get_vectype_for_scalar_type (TREE_TYPE (rhs1));
          if (comp_vectype == NULL_TREE)
-           return NULL_TREE;
+           {
+             res = NULL_TREE;
+             break;
+           }
 
          mask_type = get_mask_type_for_scalar_type (TREE_TYPE (rhs1));
          if (!mask_type
              || !expand_vec_cmp_expr_p (comp_vectype, mask_type))
-           return NULL_TREE;
+           {
+             res = NULL_TREE;
+             break;
+           }
 
          if (TREE_CODE (TREE_TYPE (rhs1)) != INTEGER_TYPE
              || !TYPE_UNSIGNED (TREE_TYPE (rhs1)))
@@ -3544,9 +3554,21 @@ search_type_for_mask (tree var, vec_info *vinfo)
        }
     }
 
+  cache.put (def_stmt, res);
   return res;
 }
 
+/* Return the proper type for converting bool VAR into
+   an integer value or NULL_TREE if no such type exists.
+   The type is chosen so that converted value has the
+   same number of elements as VAR's vector type.  */
+
+static tree
+search_type_for_mask (tree var, vec_info *vinfo)
+{
+  hash_map<gimple *, tree> cache;
+  return search_type_for_mask_1 (var, vinfo, cache);
+}
 
 /* Function vect_recog_bool_pattern