git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[13/46] Make STMT_VINFO_RELATED_STMT a stmt_vec_info 

This patch changes STMT_VINFO_RELATED_STMT from a gimple stmt to a
stmt_vec_info.

2018-07-31  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (_stmt_vec_info::related_stmt): Change from
	a gimple stmt to a stmt_vec_info.
	(is_pattern_stmt_p): Update accordingly.
	* tree-vect-data-refs.c (vect_preserves_scalar_order_p): Likewise.
	(vect_record_grouped_load_vectors): Likewise.
	* tree-vect-loop.c (vect_determine_vf_for_stmt): Likewise.
	(vect_fixup_reduc_chain, vect_update_vf_for_slp): Likewise.
	(vect_model_reduction_cost): Likewise.
	(vect_create_epilog_for_reduction): Likewise.
	(vectorizable_reduction, vectorizable_induction): Likewise.
	* tree-vect-patterns.c (vect_init_pattern_stmt): Likewise.
	Return the stmt_vec_info for the pattern statement.
	(vect_set_pattern_stmt): Update use of STMT_VINFO_RELATED_STMT.
	(vect_split_statement, vect_mark_pattern_stmts): Likewise.
	* tree-vect-slp.c (vect_detect_hybrid_slp_stmts): Likewise.
	(vect_detect_hybrid_slp, vect_get_slp_defs): Likewise.
	* tree-vect-stmts.c (vect_mark_relevant): Likewise.
	(vect_get_vec_def_for_operand_1, vectorizable_call): Likewise.
	(vectorizable_simd_clone_call, vect_analyze_stmt, new_stmt_vec_info)
	(free_stmt_vec_info, vect_is_simple_use): Likewise.

From-SVN: r263128
This commit is contained in:
Richard Sandiford 2018-07-31 14:22:09 +00:00 committed by Richard Sandiford
parent e1bd729663
commit 10681ce8cb
7 changed files with 128 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
gcc/ChangeLog
View File

@ -1,3 +1,26 @@
2018-07-31 Richard Sandiford <richard.sandiford@arm.com>
* tree-vectorizer.h (_stmt_vec_info::related_stmt): Change from
a gimple stmt to a stmt_vec_info.
(is_pattern_stmt_p): Update accordingly.
* tree-vect-data-refs.c (vect_preserves_scalar_order_p): Likewise.
(vect_record_grouped_load_vectors): Likewise.
* tree-vect-loop.c (vect_determine_vf_for_stmt): Likewise.
(vect_fixup_reduc_chain, vect_update_vf_for_slp): Likewise.
(vect_model_reduction_cost): Likewise.
(vect_create_epilog_for_reduction): Likewise.
(vectorizable_reduction, vectorizable_induction): Likewise.
* tree-vect-patterns.c (vect_init_pattern_stmt): Likewise.
Return the stmt_vec_info for the pattern statement.
(vect_set_pattern_stmt): Update use of STMT_VINFO_RELATED_STMT.
(vect_split_statement, vect_mark_pattern_stmts): Likewise.
* tree-vect-slp.c (vect_detect_hybrid_slp_stmts): Likewise.
(vect_detect_hybrid_slp, vect_get_slp_defs): Likewise.
* tree-vect-stmts.c (vect_mark_relevant): Likewise.
(vect_get_vec_def_for_operand_1, vectorizable_call): Likewise.
(vectorizable_simd_clone_call, vect_analyze_stmt, new_stmt_vec_info)
(free_stmt_vec_info, vect_is_simple_use): Likewise.
2018-07-31 Richard Sandiford <richard.sandiford@arm.com> 2018-07-31 Richard Sandiford <richard.sandiford@arm.com>
* tree-vectorizer.h (vect_finish_replace_stmt): Return a stmt_vec_info * tree-vectorizer.h (vect_finish_replace_stmt): Return a stmt_vec_info

31
gcc/tree-vect-data-refs.c
View File

@ -213,10 +213,10 @@ vect_preserves_scalar_order_p (gimple *stmt_a, gimple *stmt_b)
current position (but could happen earlier). Reordering is therefore current position (but could happen earlier). Reordering is therefore
only possible if the first access is a write. */ only possible if the first access is a write. */
if (is_pattern_stmt_p (stmtinfo_a)) if (is_pattern_stmt_p (stmtinfo_a))
stmt_a = STMT_VINFO_RELATED_STMT (stmtinfo_a); stmtinfo_a = STMT_VINFO_RELATED_STMT (stmtinfo_a);
if (is_pattern_stmt_p (stmtinfo_b)) if (is_pattern_stmt_p (stmtinfo_b))
stmt_b = STMT_VINFO_RELATED_STMT (stmtinfo_b); stmtinfo_b = STMT_VINFO_RELATED_STMT (stmtinfo_b);
gimple *earlier_stmt = get_earlier_stmt (stmt_a, stmt_b); gimple *earlier_stmt = get_earlier_stmt (stmtinfo_a, stmtinfo_b);
return !DR_IS_WRITE (STMT_VINFO_DATA_REF (vinfo_for_stmt (earlier_stmt))); return !DR_IS_WRITE (STMT_VINFO_DATA_REF (vinfo_for_stmt (earlier_stmt)));
} }
@ -6359,8 +6359,10 @@ vect_transform_grouped_load (gimple *stmt, vec<tree> dr_chain, int size,
void void
vect_record_grouped_load_vectors (gimple *stmt, vec<tree> result_chain) vect_record_grouped_load_vectors (gimple *stmt, vec<tree> result_chain)
{ {
gimple *first_stmt = DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)); stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
gimple *next_stmt, *new_stmt; vec_info *vinfo = stmt_info->vinfo;
gimple *first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
gimple *next_stmt;
unsigned int i, gap_count; unsigned int i, gap_count;
tree tmp_data_ref; tree tmp_data_ref;
@ -6389,29 +6391,28 @@ vect_record_grouped_load_vectors (gimple *stmt, vec<tree> result_chain)
while (next_stmt) while (next_stmt)
{ {
new_stmt = SSA_NAME_DEF_STMT (tmp_data_ref); stmt_vec_info new_stmt_info = vinfo->lookup_def (tmp_data_ref);
/* We assume that if VEC_STMT is not NULL, this is a case of multiple /* We assume that if VEC_STMT is not NULL, this is a case of multiple
copies, and we put the new vector statement in the first available copies, and we put the new vector statement in the first available
RELATED_STMT. */ RELATED_STMT. */
if (!STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt))) if (!STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)))
STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)) = new_stmt; STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)) = new_stmt_info;
else else
{ {
if (!DR_GROUP_SAME_DR_STMT (vinfo_for_stmt (next_stmt))) if (!DR_GROUP_SAME_DR_STMT (vinfo_for_stmt (next_stmt)))
{ {
gimple *prev_stmt = gimple *prev_stmt =
STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)); STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt));
gimple *rel_stmt = stmt_vec_info rel_stmt_info
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (prev_stmt)); = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (prev_stmt));
while (rel_stmt) while (rel_stmt_info)
{ {
prev_stmt = rel_stmt; prev_stmt = rel_stmt_info;
rel_stmt = rel_stmt_info = STMT_VINFO_RELATED_STMT (rel_stmt_info);
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (rel_stmt));
} }
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (prev_stmt)) = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (prev_stmt))
new_stmt; = new_stmt_info;
} }
} }

96
gcc/tree-vect-loop.c
View File

@ -226,7 +226,7 @@ vect_determine_vf_for_stmt (stmt_vec_info stmt_info, poly_uint64 *vf,
&& STMT_VINFO_RELATED_STMT (stmt_info)) && STMT_VINFO_RELATED_STMT (stmt_info))
{ {
gimple *pattern_def_seq = STMT_VINFO_PATTERN_DEF_SEQ (stmt_info); gimple *pattern_def_seq = STMT_VINFO_PATTERN_DEF_SEQ (stmt_info);
stmt_info = vinfo_for_stmt (STMT_VINFO_RELATED_STMT (stmt_info)); stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
/* If a pattern statement has def stmts, analyze them too. */ /* If a pattern statement has def stmts, analyze them too. */
for (gimple_stmt_iterator si = gsi_start (pattern_def_seq); for (gimple_stmt_iterator si = gsi_start (pattern_def_seq);
@ -654,23 +654,23 @@ vect_analyze_scalar_cycles (loop_vec_info loop_vinfo)
static void static void
vect_fixup_reduc_chain (gimple *stmt) vect_fixup_reduc_chain (gimple *stmt)
{ {
gimple *firstp = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt)); stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
gimple *stmtp; stmt_vec_info firstp = STMT_VINFO_RELATED_STMT (stmt_info);
gcc_assert (!REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (firstp)) stmt_vec_info stmtp;
&& REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt))); gcc_assert (!REDUC_GROUP_FIRST_ELEMENT (firstp)
REDUC_GROUP_SIZE (vinfo_for_stmt (firstp)) && REDUC_GROUP_FIRST_ELEMENT (stmt_info));
= REDUC_GROUP_SIZE (vinfo_for_stmt (stmt)); REDUC_GROUP_SIZE (firstp) = REDUC_GROUP_SIZE (stmt_info);
do do
{ {
stmtp = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt)); stmtp = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt));
REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmtp)) = firstp; REDUC_GROUP_FIRST_ELEMENT (stmtp) = firstp;
stmt = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt)); stmt = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt));
if (stmt) if (stmt)
REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmtp)) REDUC_GROUP_NEXT_ELEMENT (stmtp)
= STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt)); = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt));
} }
while (stmt); while (stmt);
STMT_VINFO_DEF_TYPE (vinfo_for_stmt (stmtp)) = vect_reduction_def; STMT_VINFO_DEF_TYPE (stmtp) = vect_reduction_def;
} }
/* Fixup scalar cycles that now have their stmts detected as patterns. */ /* Fixup scalar cycles that now have their stmts detected as patterns. */
@ -1436,14 +1436,10 @@ vect_update_vf_for_slp (loop_vec_info loop_vinfo)
for (gimple_stmt_iterator si = gsi_start_bb (bb); !gsi_end_p (si); for (gimple_stmt_iterator si = gsi_start_bb (bb); !gsi_end_p (si);
gsi_next (&si)) gsi_next (&si))
{ {
gimple *stmt = gsi_stmt (si);
stmt_vec_info stmt_info = loop_vinfo->lookup_stmt (gsi_stmt (si)); stmt_vec_info stmt_info = loop_vinfo->lookup_stmt (gsi_stmt (si));
if (STMT_VINFO_IN_PATTERN_P (stmt_info) if (STMT_VINFO_IN_PATTERN_P (stmt_info)
&& STMT_VINFO_RELATED_STMT (stmt_info)) && STMT_VINFO_RELATED_STMT (stmt_info))
{ stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
stmt = STMT_VINFO_RELATED_STMT (stmt_info);
stmt_info = vinfo_for_stmt (stmt);
}
if ((STMT_VINFO_RELEVANT_P (stmt_info) if ((STMT_VINFO_RELEVANT_P (stmt_info)
|| VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_info))) || VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_info)))
&& !PURE_SLP_STMT (stmt_info)) && !PURE_SLP_STMT (stmt_info))
@ -2247,7 +2243,7 @@ again:
if (STMT_VINFO_IN_PATTERN_P (stmt_info)) if (STMT_VINFO_IN_PATTERN_P (stmt_info))
{ {
gimple *pattern_def_seq = STMT_VINFO_PATTERN_DEF_SEQ (stmt_info); gimple *pattern_def_seq = STMT_VINFO_PATTERN_DEF_SEQ (stmt_info);
stmt_info = vinfo_for_stmt (STMT_VINFO_RELATED_STMT (stmt_info)); stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
STMT_SLP_TYPE (stmt_info) = loop_vect; STMT_SLP_TYPE (stmt_info) = loop_vect;
for (gimple_stmt_iterator pi = gsi_start (pattern_def_seq); for (gimple_stmt_iterator pi = gsi_start (pattern_def_seq);
!gsi_end_p (pi); gsi_next (&pi)) !gsi_end_p (pi); gsi_next (&pi))
@ -3836,7 +3832,6 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, internal_fn reduc_fn,
enum tree_code code; enum tree_code code;
optab optab; optab optab;
tree vectype; tree vectype;
gimple *orig_stmt;
machine_mode mode; machine_mode mode;
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
struct loop *loop = NULL; struct loop *loop = NULL;
@ -3852,12 +3847,12 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, internal_fn reduc_fn,
vectype = STMT_VINFO_VECTYPE (stmt_info); vectype = STMT_VINFO_VECTYPE (stmt_info);
mode = TYPE_MODE (vectype); mode = TYPE_MODE (vectype);
orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info); stmt_vec_info orig_stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
if (!orig_stmt) if (!orig_stmt_info)
orig_stmt = STMT_VINFO_STMT (stmt_info); orig_stmt_info = stmt_info;
code = gimple_assign_rhs_code (orig_stmt); code = gimple_assign_rhs_code (orig_stmt_info->stmt);
if (reduction_type == EXTRACT_LAST_REDUCTION if (reduction_type == EXTRACT_LAST_REDUCTION
|| reduction_type == FOLD_LEFT_REDUCTION) || reduction_type == FOLD_LEFT_REDUCTION)
@ -3902,7 +3897,7 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, internal_fn reduc_fn,
We have a reduction operator that will reduce the vector in one statement. We have a reduction operator that will reduce the vector in one statement.
Also requires scalar extract. */ Also requires scalar extract. */
if (!loop || !nested_in_vect_loop_p (loop, orig_stmt)) if (!loop || !nested_in_vect_loop_p (loop, orig_stmt_info))
{ {
if (reduc_fn != IFN_LAST) if (reduc_fn != IFN_LAST)
{ {
@ -3953,7 +3948,7 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, internal_fn reduc_fn,
{ {
int vec_size_in_bits = tree_to_uhwi (TYPE_SIZE (vectype)); int vec_size_in_bits = tree_to_uhwi (TYPE_SIZE (vectype));
tree bitsize = tree bitsize =
TYPE_SIZE (TREE_TYPE (gimple_assign_lhs (orig_stmt))); TYPE_SIZE (TREE_TYPE (gimple_assign_lhs (orig_stmt_info->stmt)));
int element_bitsize = tree_to_uhwi (bitsize); int element_bitsize = tree_to_uhwi (bitsize);
int nelements = vec_size_in_bits / element_bitsize; int nelements = vec_size_in_bits / element_bitsize;
@ -4447,7 +4442,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
tree orig_name, scalar_result; tree orig_name, scalar_result;
imm_use_iterator imm_iter, phi_imm_iter; imm_use_iterator imm_iter, phi_imm_iter;
use_operand_p use_p, phi_use_p; use_operand_p use_p, phi_use_p;
gimple *use_stmt, *orig_stmt, *reduction_phi = NULL; gimple *use_stmt, *reduction_phi = NULL;
bool nested_in_vect_loop = false; bool nested_in_vect_loop = false;
auto_vec<gimple *> new_phis; auto_vec<gimple *> new_phis;
auto_vec<gimple *> inner_phis; auto_vec<gimple *> inner_phis;
@ -4726,7 +4721,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
else else
{ {
def = vect_get_vec_def_for_stmt_copy (dt, def); def = vect_get_vec_def_for_stmt_copy (dt, def);
STMT_VINFO_RELATED_STMT (prev_phi_info) = phi; STMT_VINFO_RELATED_STMT (prev_phi_info) = phi_info;
} }
SET_PHI_ARG_DEF (phi, single_exit (loop)->dest_idx, def); SET_PHI_ARG_DEF (phi, single_exit (loop)->dest_idx, def);
@ -4758,7 +4753,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
SET_PHI_ARG_DEF (outer_phi, single_exit (loop)->dest_idx, SET_PHI_ARG_DEF (outer_phi, single_exit (loop)->dest_idx,
PHI_RESULT (phi)); PHI_RESULT (phi));
stmt_vec_info outer_phi_info = loop_vinfo->add_stmt (outer_phi); stmt_vec_info outer_phi_info = loop_vinfo->add_stmt (outer_phi);
STMT_VINFO_RELATED_STMT (prev_phi_info) = outer_phi; STMT_VINFO_RELATED_STMT (prev_phi_info) = outer_phi_info;
prev_phi_info = outer_phi_info; prev_phi_info = outer_phi_info;
} }
} }
@ -4775,27 +4770,26 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
Otherwise (it is a regular reduction) - the tree-code and scalar-def Otherwise (it is a regular reduction) - the tree-code and scalar-def
are taken from STMT. */ are taken from STMT. */
orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info); stmt_vec_info orig_stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
if (!orig_stmt) if (!orig_stmt_info)
{ {
/* Regular reduction */ /* Regular reduction */
orig_stmt = stmt; orig_stmt_info = stmt_info;
} }
else else
{ {
/* Reduction pattern */ /* Reduction pattern */
stmt_vec_info stmt_vinfo = vinfo_for_stmt (orig_stmt); gcc_assert (STMT_VINFO_IN_PATTERN_P (orig_stmt_info));
gcc_assert (STMT_VINFO_IN_PATTERN_P (stmt_vinfo)); gcc_assert (STMT_VINFO_RELATED_STMT (orig_stmt_info) == stmt_info);
gcc_assert (STMT_VINFO_RELATED_STMT (stmt_vinfo) == stmt);
} }
code = gimple_assign_rhs_code (orig_stmt); code = gimple_assign_rhs_code (orig_stmt_info->stmt);
/* For MINUS_EXPR the initial vector is [init_val,0,...,0], therefore, /* For MINUS_EXPR the initial vector is [init_val,0,...,0], therefore,
partial results are added and not subtracted. */ partial results are added and not subtracted. */
if (code == MINUS_EXPR) if (code == MINUS_EXPR)
code = PLUS_EXPR; code = PLUS_EXPR;
scalar_dest = gimple_assign_lhs (orig_stmt); scalar_dest = gimple_assign_lhs (orig_stmt_info->stmt);
scalar_type = TREE_TYPE (scalar_dest); scalar_type = TREE_TYPE (scalar_dest);
scalar_results.create (group_size); scalar_results.create (group_size);
new_scalar_dest = vect_create_destination_var (scalar_dest, NULL); new_scalar_dest = vect_create_destination_var (scalar_dest, NULL);
@ -5613,10 +5607,11 @@ vect_finalize_reduction:
{ {
gimple *current_stmt = SLP_TREE_SCALAR_STMTS (slp_node)[k]; gimple *current_stmt = SLP_TREE_SCALAR_STMTS (slp_node)[k];
orig_stmt = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (current_stmt)); orig_stmt_info
/* SLP statements can't participate in patterns. */ = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (current_stmt));
gcc_assert (!orig_stmt); /* SLP statements can't participate in patterns. */
scalar_dest = gimple_assign_lhs (current_stmt); gcc_assert (!orig_stmt_info);
scalar_dest = gimple_assign_lhs (current_stmt);
} }
phis.create (3); phis.create (3);
@ -6097,8 +6092,6 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
enum tree_code cond_reduc_op_code = ERROR_MARK; enum tree_code cond_reduc_op_code = ERROR_MARK;
tree scalar_type; tree scalar_type;
bool is_simple_use; bool is_simple_use;
gimple *orig_stmt;
stmt_vec_info orig_stmt_info = NULL;
int i; int i;
int ncopies; int ncopies;
int epilog_copies; int epilog_copies;
@ -6229,7 +6222,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
if (j == 0) if (j == 0)
STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_phi; STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_phi;
else else
STMT_VINFO_RELATED_STMT (prev_phi_info) = new_phi; STMT_VINFO_RELATED_STMT (prev_phi_info) = new_phi_info;
prev_phi_info = new_phi_info; prev_phi_info = new_phi_info;
} }
} }
@ -6259,10 +6252,9 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
the STMT_VINFO_RELATED_STMT field records the last stmt in the STMT_VINFO_RELATED_STMT field records the last stmt in
the original sequence that constitutes the pattern. */ the original sequence that constitutes the pattern. */
orig_stmt = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt)); stmt_vec_info orig_stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
if (orig_stmt) if (orig_stmt_info)
{ {
orig_stmt_info = vinfo_for_stmt (orig_stmt);
gcc_assert (STMT_VINFO_IN_PATTERN_P (orig_stmt_info)); gcc_assert (STMT_VINFO_IN_PATTERN_P (orig_stmt_info));
gcc_assert (!STMT_VINFO_IN_PATTERN_P (stmt_info)); gcc_assert (!STMT_VINFO_IN_PATTERN_P (stmt_info));
} }
@ -6393,7 +6385,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
return false; return false;
} }
if (orig_stmt) if (orig_stmt_info)
reduc_def_stmt = STMT_VINFO_REDUC_DEF (orig_stmt_info); reduc_def_stmt = STMT_VINFO_REDUC_DEF (orig_stmt_info);
else else
reduc_def_stmt = STMT_VINFO_REDUC_DEF (stmt_info); reduc_def_stmt = STMT_VINFO_REDUC_DEF (stmt_info);
@ -6414,7 +6406,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
/* For pattern recognized stmts, orig_stmt might be a reduction, /* For pattern recognized stmts, orig_stmt might be a reduction,
but some helper statements for the pattern might not, or but some helper statements for the pattern might not, or
might be COND_EXPRs with reduction uses in the condition. */ might be COND_EXPRs with reduction uses in the condition. */
gcc_assert (orig_stmt); gcc_assert (orig_stmt_info);
return false; return false;
} }
@ -6548,10 +6540,10 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
} }
} }
if (orig_stmt) if (orig_stmt_info)
gcc_assert (tmp == orig_stmt gcc_assert (tmp == orig_stmt_info
|| (REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (tmp)) || (REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (tmp))
== orig_stmt)); == orig_stmt_info));
else else
/* We changed STMT to be the first stmt in reduction chain, hence we /* We changed STMT to be the first stmt in reduction chain, hence we
check that in this case the first element in the chain is STMT. */ check that in this case the first element in the chain is STMT. */
@ -6673,13 +6665,13 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
vect_reduction_type reduction_type vect_reduction_type reduction_type
= STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info); = STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info);
if (orig_stmt if (orig_stmt_info
&& (reduction_type == TREE_CODE_REDUCTION && (reduction_type == TREE_CODE_REDUCTION
|| reduction_type == FOLD_LEFT_REDUCTION)) || reduction_type == FOLD_LEFT_REDUCTION))
{ {
/* This is a reduction pattern: get the vectype from the type of the /* This is a reduction pattern: get the vectype from the type of the
reduction variable, and get the tree-code from orig_stmt. */ reduction variable, and get the tree-code from orig_stmt. */
orig_code = gimple_assign_rhs_code (orig_stmt); orig_code = gimple_assign_rhs_code (orig_stmt_info->stmt);
gcc_assert (vectype_out); gcc_assert (vectype_out);
vec_mode = TYPE_MODE (vectype_out); vec_mode = TYPE_MODE (vectype_out);
} }
@ -7757,7 +7749,7 @@ vectorizable_induction (gimple *phi,
gsi_insert_before (&si, new_stmt, GSI_SAME_STMT); gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
new_stmt_info = loop_vinfo->add_stmt (new_stmt); new_stmt_info = loop_vinfo->add_stmt (new_stmt);
STMT_VINFO_RELATED_STMT (prev_stmt_vinfo) = new_stmt; STMT_VINFO_RELATED_STMT (prev_stmt_vinfo) = new_stmt_info;
prev_stmt_vinfo = new_stmt_info; prev_stmt_vinfo = new_stmt_info;
} }
} }

22
gcc/tree-vect-patterns.c
View File

@ -94,10 +94,11 @@ vect_pattern_detected (const char *name, gimple *stmt)
} }
} }
/* Associate pattern statement PATTERN_STMT with ORIG_STMT_INFO. /* Associate pattern statement PATTERN_STMT with ORIG_STMT_INFO and
Set its vector type to VECTYPE if it doesn't have one already. */ return the pattern statement's stmt_vec_info. Set its vector type to
VECTYPE if it doesn't have one already. */
static void static stmt_vec_info
vect_init_pattern_stmt (gimple *pattern_stmt, stmt_vec_info orig_stmt_info, vect_init_pattern_stmt (gimple *pattern_stmt, stmt_vec_info orig_stmt_info,
tree vectype) tree vectype)
{ {
@ -107,11 +108,12 @@ vect_init_pattern_stmt (gimple *pattern_stmt, stmt_vec_info orig_stmt_info,
pattern_stmt_info = orig_stmt_info->vinfo->add_stmt (pattern_stmt); pattern_stmt_info = orig_stmt_info->vinfo->add_stmt (pattern_stmt);
gimple_set_bb (pattern_stmt, gimple_bb (orig_stmt_info->stmt)); gimple_set_bb (pattern_stmt, gimple_bb (orig_stmt_info->stmt));
STMT_VINFO_RELATED_STMT (pattern_stmt_info) = orig_stmt_info->stmt; STMT_VINFO_RELATED_STMT (pattern_stmt_info) = orig_stmt_info;
STMT_VINFO_DEF_TYPE (pattern_stmt_info) STMT_VINFO_DEF_TYPE (pattern_stmt_info)
= STMT_VINFO_DEF_TYPE (orig_stmt_info); = STMT_VINFO_DEF_TYPE (orig_stmt_info);
if (!STMT_VINFO_VECTYPE (pattern_stmt_info)) if (!STMT_VINFO_VECTYPE (pattern_stmt_info))
STMT_VINFO_VECTYPE (pattern_stmt_info) = vectype; STMT_VINFO_VECTYPE (pattern_stmt_info) = vectype;
return pattern_stmt_info;
} }
/* Set the pattern statement of ORIG_STMT_INFO to PATTERN_STMT. /* Set the pattern statement of ORIG_STMT_INFO to PATTERN_STMT.
@ -123,8 +125,8 @@ vect_set_pattern_stmt (gimple *pattern_stmt, stmt_vec_info orig_stmt_info,
tree vectype) tree vectype)
{ {
STMT_VINFO_IN_PATTERN_P (orig_stmt_info) = true; STMT_VINFO_IN_PATTERN_P (orig_stmt_info) = true;
STMT_VINFO_RELATED_STMT (orig_stmt_info) = pattern_stmt; STMT_VINFO_RELATED_STMT (orig_stmt_info)
vect_init_pattern_stmt (pattern_stmt, orig_stmt_info, vectype); = vect_init_pattern_stmt (pattern_stmt, orig_stmt_info, vectype);
} }
/* Add NEW_STMT to STMT_INFO's pattern definition statements. If VECTYPE /* Add NEW_STMT to STMT_INFO's pattern definition statements. If VECTYPE
@ -634,8 +636,7 @@ vect_split_statement (stmt_vec_info stmt2_info, tree new_rhs,
{ {
/* STMT2_INFO is part of a pattern. Get the statement to which /* STMT2_INFO is part of a pattern. Get the statement to which
the pattern is attached. */ the pattern is attached. */
stmt_vec_info orig_stmt2_info stmt_vec_info orig_stmt2_info = STMT_VINFO_RELATED_STMT (stmt2_info);
= vinfo_for_stmt (STMT_VINFO_RELATED_STMT (stmt2_info));
vect_init_pattern_stmt (stmt1, orig_stmt2_info, vectype); vect_init_pattern_stmt (stmt1, orig_stmt2_info, vectype);
if (dump_enabled_p ()) if (dump_enabled_p ())
@ -659,7 +660,7 @@ vect_split_statement (stmt_vec_info stmt2_info, tree new_rhs,
} }
gimple_seq *def_seq = &STMT_VINFO_PATTERN_DEF_SEQ (orig_stmt2_info); gimple_seq *def_seq = &STMT_VINFO_PATTERN_DEF_SEQ (orig_stmt2_info);
if (STMT_VINFO_RELATED_STMT (orig_stmt2_info) == stmt2_info->stmt) if (STMT_VINFO_RELATED_STMT (orig_stmt2_info) == stmt2_info)
/* STMT2_INFO is the actual pattern statement. Add STMT1 /* STMT2_INFO is the actual pattern statement. Add STMT1
to the end of the definition sequence. */ to the end of the definition sequence. */
gimple_seq_add_stmt_without_update (def_seq, stmt1); gimple_seq_add_stmt_without_update (def_seq, stmt1);
@ -4754,8 +4755,7 @@ vect_mark_pattern_stmts (gimple *orig_stmt, gimple *pattern_stmt,
} }
/* Switch to the statement that ORIG replaces. */ /* Switch to the statement that ORIG replaces. */
orig_stmt_info orig_stmt_info = STMT_VINFO_RELATED_STMT (orig_stmt_info);
= vinfo_for_stmt (STMT_VINFO_RELATED_STMT (orig_stmt_info));
/* We shouldn't be replacing the main pattern statement. */ /* We shouldn't be replacing the main pattern statement. */
gcc_assert (STMT_VINFO_RELATED_STMT (orig_stmt_info) != orig_stmt); gcc_assert (STMT_VINFO_RELATED_STMT (orig_stmt_info) != orig_stmt);

11
gcc/tree-vect-slp.c
View File

@ -2327,7 +2327,7 @@ vect_detect_hybrid_slp_stmts (slp_tree node, unsigned i, slp_vect_type stype)
original stmt for immediate uses. */ original stmt for immediate uses. */
if (! STMT_VINFO_IN_PATTERN_P (stmt_vinfo) if (! STMT_VINFO_IN_PATTERN_P (stmt_vinfo)
&& STMT_VINFO_RELATED_STMT (stmt_vinfo)) && STMT_VINFO_RELATED_STMT (stmt_vinfo))
stmt = STMT_VINFO_RELATED_STMT (stmt_vinfo); stmt = STMT_VINFO_RELATED_STMT (stmt_vinfo)->stmt;
tree def; tree def;
if (gimple_code (stmt) == GIMPLE_PHI) if (gimple_code (stmt) == GIMPLE_PHI)
def = gimple_phi_result (stmt); def = gimple_phi_result (stmt);
@ -2341,7 +2341,7 @@ vect_detect_hybrid_slp_stmts (slp_tree node, unsigned i, slp_vect_type stype)
continue; continue;
if (STMT_VINFO_IN_PATTERN_P (use_vinfo) if (STMT_VINFO_IN_PATTERN_P (use_vinfo)
&& STMT_VINFO_RELATED_STMT (use_vinfo)) && STMT_VINFO_RELATED_STMT (use_vinfo))
use_vinfo = vinfo_for_stmt (STMT_VINFO_RELATED_STMT (use_vinfo)); use_vinfo = STMT_VINFO_RELATED_STMT (use_vinfo);
if (!STMT_SLP_TYPE (use_vinfo) if (!STMT_SLP_TYPE (use_vinfo)
&& (STMT_VINFO_RELEVANT (use_vinfo) && (STMT_VINFO_RELEVANT (use_vinfo)
|| VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (use_vinfo))) || VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (use_vinfo)))
@ -2446,7 +2446,7 @@ vect_detect_hybrid_slp (loop_vec_info loop_vinfo)
memset (&wi, 0, sizeof (wi)); memset (&wi, 0, sizeof (wi));
wi.info = loop_vinfo; wi.info = loop_vinfo;
gimple_stmt_iterator gsi2 gimple_stmt_iterator gsi2
= gsi_for_stmt (STMT_VINFO_RELATED_STMT (stmt_info)); = gsi_for_stmt (STMT_VINFO_RELATED_STMT (stmt_info)->stmt);
walk_gimple_stmt (&gsi2, vect_detect_hybrid_slp_2, walk_gimple_stmt (&gsi2, vect_detect_hybrid_slp_2,
vect_detect_hybrid_slp_1, &wi); vect_detect_hybrid_slp_1, &wi);
walk_gimple_seq (STMT_VINFO_PATTERN_DEF_SEQ (stmt_info), walk_gimple_seq (STMT_VINFO_PATTERN_DEF_SEQ (stmt_info),
@ -3612,7 +3612,7 @@ vect_get_slp_defs (vec<tree> ops, slp_tree slp_node,
if (SLP_TREE_DEF_TYPE (child) == vect_internal_def) if (SLP_TREE_DEF_TYPE (child) == vect_internal_def)
{ {
gimple *first_def = SLP_TREE_SCALAR_STMTS (child)[0]; gimple *first_def = SLP_TREE_SCALAR_STMTS (child)[0];
gimple *related stmt_vec_info related
= STMT_VINFO_RELATED_STMT (vinfo_for_stmt (first_def)); = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (first_def));
tree first_def_op; tree first_def_op;
@ -3622,7 +3622,8 @@ vect_get_slp_defs (vec<tree> ops, slp_tree slp_node,
first_def_op = gimple_get_lhs (first_def); first_def_op = gimple_get_lhs (first_def);
if (operand_equal_p (oprnd, first_def_op, 0) if (operand_equal_p (oprnd, first_def_op, 0)
|| (related || (related
&& operand_equal_p (oprnd, gimple_get_lhs (related), 0))) && operand_equal_p (oprnd,
gimple_get_lhs (related->stmt), 0)))
{ {
/* The number of vector defs is determined by the number of /* The number of vector defs is determined by the number of
vector statements in the node from which we get those vector statements in the node from which we get those

56
gcc/tree-vect-stmts.c
View File

@ -202,7 +202,6 @@ vect_mark_relevant (vec<gimple *> *worklist, gimple *stmt,
stmt_vec_info stmt_info = vinfo_for_stmt (stmt); stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
enum vect_relevant save_relevant = STMT_VINFO_RELEVANT (stmt_info); enum vect_relevant save_relevant = STMT_VINFO_RELEVANT (stmt_info);
bool save_live_p = STMT_VINFO_LIVE_P (stmt_info); bool save_live_p = STMT_VINFO_LIVE_P (stmt_info);
gimple *pattern_stmt;
if (dump_enabled_p ()) if (dump_enabled_p ())
{ {
@ -222,17 +221,16 @@ vect_mark_relevant (vec<gimple *> *worklist, gimple *stmt,
as relevant/live because it's not going to be vectorized. as relevant/live because it's not going to be vectorized.
Instead mark the pattern-stmt that replaces it. */ Instead mark the pattern-stmt that replaces it. */
pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
if (dump_enabled_p ()) if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location, dump_printf_loc (MSG_NOTE, vect_location,
"last stmt in pattern. don't mark" "last stmt in pattern. don't mark"
" relevant/live.\n"); " relevant/live.\n");
stmt_info = vinfo_for_stmt (pattern_stmt); stmt_vec_info old_stmt_info = stmt_info;
gcc_assert (STMT_VINFO_RELATED_STMT (stmt_info) == stmt); stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
gcc_assert (STMT_VINFO_RELATED_STMT (stmt_info) == old_stmt_info);
save_relevant = STMT_VINFO_RELEVANT (stmt_info); save_relevant = STMT_VINFO_RELEVANT (stmt_info);
save_live_p = STMT_VINFO_LIVE_P (stmt_info); save_live_p = STMT_VINFO_LIVE_P (stmt_info);
stmt = pattern_stmt; stmt = stmt_info->stmt;
} }
STMT_VINFO_LIVE_P (stmt_info) |= live_p; STMT_VINFO_LIVE_P (stmt_info) |= live_p;
@ -1489,8 +1487,8 @@ vect_get_vec_def_for_operand_1 (gimple *def_stmt, enum vect_def_type dt)
if (!vec_stmt if (!vec_stmt
&& STMT_VINFO_IN_PATTERN_P (def_stmt_info) && STMT_VINFO_IN_PATTERN_P (def_stmt_info)
&& !STMT_VINFO_RELEVANT (def_stmt_info)) && !STMT_VINFO_RELEVANT (def_stmt_info))
vec_stmt = STMT_VINFO_VEC_STMT (vinfo_for_stmt ( vec_stmt = (STMT_VINFO_VEC_STMT
STMT_VINFO_RELATED_STMT (def_stmt_info))); (STMT_VINFO_RELATED_STMT (def_stmt_info)));
gcc_assert (vec_stmt); gcc_assert (vec_stmt);
if (gimple_code (vec_stmt) == GIMPLE_PHI) if (gimple_code (vec_stmt) == GIMPLE_PHI)
vec_oprnd = PHI_RESULT (vec_stmt); vec_oprnd = PHI_RESULT (vec_stmt);
@ -3635,7 +3633,7 @@ vectorizable_call (gimple *gs, gimple_stmt_iterator *gsi, gimple **vec_stmt,
return true; return true;
if (is_pattern_stmt_p (stmt_info)) if (is_pattern_stmt_p (stmt_info))
stmt_info = vinfo_for_stmt (STMT_VINFO_RELATED_STMT (stmt_info)); stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
lhs = gimple_get_lhs (stmt_info->stmt); lhs = gimple_get_lhs (stmt_info->stmt);
gassign *new_stmt gassign *new_stmt
@ -4370,7 +4368,7 @@ vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi,
{ {
type = TREE_TYPE (scalar_dest); type = TREE_TYPE (scalar_dest);
if (is_pattern_stmt_p (stmt_info)) if (is_pattern_stmt_p (stmt_info))
lhs = gimple_call_lhs (STMT_VINFO_RELATED_STMT (stmt_info)); lhs = gimple_call_lhs (STMT_VINFO_RELATED_STMT (stmt_info)->stmt);
else else
lhs = gimple_call_lhs (stmt); lhs = gimple_call_lhs (stmt);
new_stmt = gimple_build_assign (lhs, build_zero_cst (type)); new_stmt = gimple_build_assign (lhs, build_zero_cst (type));
@ -9420,7 +9418,6 @@ vect_analyze_stmt (gimple *stmt, bool *need_to_vectorize, slp_tree node,
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info); bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
enum vect_relevant relevance = STMT_VINFO_RELEVANT (stmt_info); enum vect_relevant relevance = STMT_VINFO_RELEVANT (stmt_info);
bool ok; bool ok;
gimple *pattern_stmt;
gimple_seq pattern_def_seq; gimple_seq pattern_def_seq;
if (dump_enabled_p ()) if (dump_enabled_p ())
@ -9482,18 +9479,18 @@ vect_analyze_stmt (gimple *stmt, bool *need_to_vectorize, slp_tree node,
traversal, don't analyze pattern stmts instead, the pattern stmts traversal, don't analyze pattern stmts instead, the pattern stmts
already will be part of SLP instance. */ already will be part of SLP instance. */
pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info); stmt_vec_info pattern_stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
if (!STMT_VINFO_RELEVANT_P (stmt_info) if (!STMT_VINFO_RELEVANT_P (stmt_info)
&& !STMT_VINFO_LIVE_P (stmt_info)) && !STMT_VINFO_LIVE_P (stmt_info))
{ {
if (STMT_VINFO_IN_PATTERN_P (stmt_info) if (STMT_VINFO_IN_PATTERN_P (stmt_info)
&& pattern_stmt && pattern_stmt_info
&& (STMT_VINFO_RELEVANT_P (vinfo_for_stmt (pattern_stmt)) && (STMT_VINFO_RELEVANT_P (pattern_stmt_info)
|| STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_stmt)))) || STMT_VINFO_LIVE_P (pattern_stmt_info)))
{ {
/* Analyze PATTERN_STMT instead of the original stmt. */ /* Analyze PATTERN_STMT instead of the original stmt. */
stmt = pattern_stmt; stmt = pattern_stmt_info->stmt;
stmt_info = vinfo_for_stmt (pattern_stmt); stmt_info = pattern_stmt_info;
if (dump_enabled_p ()) if (dump_enabled_p ())
{ {
dump_printf_loc (MSG_NOTE, vect_location, dump_printf_loc (MSG_NOTE, vect_location,
@ -9511,9 +9508,9 @@ vect_analyze_stmt (gimple *stmt, bool *need_to_vectorize, slp_tree node,
} }
else if (STMT_VINFO_IN_PATTERN_P (stmt_info) else if (STMT_VINFO_IN_PATTERN_P (stmt_info)
&& node == NULL && node == NULL
&& pattern_stmt && pattern_stmt_info
&& (STMT_VINFO_RELEVANT_P (vinfo_for_stmt (pattern_stmt)) && (STMT_VINFO_RELEVANT_P (pattern_stmt_info)
|| STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_stmt)))) || STMT_VINFO_LIVE_P (pattern_stmt_info)))
{ {
/* Analyze PATTERN_STMT too. */ /* Analyze PATTERN_STMT too. */
if (dump_enabled_p ()) if (dump_enabled_p ())
@ -9523,7 +9520,7 @@ vect_analyze_stmt (gimple *stmt, bool *need_to_vectorize, slp_tree node,
dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0); dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
} }
if (!vect_analyze_stmt (pattern_stmt, need_to_vectorize, node, if (!vect_analyze_stmt (pattern_stmt_info, need_to_vectorize, node,
node_instance, cost_vec)) node_instance, cost_vec))
return false; return false;
} }
@ -9855,7 +9852,6 @@ new_stmt_vec_info (gimple *stmt, vec_info *vinfo)
STMT_VINFO_VEC_STMT (res) = NULL; STMT_VINFO_VEC_STMT (res) = NULL;
STMT_VINFO_VECTORIZABLE (res) = true; STMT_VINFO_VECTORIZABLE (res) = true;
STMT_VINFO_IN_PATTERN_P (res) = false; STMT_VINFO_IN_PATTERN_P (res) = false;
STMT_VINFO_RELATED_STMT (res) = NULL;
STMT_VINFO_PATTERN_DEF_SEQ (res) = NULL; STMT_VINFO_PATTERN_DEF_SEQ (res) = NULL;
STMT_VINFO_DATA_REF (res) = NULL; STMT_VINFO_DATA_REF (res) = NULL;
STMT_VINFO_VEC_REDUCTION_TYPE (res) = TREE_CODE_REDUCTION; STMT_VINFO_VEC_REDUCTION_TYPE (res) = TREE_CODE_REDUCTION;
@ -9936,16 +9932,14 @@ free_stmt_vec_info (gimple *stmt)
release_ssa_name (lhs); release_ssa_name (lhs);
free_stmt_vec_info (seq_stmt); free_stmt_vec_info (seq_stmt);
} }
stmt_vec_info patt_info stmt_vec_info patt_stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
= vinfo_for_stmt (STMT_VINFO_RELATED_STMT (stmt_info)); if (patt_stmt_info)
if (patt_info)
{ {
gimple *patt_stmt = STMT_VINFO_STMT (patt_info); gimple_set_bb (patt_stmt_info->stmt, NULL);
gimple_set_bb (patt_stmt, NULL); tree lhs = gimple_get_lhs (patt_stmt_info->stmt);
tree lhs = gimple_get_lhs (patt_stmt);
if (lhs && TREE_CODE (lhs) == SSA_NAME) if (lhs && TREE_CODE (lhs) == SSA_NAME)
release_ssa_name (lhs); release_ssa_name (lhs);
free_stmt_vec_info (patt_stmt); free_stmt_vec_info (patt_stmt_info);
} }
} }
@ -10143,8 +10137,8 @@ vect_is_simple_use (tree operand, vec_info *vinfo, enum vect_def_type *dt,
{ {
if (STMT_VINFO_IN_PATTERN_P (stmt_vinfo)) if (STMT_VINFO_IN_PATTERN_P (stmt_vinfo))
{ {
def_stmt = STMT_VINFO_RELATED_STMT (stmt_vinfo); stmt_vinfo = STMT_VINFO_RELATED_STMT (stmt_vinfo);
stmt_vinfo = vinfo_for_stmt (def_stmt); def_stmt = stmt_vinfo->stmt;
} }
switch (gimple_code (def_stmt)) switch (gimple_code (def_stmt))
{ {

14
gcc/tree-vectorizer.h
View File

@ -847,7 +847,7 @@ struct _stmt_vec_info {
related_stmt of the "pattern stmt" points back to this stmt (which is related_stmt of the "pattern stmt" points back to this stmt (which is
the last stmt in the original sequence of stmts that constitutes the the last stmt in the original sequence of stmts that constitutes the
pattern). */ pattern). */
gimple *related_stmt; stmt_vec_info related_stmt;
/* Used to keep a sequence of def stmts of a pattern stmt if such exists. /* Used to keep a sequence of def stmts of a pattern stmt if such exists.
The sequence is attached to the original statement rather than the The sequence is attached to the original statement rather than the
@ -1189,16 +1189,8 @@ get_later_stmt (gimple *stmt1, gimple *stmt2)
static inline bool static inline bool
is_pattern_stmt_p (stmt_vec_info stmt_info) is_pattern_stmt_p (stmt_vec_info stmt_info)
{ {
gimple *related_stmt; stmt_vec_info related_stmt_info = STMT_VINFO_RELATED_STMT (stmt_info);
stmt_vec_info related_stmt_info; return related_stmt_info && STMT_VINFO_IN_PATTERN_P (related_stmt_info);
related_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
if (related_stmt
&& (related_stmt_info = vinfo_for_stmt (related_stmt))
&& STMT_VINFO_IN_PATTERN_P (related_stmt_info))
return true;
return false;
} }
/* Return true if BB is a loop header. */ /* Return true if BB is a loop header. */