From: Richard Biener Date: Fri, 6 Nov 2020 11:44:47 +0000 (+0100) Subject: refactor SLP analysis X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=b88fdcc1c3675330031b0cff35ecf14b53616321;p=gcc.git refactor SLP analysis This passes down the graph entry kind down to vect_analyze_slp_instance which simplifies it and makes it a shallow wrapper around vect_build_slp_instance. 2020-11-06 Richard Biener * tree-vect-slp.c (vect_analyze_slp): Pass down the SLP graph entry kind. (vect_analyze_slp_instance): Simplify. (vect_build_slp_instance): Adjust. (vect_slp_check_for_constructors): Perform more eligibility checks here. --- diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c index 4d1f17bd3fa..88e637e30dc 100644 --- a/gcc/tree-vect-slp.c +++ b/gcc/tree-vect-slp.c @@ -2174,7 +2174,8 @@ calculate_unrolling_factor (poly_uint64 nunits, unsigned int group_size) static bool vect_analyze_slp_instance (vec_info *vinfo, scalar_stmts_to_slp_tree_map_t *bst_map, - stmt_vec_info stmt_info, unsigned max_tree_size); + stmt_vec_info stmt_info, slp_instance_kind kind, + unsigned max_tree_size); /* Analyze an SLP instance starting from SCALAR_STMTS which are a group of KIND. Return true if successful. */ @@ -2375,7 +2376,7 @@ vect_build_slp_instance (vec_info *vinfo, stmt_vec_info rest = vect_split_slp_store_group (stmt_info, group1_size); bool res = vect_analyze_slp_instance (vinfo, bst_map, stmt_info, - max_tree_size); + kind, max_tree_size); /* Split the rest at the failure point and possibly re-analyze the remaining matching part if it has at least two lanes. */ @@ -2386,14 +2387,14 @@ vect_build_slp_instance (vec_info *vinfo, stmt_vec_info rest2 = rest; rest = vect_split_slp_store_group (rest, i - group1_size); if (i - group1_size > 1) - res |= vect_analyze_slp_instance (vinfo, bst_map, - rest2, max_tree_size); + res |= vect_analyze_slp_instance (vinfo, bst_map, rest2, + kind, max_tree_size); } /* Re-analyze the non-matching tail if it has at least two lanes. */ if (i + 1 < group_size) res |= vect_analyze_slp_instance (vinfo, bst_map, - rest, max_tree_size); + rest, kind, max_tree_size); return res; } } @@ -2418,10 +2419,10 @@ vect_build_slp_instance (vec_info *vinfo, DR_GROUP_GAP (stmt_info) = 0; bool res = vect_analyze_slp_instance (vinfo, bst_map, stmt_info, - max_tree_size); + kind, max_tree_size); if (i + 1 < group_size) res |= vect_analyze_slp_instance (vinfo, bst_map, - rest, max_tree_size); + rest, kind, max_tree_size); return res; } @@ -2444,59 +2445,34 @@ vect_build_slp_instance (vec_info *vinfo, static bool vect_analyze_slp_instance (vec_info *vinfo, scalar_stmts_to_slp_tree_map_t *bst_map, - stmt_vec_info stmt_info, unsigned max_tree_size) + stmt_vec_info stmt_info, + slp_instance_kind kind, + unsigned max_tree_size) { - unsigned int group_size; unsigned int i; - struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info); vec scalar_stmts; - slp_instance_kind kind; if (is_a (vinfo)) vect_location = stmt_info->stmt; - if (STMT_VINFO_GROUPED_ACCESS (stmt_info)) - { - kind = slp_inst_kind_store; - group_size = DR_GROUP_SIZE (stmt_info); - } - else if (!dr && REDUC_GROUP_FIRST_ELEMENT (stmt_info)) - { - kind = slp_inst_kind_reduc_chain; - gcc_assert (is_a (vinfo)); - group_size = REDUC_GROUP_SIZE (stmt_info); - } - else if (is_gimple_assign (stmt_info->stmt) - && gimple_assign_rhs_code (stmt_info->stmt) == CONSTRUCTOR) - { - kind = slp_inst_kind_ctor; - group_size = CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt_info->stmt)); - } - else - { - kind = slp_inst_kind_reduc_group; - gcc_assert (is_a (vinfo)); - group_size = as_a (vinfo)->reductions.length (); - } - /* Create a node (a root of the SLP tree) for the packed grouped stores. */ - scalar_stmts.create (group_size); stmt_vec_info next_info = stmt_info; - if (STMT_VINFO_GROUPED_ACCESS (stmt_info)) + if (kind == slp_inst_kind_store) { - /* Collect the stores and store them in SLP_TREE_SCALAR_STMTS. */ + /* Collect the stores and store them in scalar_stmts. */ + scalar_stmts.create (DR_GROUP_SIZE (stmt_info)); while (next_info) { - scalar_stmts.safe_push (vect_stmt_to_vectorize (next_info)); + scalar_stmts.quick_push (vect_stmt_to_vectorize (next_info)); next_info = DR_GROUP_NEXT_ELEMENT (next_info); } } - else if (!dr && REDUC_GROUP_FIRST_ELEMENT (stmt_info)) + else if (kind == slp_inst_kind_reduc_chain) { - /* Collect the reduction stmts and store them in - SLP_TREE_SCALAR_STMTS. */ + /* Collect the reduction stmts and store them in scalar_stmts. */ + scalar_stmts.create (REDUC_GROUP_SIZE (stmt_info)); while (next_info) { - scalar_stmts.safe_push (vect_stmt_to_vectorize (next_info)); + scalar_stmts.quick_push (vect_stmt_to_vectorize (next_info)); next_info = REDUC_GROUP_NEXT_ELEMENT (next_info); } /* Mark the first element of the reduction chain as reduction to properly @@ -2511,30 +2487,23 @@ vect_analyze_slp_instance (vec_info *vinfo, { tree rhs = gimple_assign_rhs1 (stmt_info->stmt); tree val; + scalar_stmts.create (CONSTRUCTOR_NELTS (rhs)); FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val) { - if (TREE_CODE (val) == SSA_NAME) - { - gimple* def = SSA_NAME_DEF_STMT (val); - stmt_vec_info def_info = vinfo->lookup_stmt (def); - /* Value is defined in another basic block. */ - if (!def_info) - return false; - def_info = vect_stmt_to_vectorize (def_info); - scalar_stmts.safe_push (def_info); - } - else - return false; + stmt_vec_info def_info = vinfo->lookup_def (val); + def_info = vect_stmt_to_vectorize (def_info); + scalar_stmts.quick_push (def_info); } if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "Analyzing vectorizable constructor: %G\n", stmt_info->stmt); } - else + else if (kind == slp_inst_kind_reduc_group) { /* Collect reduction statements. */ vec reductions = as_a (vinfo)->reductions; + scalar_stmts.create (reductions.length ()); for (i = 0; reductions.iterate (i, &next_info); i++) if (STMT_VINFO_RELEVANT_P (next_info) || STMT_VINFO_LIVE_P (next_info)) @@ -2543,13 +2512,16 @@ vect_analyze_slp_instance (vec_info *vinfo, if (scalar_stmts.length () < 2) return false; } + else + gcc_unreachable (); /* Build the tree for the SLP instance. */ bool res = vect_build_slp_instance (vinfo, kind, scalar_stmts, kind == slp_inst_kind_ctor ? stmt_info : NULL, - max_tree_size, - bst_map, stmt_info); + max_tree_size, bst_map, + kind == slp_inst_kind_store + ? stmt_info : NULL); /* ??? If this is slp_inst_kind_store and the above succeeded here's where we should do store group splitting. */ @@ -2573,7 +2545,10 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size) /* Find SLP sequences starting from groups of grouped stores. */ FOR_EACH_VEC_ELT (vinfo->grouped_stores, i, first_element) - vect_analyze_slp_instance (vinfo, bst_map, first_element, max_tree_size); + vect_analyze_slp_instance (vinfo, bst_map, first_element, + STMT_VINFO_GROUPED_ACCESS (first_element) + ? slp_inst_kind_store : slp_inst_kind_ctor, + max_tree_size); if (loop_vec_info loop_vinfo = dyn_cast (vinfo)) { @@ -2583,6 +2558,7 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size) && ! STMT_VINFO_LIVE_P (first_element)) ; else if (! vect_analyze_slp_instance (vinfo, bst_map, first_element, + slp_inst_kind_reduc_chain, max_tree_size)) { /* Dissolve reduction chain group. */ @@ -2604,7 +2580,7 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size) /* Find SLP sequences starting from groups of reductions. */ if (loop_vinfo->reductions.length () > 1) vect_analyze_slp_instance (vinfo, bst_map, loop_vinfo->reductions[0], - max_tree_size); + slp_inst_kind_reduc_group, max_tree_size); } /* The map keeps a reference on SLP nodes built, release that. */ @@ -4033,6 +4009,15 @@ vect_slp_check_for_constructors (bb_vec_info bb_vinfo) || uniform_vector_p (rhs)) continue; + unsigned j; + tree val; + FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), j, val) + if (TREE_CODE (val) != SSA_NAME + || !bb_vinfo->lookup_def (val)) + break; + if (j != CONSTRUCTOR_NELTS (rhs)) + continue; + stmt_vec_info stmt_info = bb_vinfo->lookup_stmt (assign); BB_VINFO_GROUPED_STORES (bb_vinfo).safe_push (stmt_info); }