OSDN Git Service

* tree-ssa-reassoc.c (undistribute_ops_list): Use create_tmp_reg.
authormatz <matz@138bc75d-0d04-0410-961f-82ee72b054a4>
Mon, 10 May 2010 14:31:37 +0000 (14:31 +0000)
committerMasaki Muranaka <monaka@monami-software.com>
Sun, 23 May 2010 05:04:23 +0000 (14:04 +0900)
(can_reassociate_p): Use FLOAT_TYPE_P.
* tree-vectorizer.h (vect_is_simple_reduction): Rename to ...
(vect_force_simple_reduction): ... this.
* tree-parloops.c (gather_scalar_reductions): Use
vect_force_simple_reduction.
* tree-vect-loop.c (vect_is_simple_reduction_1): Rename from
vect_is_simple_reduction, add modify argument, if true rewrite
"a-b" into "a+(-b)".
(vect_is_simple_reduction, vect_force_simple_reduction): New
functions.
(vect_analyze_scalar_cycles_1): Use vect_force_simple_reduction.

testsuite/
* gcc.dg/vect/fast-math-vect-reduc-8.c: New test.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@159226 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/testsuite/ChangeLog
gcc/tree-ssa-reassoc.c
gcc/tree-vect-loop.c
gcc/tree-vectorizer.h

index 86156f7..a0bd1f0 100644 (file)
@@ -1,5 +1,20 @@
-2010-05-10  H.J. Lu<hongjiu.lu@intel.com>
-           Vladimir Makarov<vmakarov@redhat.com>
+2010-05-10  Michael Matz  <matz@suse.de>
+
+       * tree-ssa-reassoc.c (undistribute_ops_list): Use create_tmp_reg.
+       (can_reassociate_p): Use FLOAT_TYPE_P.
+       * tree-vectorizer.h (vect_is_simple_reduction): Rename to ...
+       (vect_force_simple_reduction): ... this.
+       * tree-parloops.c (gather_scalar_reductions): Use 
+       vect_force_simple_reduction.
+       * tree-vect-loop.c (vect_is_simple_reduction_1): Rename from
+       vect_is_simple_reduction, add modify argument, if true rewrite
+       "a-b" into "a+(-b)".
+       (vect_is_simple_reduction, vect_force_simple_reduction): New
+       functions.
+       (vect_analyze_scalar_cycles_1): Use vect_force_simple_reduction.
+
+2010-05-10  H.J. Lu  <hongjiu.lu@intel.com>
+           Vladimir Makarov  <vmakarov@redhat.com>
 
        PR rtl-optimization/44012
        * ira-build.c (remove_unnecessary_allocnos): Nullify
index 3208c84..252c451 100644 (file)
@@ -1,3 +1,7 @@
+2010-05-10  Michael Matz  <matz@suse.de>
+
+       * gcc.dg/vect/fast-math-vect-reduc-8.c: New test.
+
 2010-05-10  H.J. Lu  <hongjiu.lu@intel.com>
 
        PR rtl-optimization/44012
index 6bdb57e..ae630e5 100644 (file)
@@ -1165,7 +1165,7 @@ undistribute_ops_list (enum tree_code opcode,
              fprintf (dump_file, "Building (");
              print_generic_expr (dump_file, oe1->op, 0);
            }
-         tmpvar = create_tmp_var (TREE_TYPE (oe1->op), NULL);
+         tmpvar = create_tmp_reg (TREE_TYPE (oe1->op), NULL);
          add_referenced_var (tmpvar);
          zero_one_operation (&oe1->op, c->oecode, c->op);
          EXECUTE_IF_SET_IN_SBITMAP (candidates2, first+1, i, sbi0)
@@ -1948,7 +1948,7 @@ can_reassociate_p (tree op)
   tree type = TREE_TYPE (op);
   if (INTEGRAL_TYPE_P (type)
       || NON_SAT_FIXED_POINT_TYPE_P (type)
-      || (flag_associative_math && SCALAR_FLOAT_TYPE_P (type)))
+      || (flag_associative_math && FLOAT_TYPE_P (type)))
     return true;
   return false;
 }
index 83b823d..8acc992 100644 (file)
@@ -513,8 +513,8 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
       gcc_assert (STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_unknown_def_type);
 
       nested_cycle = (loop != LOOP_VINFO_LOOP (loop_vinfo));
-      reduc_stmt = vect_is_simple_reduction (loop_vinfo, phi, !nested_cycle,
-                                             &double_reduc);
+      reduc_stmt = vect_force_simple_reduction (loop_vinfo, phi, !nested_cycle,
+                                               &double_reduc);
       if (reduc_stmt)
         {
           if (double_reduc)
@@ -1584,7 +1584,7 @@ report_vect_op (gimple stmt, const char *msg)
 }
 
 
-/* Function vect_is_simple_reduction
+/* Function vect_is_simple_reduction_1
 
    (1) Detect a cross-iteration def-use cycle that represents a simple
    reduction computation. We look for the following pattern:
@@ -1612,18 +1612,23 @@ report_vect_op (gimple stmt, const char *msg)
      a1 = phi < a0, a2 >
      inner loop (def of a3)
      a2 = phi < a3 >
+
+   If MODIFY is true it tries also to rework the code in-place to enable
+   detection of more reduction patterns.  For the time being we rewrite
+   "res -= RHS" into "rhs += -RHS" when it seems worthwhile.
 */
 
-gimple
-vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
-                          bool check_reduction, bool *double_reduc)
+static gimple
+vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
+                           bool check_reduction, bool *double_reduc,
+                           bool modify)
 {
   struct loop *loop = (gimple_bb (phi))->loop_father;
   struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
   edge latch_e = loop_latch_edge (loop);
   tree loop_arg = PHI_ARG_DEF_FROM_EDGE (phi, latch_e);
   gimple def_stmt, def1 = NULL, def2 = NULL;
-  enum tree_code code;
+  enum tree_code orig_code, code;
   tree op1, op2, op3 = NULL_TREE, op4 = NULL_TREE;
   tree type;
   int nloop_uses;
@@ -1743,7 +1748,14 @@ vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
       return NULL;
     }
 
-  code = gimple_assign_rhs_code (def_stmt);
+  code = orig_code = gimple_assign_rhs_code (def_stmt);
+
+  /* We can handle "res -= x[i]", which is non-associative by
+     simply rewriting this into "res += -x[i]".  Avoid changing
+     gimple instruction for the first simple tests and only do this
+     if we're allowed to change code at all.  */
+  if (code == MINUS_EXPR && modify)
+    code = PLUS_EXPR;
 
   if (check_reduction
       && (!commutative_tree_code (code) || !associative_tree_code (code)))
@@ -1863,6 +1875,24 @@ vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
       return NULL;
     }
 
+  /* If we detected "res -= x[i]" earlier, rewrite it into
+     "res += -x[i]" now.  If this turns out to be useless reassoc
+     will clean it up again.  */
+  if (orig_code == MINUS_EXPR)
+    {
+      tree rhs = gimple_assign_rhs2 (def_stmt);
+      tree negrhs = make_ssa_name (SSA_NAME_VAR (rhs), NULL);
+      gimple negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
+                                                        rhs, NULL);
+      gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
+      set_vinfo_for_stmt (negate_stmt, new_stmt_vec_info (negate_stmt, 
+                                                         loop_info, NULL));
+      gsi_insert_before (&gsi, negate_stmt, GSI_NEW_STMT);
+      gimple_assign_set_rhs2 (def_stmt, negrhs);
+      gimple_assign_set_rhs_code (def_stmt, PLUS_EXPR);
+      update_stmt (def_stmt);
+    }
+
   /* Reduction is safe. We're dealing with one of the following:
      1) integer arithmetic and no trapv
      2) floating point arithmetic, and special flags permit this optimization
@@ -1940,6 +1970,28 @@ vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
     }
 }
 
+/* Wrapper around vect_is_simple_reduction_1, that won't modify code
+   in-place.  Arguments as there.  */
+
+static gimple
+vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
+                          bool check_reduction, bool *double_reduc)
+{
+  return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
+                                    double_reduc, false);
+}
+
+/* Wrapper around vect_is_simple_reduction_1, which will modify code
+   in-place if it enables detection of more reductions.  Arguments
+   as there.  */
+
+gimple
+vect_force_simple_reduction (loop_vec_info loop_info, gimple phi,
+                          bool check_reduction, bool *double_reduc)
+{
+  return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
+                                    double_reduc, true);
+}
 
 /* Function vect_estimate_min_profitable_iters
 
index fc9f0e9..79fe6ab 100644 (file)
@@ -846,7 +846,7 @@ extern tree vect_create_addr_base_for_vector_ref (gimple, gimple_seq *,
 /* In tree-vect-loop.c.  */
 /* FORNOW: Used in tree-parloops.c.  */
 extern void destroy_loop_vec_info (loop_vec_info, bool);
-extern gimple vect_is_simple_reduction (loop_vec_info, gimple, bool, bool *);
+extern gimple vect_force_simple_reduction (loop_vec_info, gimple, bool, bool *);
 /* Drive for loop analysis stage.  */
 extern loop_vec_info vect_analyze_loop (struct loop *);
 /* Drive for loop transformation stage.  */