Skip to content

R
riscv-gcc-1
Commit 310213d4 by Richard Biener Committed by Richard Biener
Options

tree-vectorizer.h (vec_info): New base class for... 

2015-10-06  Richard Biener  <rguenther@suse.de>

	* tree-vectorizer.h (vec_info): New base class for...
	(_loop_vec_info): ... this and ...
	(_bb_vec_info): ... this.
	(vect_is_simple_use, vect_is_simple_use_1, new_stmt_vec_info,
	vect_analyze_data_refs_alignment, vect_verify_datarefs_alignment,
	vect_analyze_data_ref_accesses, vect_analyze_data_refs,
	vect_schedule_slp, vect_analyze_slp, vect_pattern_recog,
	vect_destroy_datarefs): Adjust interface to take a vec_info *
	rather than both a loop_vec_info and a bb_vec_info argument.
	* tree-vect-data-refs.c (vect_compute_data_refs_alignment,
	vect_verify_datarefs_alignment, vect_enhance_data_refs_alignment,
	vect_analyze_data_refs_alignment, vect_analyze_data_ref_accesses,
	vect_analyze_data_refs, vect_create_data_ref_ptr): Adjust
	accordingly.
	* tree-vect-loop.c (new_loop_vec_info): Initialize base class.
	(destroy_loop_vec_info, vect_analyze_loop_2,
	vect_is_simple_reduction_1, get_initial_def_for_induction,
	vect_create_epilog_for_reduction, vectorizable_reduction,
	vectorizable_live_operation, vect_transform_loop): Adjust.
	* tree-vect-patterns.c (type_conversion_p,
	vect_recog_widen_mult_pattern, vect_recog_widen_shift_pattern,
	vect_recog_rotate_pattern, vect_recog_vector_vector_shift_pattern,
	vect_recog_divmod_pattern, vect_recog_mixed_size_cond_pattern,
	check_bool_pattern, vect_recog_bool_pattern,
	vect_mark_pattern_stmts, vect_pattern_recog): Likewise.
	* tree-vect-slp.c (vect_get_and_check_slp_defs,
	vect_build_slp_tree_1, vect_build_slp_tree, vect_analyze_slp_cost_1,
	vect_analyze_slp_instance, vect_analyze_slp, destroy_bb_vec_info,
	vect_slp_analyze_bb_1, vect_schedule_slp): Likewise.
	(new_bb_vec_info): Initialize base classs.
	* tree-vect-stmts.c (record_stmt_cost, process_use,
	vect_get_vec_def_for_operand, vect_finish_stmt_generation,
	vectorizable_mask_load_store, vectorizable_call,
	vectorizable_simd_clone_call, vectorizable_conversion,
	vectorizable_assignment, vectorizable_shift,
	vectorizable_operation, vectorizable_store,
	vectorizable_load, vect_is_simple_cond, vectorizable_condition,
	new_stmt_vec_info, vect_is_simple_use, vect_is_simple_use_1): Likewise.
	* tree-vectorizer.c (vect_destroy_datarefs): Likewise.

From-SVN: r228514
parent 5097195f
Showing with 344 additions and 369 deletions
gcc/ChangeLog
2015-10-06 Richard Biener <rguenther@suse.de>
* tree-vectorizer.h (vec_info): New base class for...
(_loop_vec_info): ... this and ...
(_bb_vec_info): ... this.
(vect_is_simple_use, vect_is_simple_use_1, new_stmt_vec_info,
vect_analyze_data_refs_alignment, vect_verify_datarefs_alignment,
vect_analyze_data_ref_accesses, vect_analyze_data_refs,
vect_schedule_slp, vect_analyze_slp, vect_pattern_recog,
vect_destroy_datarefs): Adjust interface to take a vec_info *
rather than both a loop_vec_info and a bb_vec_info argument.
* tree-vect-data-refs.c (vect_compute_data_refs_alignment,
vect_verify_datarefs_alignment, vect_enhance_data_refs_alignment,
vect_analyze_data_refs_alignment, vect_analyze_data_ref_accesses,
vect_analyze_data_refs, vect_create_data_ref_ptr): Adjust
accordingly.
* tree-vect-loop.c (new_loop_vec_info): Initialize base class.
(destroy_loop_vec_info, vect_analyze_loop_2,
vect_is_simple_reduction_1, get_initial_def_for_induction,
vect_create_epilog_for_reduction, vectorizable_reduction,
vectorizable_live_operation, vect_transform_loop): Adjust.
* tree-vect-patterns.c (type_conversion_p,
vect_recog_widen_mult_pattern, vect_recog_widen_shift_pattern,
vect_recog_rotate_pattern, vect_recog_vector_vector_shift_pattern,
vect_recog_divmod_pattern, vect_recog_mixed_size_cond_pattern,
check_bool_pattern, vect_recog_bool_pattern,
vect_mark_pattern_stmts, vect_pattern_recog): Likewise.
* tree-vect-slp.c (vect_get_and_check_slp_defs,
vect_build_slp_tree_1, vect_build_slp_tree, vect_analyze_slp_cost_1,
vect_analyze_slp_instance, vect_analyze_slp, destroy_bb_vec_info,
vect_slp_analyze_bb_1, vect_schedule_slp): Likewise.
(new_bb_vec_info): Initialize base classs.
* tree-vect-stmts.c (record_stmt_cost, process_use,
vect_get_vec_def_for_operand, vect_finish_stmt_generation,
vectorizable_mask_load_store, vectorizable_call,
vectorizable_simd_clone_call, vectorizable_conversion,
vectorizable_assignment, vectorizable_shift,
vectorizable_operation, vectorizable_store,
vectorizable_load, vect_is_simple_cond, vectorizable_condition,
new_stmt_vec_info, vect_is_simple_use, vect_is_simple_use_1): Likewise.
* tree-vectorizer.c (vect_destroy_datarefs): Likewise.
2015-10-05 Kaz Kojima <kkojima@gcc.gnu.org>
PR c/65345
gcc/tree-vect-data-refs.c
......@@ -784,23 +784,17 @@ vect_compute_data_ref_alignment (struct data_reference *dr)
Return FALSE if a data reference is found that cannot be vectorized. */
static bool
vect_compute_data_refs_alignment (loop_vec_info loop_vinfo,
bb_vec_info bb_vinfo)
vect_compute_data_refs_alignment (vec_info *vinfo)
{
vec<data_reference_p> datarefs;
vec<data_reference_p> datarefs = vinfo->datarefs;
struct data_reference *dr;
unsigned int i;
if (loop_vinfo)
datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
else
datarefs = BB_VINFO_DATAREFS (bb_vinfo);
FOR_EACH_VEC_ELT (datarefs, i, dr)
if (STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (DR_STMT (dr)))
&& !vect_compute_data_ref_alignment (dr))
{
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
{
/* Mark unsupported statement as unvectorizable. */
STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (DR_STMT (dr))) = false;
......@@ -879,18 +873,13 @@ vect_update_misalignment_for_peel (struct data_reference *dr,
handled with respect to alignment. */
bool
vect_verify_datarefs_alignment (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
vect_verify_datarefs_alignment (vec_info *vinfo)
{
vec<data_reference_p> datarefs;
vec<data_reference_p> datarefs = vinfo->datarefs;
struct data_reference *dr;
enum dr_alignment_support supportable_dr_alignment;
unsigned int i;
if (loop_vinfo)
datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
else
datarefs = BB_VINFO_DATAREFS (bb_vinfo);
FOR_EACH_VEC_ELT (datarefs, i, dr)
{
gimple *stmt = DR_STMT (dr);
......@@ -1679,7 +1668,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
if (do_peeling && known_alignment_for_access_p (dr0) && npeel == 0)
{
stat = vect_verify_datarefs_alignment (loop_vinfo, NULL);
stat = vect_verify_datarefs_alignment (loop_vinfo);
if (!stat)
do_peeling = false;
else
......@@ -1758,7 +1747,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
Drop the body_cst_vec on the floor here. */
body_cost_vec.release ();
stat = vect_verify_datarefs_alignment (loop_vinfo, NULL);
stat = vect_verify_datarefs_alignment (loop_vinfo);
gcc_assert (stat);
return stat;
}
......@@ -1875,7 +1864,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
/* Peeling and versioning can't be done together at this time. */
gcc_assert (! (do_peeling && do_versioning));
stat = vect_verify_datarefs_alignment (loop_vinfo, NULL);
stat = vect_verify_datarefs_alignment (loop_vinfo);
gcc_assert (stat);
return stat;
}
......@@ -1883,7 +1872,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
/* This point is reached if neither peeling nor versioning is being done. */
gcc_assert (! (do_peeling || do_versioning));
stat = vect_verify_datarefs_alignment (loop_vinfo, NULL);
stat = vect_verify_datarefs_alignment (loop_vinfo);
return stat;
}
......@@ -1967,8 +1956,7 @@ vect_find_same_alignment_drs (struct data_dependence_relation *ddr,
Return FALSE if a data reference is found that cannot be vectorized. */
bool
vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo,
bb_vec_info bb_vinfo)
vect_analyze_data_refs_alignment (vec_info *vinfo)
{
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
......@@ -1976,17 +1964,17 @@ vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo,
/* Mark groups of data references with same alignment using
data dependence information. */
if (loop_vinfo)
if (is_a <loop_vec_info> (vinfo))
{
vec<ddr_p> ddrs = LOOP_VINFO_DDRS (loop_vinfo);
vec<ddr_p> ddrs = vinfo->ddrs;
struct data_dependence_relation *ddr;
unsigned int i;
FOR_EACH_VEC_ELT (ddrs, i, ddr)
vect_find_same_alignment_drs (ddr, loop_vinfo);
vect_find_same_alignment_drs (ddr, as_a <loop_vec_info> (vinfo));
}
if (!vect_compute_data_refs_alignment (loop_vinfo, bb_vinfo))
if (!vect_compute_data_refs_alignment (vinfo))
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -2516,21 +2504,16 @@ dr_group_sort_cmp (const void *dra_, const void *drb_)
FORNOW: handle only arrays and pointer accesses. */
bool
vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
vect_analyze_data_ref_accesses (vec_info *vinfo)
{
unsigned int i;
vec<data_reference_p> datarefs;
vec<data_reference_p> datarefs = vinfo->datarefs;
struct data_reference *dr;
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
"=== vect_analyze_data_ref_accesses ===\n");
if (loop_vinfo)
datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
else
datarefs = BB_VINFO_DATAREFS (bb_vinfo);
if (datarefs.is_empty ())
return true;
......@@ -2654,7 +2637,7 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
"not vectorized: complicated access pattern.\n");
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
{
/* Mark the statement as not vectorizable. */
STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (DR_STMT (dr))) = false;
......@@ -3217,9 +3200,7 @@ vect_check_gather_scatter (gimple *stmt, loop_vec_info loop_vinfo, tree *basep,
*/
bool
vect_analyze_data_refs (loop_vec_info loop_vinfo,
bb_vec_info bb_vinfo,
int *min_vf, unsigned *n_stmts)
vect_analyze_data_refs (vec_info *vinfo, int *min_vf, unsigned *n_stmts)
{
struct loop *loop = NULL;
basic_block bb = NULL;
......@@ -3232,7 +3213,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
dump_printf_loc (MSG_NOTE, vect_location,
"=== vect_analyze_data_refs ===\n");
if (loop_vinfo)
if (loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo))
{
basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
......@@ -3304,6 +3285,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
}
else
{
bb_vec_info bb_vinfo = as_a <bb_vec_info> (vinfo);
gimple_stmt_iterator gsi;
bb = BB_VINFO_BB (bb_vinfo);
......@@ -3381,11 +3363,11 @@ again:
&& !TREE_THIS_VOLATILE (DR_REF (dr))
&& targetm.vectorize.builtin_scatter != NULL;
bool maybe_simd_lane_access
= loop_vinfo && loop->simduid;
= is_a <loop_vec_info> (vinfo) && loop->simduid;
/* If target supports vector gather loads or scatter stores, or if
this might be a SIMD lane access, see if they can't be used. */
if (loop_vinfo
if (is_a <loop_vec_info> (vinfo)
&& (maybe_gather || maybe_scatter || maybe_simd_lane_access)
&& !nested_in_vect_loop_p (loop, stmt))
{
......@@ -3468,7 +3450,7 @@ again:
dump_printf (MSG_MISSED_OPTIMIZATION, "\n");
}
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
break;
return false;
......@@ -3482,7 +3464,7 @@ again:
"not vectorized: base addr of dr is a "
"constant\n");
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
break;
if (gatherscatter != SG_NONE || simd_lane_access)
......@@ -3500,7 +3482,7 @@ again:
dump_printf (MSG_MISSED_OPTIMIZATION, "\n");
}
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
break;
return false;
......@@ -3517,7 +3499,7 @@ again:
dump_printf (MSG_MISSED_OPTIMIZATION, "\n");
}
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
break;
if (gatherscatter != SG_NONE || simd_lane_access)
......@@ -3537,7 +3519,7 @@ again:
dump_printf (MSG_MISSED_OPTIMIZATION, "\n");
}
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
break;
if (gatherscatter != SG_NONE || simd_lane_access)
......@@ -3562,7 +3544,7 @@ again:
dump_printf (MSG_MISSED_OPTIMIZATION, "\n");
}
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
break;
if (gatherscatter != SG_NONE || simd_lane_access)
......@@ -3700,7 +3682,7 @@ again:
dump_printf (MSG_MISSED_OPTIMIZATION, "\n");
}
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
break;
if (gatherscatter != SG_NONE || simd_lane_access)
......@@ -3733,7 +3715,7 @@ again:
dump_printf (MSG_MISSED_OPTIMIZATION, "\n");
}
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
break;
if (gatherscatter != SG_NONE || simd_lane_access)
......@@ -3766,7 +3748,8 @@ again:
if (gatherscatter != SG_NONE)
{
tree off;
if (!vect_check_gather_scatter (stmt, loop_vinfo, NULL, &off, NULL)
if (!vect_check_gather_scatter (stmt, as_a <loop_vec_info> (vinfo),
NULL, &off, NULL)
|| get_vectype_for_scalar_type (TREE_TYPE (off)) == NULL_TREE)
{
STMT_VINFO_DATA_REF (stmt_info) = NULL;
......@@ -3789,7 +3772,7 @@ again:
STMT_VINFO_GATHER_SCATTER_P (stmt_info) = gatherscatter;
}
else if (loop_vinfo
else if (is_a <loop_vec_info> (vinfo)
&& TREE_CODE (DR_STEP (dr)) != INTEGER_CST)
{
if (nested_in_vect_loop_p (loop, stmt))
......@@ -3814,7 +3797,7 @@ again:
avoids spending useless time in analyzing their dependence. */
if (i != datarefs.length ())
{
gcc_assert (bb_vinfo != NULL);
gcc_assert (is_a <bb_vec_info> (vinfo));
for (unsigned j = i; j < datarefs.length (); ++j)
{
data_reference_p dr = datarefs[j];
......@@ -4259,7 +4242,7 @@ vect_create_data_ref_ptr (gimple *stmt, tree aggr_type, struct loop *at_loop,
aggr_ptr, loop, &incr_gsi, insert_after,
&indx_before_incr, &indx_after_incr);
incr = gsi_stmt (incr_gsi);
set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo, NULL));
set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo));
/* Copy the points-to information if it exists. */
if (DR_PTR_INFO (dr))
......@@ -4289,7 +4272,7 @@ vect_create_data_ref_ptr (gimple *stmt, tree aggr_type, struct loop *at_loop,
containing_loop, &incr_gsi, insert_after, &indx_before_incr,
&indx_after_incr);
incr = gsi_stmt (incr_gsi);
set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo, NULL));
set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo));
/* Copy the points-to information if it exists. */
if (DR_PTR_INFO (dr))
......
gcc/tree-vect-loop.c
......@@ -897,6 +897,7 @@ new_loop_vec_info (struct loop *loop)
unsigned int i, nbbs;
res = (loop_vec_info) xcalloc (1, sizeof (struct _loop_vec_info));
res->kind = vec_info::loop;
LOOP_VINFO_LOOP (res) = loop;
bbs = get_loop_body (loop);
......@@ -924,7 +925,7 @@ new_loop_vec_info (struct loop *loop)
loop_vec_info inner_loop_vinfo =
STMT_VINFO_LOOP_VINFO (stmt_info);
gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
STMT_VINFO_LOOP_VINFO (stmt_info) = res;
stmt_info->vinfo = res;
}
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
{
......@@ -933,7 +934,7 @@ new_loop_vec_info (struct loop *loop)
loop_vec_info inner_loop_vinfo =
STMT_VINFO_LOOP_VINFO (stmt_info);
gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
STMT_VINFO_LOOP_VINFO (stmt_info) = res;
stmt_info->vinfo = res;
}
}
else
......@@ -943,14 +944,14 @@ new_loop_vec_info (struct loop *loop)
{
gimple *phi = gsi_stmt (si);
gimple_set_uid (phi, 0);
set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, res, NULL));
set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, res));
}
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
{
gimple *stmt = gsi_stmt (si);
gimple_set_uid (stmt, 0);
set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res, NULL));
set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res));
}
}
}
......@@ -1055,7 +1056,7 @@ destroy_loop_vec_info (loop_vec_info loop_vinfo, bool clean_stmts)
}
free (LOOP_VINFO_BBS (loop_vinfo));
vect_destroy_datarefs (loop_vinfo, NULL);
vect_destroy_datarefs (loop_vinfo);
free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo));
LOOP_VINFO_LOOP_NEST (loop_vinfo).release ();
LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo).release ();
......@@ -1767,7 +1768,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
FORNOW: Handle only simple, array references, which
alignment can be forced, and aligned pointer-references. */
ok = vect_analyze_data_refs (loop_vinfo, NULL, &min_vf, &n_stmts);
ok = vect_analyze_data_refs (loop_vinfo, &min_vf, &n_stmts);
if (!ok)
{
if (dump_enabled_p ())
......@@ -1781,14 +1782,14 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
vect_analyze_scalar_cycles (loop_vinfo);
vect_pattern_recog (loop_vinfo, NULL);
vect_pattern_recog (loop_vinfo);
vect_fixup_scalar_cycles_with_patterns (loop_vinfo);
/* Analyze the access patterns of the data-refs in the loop (consecutive,
complex, etc.). FORNOW: Only handle consecutive access pattern. */
ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL);
ok = vect_analyze_data_ref_accesses (loop_vinfo);
if (!ok)
{
if (dump_enabled_p ())
......@@ -1840,7 +1841,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
}
/* Check the SLP opportunities in the loop, analyze and build SLP trees. */
ok = vect_analyze_slp (loop_vinfo, NULL, n_stmts);
ok = vect_analyze_slp (loop_vinfo, n_stmts);
if (!ok)
return false;
......@@ -1858,7 +1859,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
/* Analyze the alignment of the data-refs in the loop.
Fail if a data reference is found that cannot be vectorized. */
ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
ok = vect_analyze_data_refs_alignment (loop_vinfo);
if (!ok)
{
if (dump_enabled_p ())
......@@ -2646,7 +2647,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple *phi,
gimple *negate_stmt = gimple_build_assign (negrhs, NEGATE_EXPR, rhs);
gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
set_vinfo_for_stmt (negate_stmt, new_stmt_vec_info (negate_stmt,
loop_info, NULL));
loop_info));
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);
......@@ -3508,7 +3509,7 @@ get_initial_def_for_induction (gimple *iv_phi)
new_stmt);
gcc_assert (!new_bb);
set_vinfo_for_stmt (new_stmt,
new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
new_stmt_vec_info (new_stmt, loop_vinfo));
}
}
else
......@@ -3610,7 +3611,7 @@ get_initial_def_for_induction (gimple *iv_phi)
vec_dest = vect_get_new_vect_var (vectype, vect_simple_var, "vec_iv_");
induction_phi = create_phi_node (vec_dest, iv_loop->header);
set_vinfo_for_stmt (induction_phi,
new_stmt_vec_info (induction_phi, loop_vinfo, NULL));
new_stmt_vec_info (induction_phi, loop_vinfo));
induc_def = PHI_RESULT (induction_phi);
/* Create the iv update inside the loop */
......@@ -3618,8 +3619,7 @@ get_initial_def_for_induction (gimple *iv_phi)
vec_def = make_ssa_name (vec_dest, new_stmt);
gimple_assign_set_lhs (new_stmt, vec_def);
gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
set_vinfo_for_stmt (new_stmt, new_stmt_vec_info (new_stmt, loop_vinfo,
NULL));
set_vinfo_for_stmt (new_stmt, new_stmt_vec_info (new_stmt, loop_vinfo));
/* Set the arguments of the phi node: */
add_phi_arg (induction_phi, vec_init, pe, UNKNOWN_LOCATION);
......@@ -3684,7 +3684,7 @@ get_initial_def_for_induction (gimple *iv_phi)
gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
}
set_vinfo_for_stmt (new_stmt,
new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
new_stmt_vec_info (new_stmt, loop_vinfo));
STMT_VINFO_RELATED_STMT (prev_stmt_vinfo) = new_stmt;
prev_stmt_vinfo = vinfo_for_stmt (new_stmt);
}
......@@ -3752,7 +3752,7 @@ get_initial_def_for_induction (gimple *iv_phi)
si = gsi_after_labels (bb);
gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
set_vinfo_for_stmt (new_stmt,
new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
new_stmt_vec_info (new_stmt, loop_vinfo));
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_stmt))
= STMT_VINFO_RELATED_STMT (vinfo_for_stmt (induction_phi));
}
......@@ -4177,7 +4177,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
{
tree new_def = copy_ssa_name (def);
phi = create_phi_node (new_def, exit_bb);
set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo, NULL));
set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo));
if (j == 0)
new_phis.quick_push (phi);
else
......@@ -4205,7 +4205,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
SET_PHI_ARG_DEF (outer_phi, single_exit (loop)->dest_idx,
PHI_RESULT (phi));
set_vinfo_for_stmt (outer_phi, new_stmt_vec_info (outer_phi,
loop_vinfo, NULL));
loop_vinfo));
inner_phis.quick_push (phi);
new_phis[i] = outer_phi;
prev_phi_info = vinfo_for_stmt (outer_phi);
......@@ -4217,7 +4217,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
SET_PHI_ARG_DEF (outer_phi, single_exit (loop)->dest_idx,
PHI_RESULT (phi));
set_vinfo_for_stmt (outer_phi, new_stmt_vec_info (outer_phi,
loop_vinfo, NULL));
loop_vinfo));
STMT_VINFO_RELATED_STMT (prev_phi_info) = outer_phi;
prev_phi_info = vinfo_for_stmt (outer_phi);
}
......@@ -4558,8 +4558,7 @@ vect_finalize_reduction:
if (nested_in_vect_loop)
{
set_vinfo_for_stmt (epilog_stmt,
new_stmt_vec_info (epilog_stmt, loop_vinfo,
NULL));
new_stmt_vec_info (epilog_stmt, loop_vinfo));
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (epilog_stmt)) =
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_phi));
......@@ -4730,7 +4729,7 @@ vect_finalize_reduction:
/* Create vector phi node. */
vect_phi = create_phi_node (vec_initial_def, bb);
new_phi_vinfo = new_stmt_vec_info (vect_phi,
loop_vec_info_for_loop (outer_loop), NULL);
loop_vec_info_for_loop (outer_loop));
set_vinfo_for_stmt (vect_phi, new_phi_vinfo);
/* Create vs0 - initial def of the double reduction phi. */
......@@ -5037,7 +5036,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
if (i == 0 && code == COND_EXPR)
continue;
is_simple_use = vect_is_simple_use_1 (ops[i], stmt, loop_vinfo, NULL,
is_simple_use = vect_is_simple_use_1 (ops[i], stmt, loop_vinfo,
&def_stmt, &def, &dt, &tem);
if (!vectype_in)
vectype_in = tem;
......@@ -5058,7 +5057,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
}
}
is_simple_use = vect_is_simple_use_1 (ops[i], stmt, loop_vinfo, NULL,
is_simple_use = vect_is_simple_use_1 (ops[i], stmt, loop_vinfo,
&def_stmt, &def, &dt, &tem);
if (!vectype_in)
vectype_in = tem;
......@@ -5387,8 +5386,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
operand. */
new_phi = create_phi_node (vec_dest, loop->header);
set_vinfo_for_stmt (new_phi,
new_stmt_vec_info (new_phi, loop_vinfo,
NULL));
new_stmt_vec_info (new_phi, loop_vinfo));
if (j == 0 || slp_node)
phis.quick_push (new_phi);
}
......@@ -5440,14 +5438,14 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
gimple *dummy_stmt;
tree dummy;
vect_is_simple_use (ops[!reduc_index], stmt, loop_vinfo, NULL,
vect_is_simple_use (ops[!reduc_index], stmt, loop_vinfo,
&dummy_stmt, &dummy, &dt);
loop_vec_def0 = vect_get_vec_def_for_stmt_copy (dt,
loop_vec_def0);
vec_oprnds0[0] = loop_vec_def0;
if (op_type == ternary_op)
{
vect_is_simple_use (op1, stmt, loop_vinfo, NULL, &dummy_stmt,
vect_is_simple_use (op1, stmt, loop_vinfo, &dummy_stmt,
&dummy, &dt);
loop_vec_def1 = vect_get_vec_def_for_stmt_copy (dt,
loop_vec_def1);
......@@ -5749,8 +5747,7 @@ vectorizable_live_operation (gimple *stmt,
else
op = gimple_op (stmt, i + 1);
if (op
&& !vect_is_simple_use (op, stmt, loop_vinfo, NULL, &def_stmt, &def,
&dt))
&& !vect_is_simple_use (op, stmt, loop_vinfo, &def_stmt, &def, &dt))
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -6218,7 +6215,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
dump_printf_loc (MSG_NOTE, vect_location,
"=== scheduling SLP instances ===\n");
vect_schedule_slp (loop_vinfo, NULL);
vect_schedule_slp (loop_vinfo);
}
/* Hybrid SLP stmts must be vectorized in addition to SLP. */
......
gcc/tree-vect-patterns.c
......@@ -171,18 +171,14 @@ type_conversion_p (tree name, gimple *use_stmt, bool check_sign,
{
tree dummy;
gimple *dummy_gimple;
loop_vec_info loop_vinfo;
stmt_vec_info stmt_vinfo;
tree type = TREE_TYPE (name);
tree oprnd0;
enum vect_def_type dt;
tree def;
bb_vec_info bb_vinfo;
stmt_vinfo = vinfo_for_stmt (use_stmt);
loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
if (!vect_is_simple_use (name, use_stmt, loop_vinfo, bb_vinfo, def_stmt,
if (!vect_is_simple_use (name, use_stmt, stmt_vinfo->vinfo, def_stmt,
&def, &dt))
return false;
......@@ -211,8 +207,8 @@ type_conversion_p (tree name, gimple *use_stmt, bool check_sign,
else
*promotion = false;
if (!vect_is_simple_use (oprnd0, *def_stmt, loop_vinfo,
bb_vinfo, &dummy_gimple, &dummy, &dt))
if (!vect_is_simple_use (oprnd0, *def_stmt, stmt_vinfo->vinfo,
&dummy_gimple, &dummy, &dt))
return false;
return true;
......@@ -978,8 +974,6 @@ vect_recog_widen_mult_pattern (vec<gimple *> *stmts,
pattern_stmt = gimple_build_assign (var, WIDEN_MULT_EXPR, oprnd0, oprnd1);
stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
STMT_VINFO_PATTERN_DEF_SEQ (stmt_vinfo) = NULL;
/* If the original two operands have different sizes, we may need to convert
......@@ -989,7 +983,7 @@ vect_recog_widen_mult_pattern (vec<gimple *> *stmts,
{
append_pattern_def_seq (stmt_vinfo, new_stmt);
stmt_vec_info new_stmt_info
= new_stmt_vec_info (new_stmt, loop_vinfo, bb_vinfo);
= new_stmt_vec_info (new_stmt, stmt_vinfo->vinfo);
set_vinfo_for_stmt (new_stmt, new_stmt_info);
STMT_VINFO_VECTYPE (new_stmt_info) = vectype;
}
......@@ -1000,7 +994,7 @@ vect_recog_widen_mult_pattern (vec<gimple *> *stmts,
{
append_pattern_def_seq (stmt_vinfo, pattern_stmt);
stmt_vec_info pattern_stmt_info
= new_stmt_vec_info (pattern_stmt, loop_vinfo, bb_vinfo);
= new_stmt_vec_info (pattern_stmt, stmt_vinfo->vinfo);
set_vinfo_for_stmt (pattern_stmt, pattern_stmt_info);
STMT_VINFO_VECTYPE (pattern_stmt_info) = vecitype;
pattern_stmt = gimple_build_assign (vect_recog_temp_ssa_var (type, NULL),
......@@ -1754,11 +1748,9 @@ vect_recog_widen_shift_pattern (vec<gimple *> *stmts,
if (wstmt)
{
stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
new_pattern_def_seq (stmt_vinfo, wstmt);
stmt_vec_info new_stmt_info
= new_stmt_vec_info (wstmt, loop_vinfo, bb_vinfo);
= new_stmt_vec_info (wstmt, stmt_vinfo->vinfo);
set_vinfo_for_stmt (wstmt, new_stmt_info);
STMT_VINFO_VECTYPE (new_stmt_info) = vectype;
}
......@@ -1807,8 +1799,7 @@ vect_recog_rotate_pattern (vec<gimple *> *stmts, tree *type_in, tree *type_out)
gimple *pattern_stmt, *def_stmt;
enum tree_code rhs_code;
stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
vec_info *vinfo = stmt_vinfo->vinfo;
enum vect_def_type dt;
optab optab1, optab2;
edge ext_def = NULL;
......@@ -1839,8 +1830,7 @@ vect_recog_rotate_pattern (vec<gimple *> *stmts, tree *type_in, tree *type_out)
|| !TYPE_UNSIGNED (type))
return NULL;
if (!vect_is_simple_use (oprnd1, last_stmt, loop_vinfo, bb_vinfo, &def_stmt,
&def, &dt))
if (!vect_is_simple_use (oprnd1, last_stmt, vinfo, &def_stmt, &def, &dt))
return NULL;
if (dt != vect_internal_def
......@@ -1859,7 +1849,7 @@ vect_recog_rotate_pattern (vec<gimple *> *stmts, tree *type_in, tree *type_out)
&& optab_handler (optab1, TYPE_MODE (vectype)) != CODE_FOR_nothing)
return NULL;
if (bb_vinfo != NULL || dt != vect_internal_def)
if (is_a <bb_vec_info> (vinfo) || dt != vect_internal_def)
{
optab2 = optab_for_tree_code (rhs_code, vectype, optab_scalar);
if (optab2
......@@ -1876,7 +1866,7 @@ vect_recog_rotate_pattern (vec<gimple *> *stmts, tree *type_in, tree *type_out)
|| !optab2
|| optab_handler (optab2, TYPE_MODE (vectype)) == CODE_FOR_nothing)
{
if (bb_vinfo == NULL && dt == vect_internal_def)
if (! is_a <bb_vec_info> (vinfo) && dt == vect_internal_def)
return NULL;
optab1 = optab_for_tree_code (LSHIFT_EXPR, vectype, optab_scalar);
optab2 = optab_for_tree_code (RSHIFT_EXPR, vectype, optab_scalar);
......@@ -1894,9 +1884,9 @@ vect_recog_rotate_pattern (vec<gimple *> *stmts, tree *type_in, tree *type_out)
if (dt == vect_external_def
&& TREE_CODE (oprnd1) == SSA_NAME
&& loop_vinfo)
&& is_a <loop_vec_info> (vinfo))
{
struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
struct loop *loop = as_a <loop_vec_info> (vinfo)->loop;
ext_def = loop_preheader_edge (loop);
if (!SSA_NAME_IS_DEFAULT_DEF (oprnd1))
{
......@@ -1963,7 +1953,7 @@ vect_recog_rotate_pattern (vec<gimple *> *stmts, tree *type_in, tree *type_out)
}
else
{
def_stmt_vinfo = new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
def_stmt_vinfo = new_stmt_vec_info (def_stmt, vinfo);
set_vinfo_for_stmt (def_stmt, def_stmt_vinfo);
STMT_VINFO_VECTYPE (def_stmt_vinfo) = vecstype;
append_pattern_def_seq (stmt_vinfo, def_stmt);
......@@ -1982,7 +1972,7 @@ vect_recog_rotate_pattern (vec<gimple *> *stmts, tree *type_in, tree *type_out)
}
else
{
def_stmt_vinfo = new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
def_stmt_vinfo = new_stmt_vec_info (def_stmt, vinfo);
set_vinfo_for_stmt (def_stmt, def_stmt_vinfo);
STMT_VINFO_VECTYPE (def_stmt_vinfo) = vecstype;
append_pattern_def_seq (stmt_vinfo, def_stmt);
......@@ -2066,8 +2056,7 @@ vect_recog_vector_vector_shift_pattern (vec<gimple *> *stmts,
gimple *pattern_stmt, *def_stmt;
enum tree_code rhs_code;
stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
vec_info *vinfo = stmt_vinfo->vinfo;
enum vect_def_type dt;
tree def;
......@@ -2101,7 +2090,7 @@ vect_recog_vector_vector_shift_pattern (vec<gimple *> *stmts,
!= TYPE_PRECISION (TREE_TYPE (oprnd0)))
return NULL;
if (!vect_is_simple_use (oprnd1, last_stmt, loop_vinfo, bb_vinfo, &def_stmt,
if (!vect_is_simple_use (oprnd1, last_stmt, vinfo, &def_stmt,
&def, &dt))
return NULL;
......@@ -2329,8 +2318,7 @@ vect_recog_divmod_pattern (vec<gimple *> *stmts,
gimple *pattern_stmt, *def_stmt;
enum tree_code rhs_code;
stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
vec_info *vinfo = stmt_vinfo->vinfo;
optab optab;
tree q;
int dummy_int, prec;
......@@ -2435,8 +2423,7 @@ vect_recog_divmod_pattern (vec<gimple *> *stmts,
def_stmt = gimple_build_assign (var, COND_EXPR, cond,
build_int_cst (utype, -1),
build_int_cst (utype, 0));
def_stmt_vinfo
= new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
def_stmt_vinfo = new_stmt_vec_info (def_stmt, vinfo);
set_vinfo_for_stmt (def_stmt, def_stmt_vinfo);
STMT_VINFO_VECTYPE (def_stmt_vinfo) = vecutype;
append_pattern_def_seq (stmt_vinfo, def_stmt);
......@@ -2444,8 +2431,7 @@ vect_recog_divmod_pattern (vec<gimple *> *stmts,
def_stmt = gimple_build_assign (var, RSHIFT_EXPR,
gimple_assign_lhs (def_stmt),
shift);
def_stmt_vinfo
= new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
def_stmt_vinfo = new_stmt_vec_info (def_stmt, vinfo);
set_vinfo_for_stmt (def_stmt, def_stmt_vinfo);
STMT_VINFO_VECTYPE (def_stmt_vinfo) = vecutype;
append_pattern_def_seq (stmt_vinfo, def_stmt);
......@@ -2779,8 +2765,7 @@ vect_recog_mixed_size_cond_pattern (vec<gimple *> *stmts, tree *type_in,
stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt), def_stmt_info;
tree type, vectype, comp_vectype, itype = NULL_TREE, vecitype;
gimple *pattern_stmt, *def_stmt;
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
vec_info *vinfo = stmt_vinfo->vinfo;
tree orig_type0 = NULL_TREE, orig_type1 = NULL_TREE;
gimple *def_stmt0 = NULL, *def_stmt1 = NULL;
bool promotion;
......@@ -2885,7 +2870,7 @@ vect_recog_mixed_size_cond_pattern (vec<gimple *> *stmts, tree *type_in,
NOP_EXPR, gimple_assign_lhs (def_stmt));
new_pattern_def_seq (stmt_vinfo, def_stmt);
def_stmt_info = new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
def_stmt_info = new_stmt_vec_info (def_stmt, vinfo);
set_vinfo_for_stmt (def_stmt, def_stmt_info);
STMT_VINFO_VECTYPE (def_stmt_info) = vecitype;
*type_in = vecitype;
......@@ -2903,14 +2888,14 @@ vect_recog_mixed_size_cond_pattern (vec<gimple *> *stmts, tree *type_in,
true if bool VAR can be optimized that way. */
static bool
check_bool_pattern (tree var, loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
check_bool_pattern (tree var, vec_info *vinfo)
{
gimple *def_stmt;
enum vect_def_type dt;
tree def, rhs1;
enum tree_code rhs_code;
if (!vect_is_simple_use (var, NULL, loop_vinfo, bb_vinfo, &def_stmt, &def,
if (!vect_is_simple_use (var, NULL, vinfo, &def_stmt, &def,
&dt))
return false;
......@@ -2928,25 +2913,24 @@ check_bool_pattern (tree var, loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
switch (rhs_code)
{
case SSA_NAME:
return check_bool_pattern (rhs1, loop_vinfo, bb_vinfo);
return check_bool_pattern (rhs1, vinfo);
CASE_CONVERT:
if ((TYPE_PRECISION (TREE_TYPE (rhs1)) != 1
|| !TYPE_UNSIGNED (TREE_TYPE (rhs1)))
&& TREE_CODE (TREE_TYPE (rhs1)) != BOOLEAN_TYPE)
return false;
return check_bool_pattern (rhs1, loop_vinfo, bb_vinfo);
return check_bool_pattern (rhs1, vinfo);
case BIT_NOT_EXPR:
return check_bool_pattern (rhs1, loop_vinfo, bb_vinfo);
return check_bool_pattern (rhs1, vinfo);
case BIT_AND_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
if (!check_bool_pattern (rhs1, loop_vinfo, bb_vinfo))
if (!check_bool_pattern (rhs1, vinfo))
return false;
return check_bool_pattern (gimple_assign_rhs2 (def_stmt), loop_vinfo,
bb_vinfo);
return check_bool_pattern (gimple_assign_rhs2 (def_stmt), vinfo);
default:
if (TREE_CODE_CLASS (rhs_code) == tcc_comparison)
......@@ -3243,8 +3227,7 @@ vect_recog_bool_pattern (vec<gimple *> *stmts, tree *type_in,
enum tree_code rhs_code;
tree var, lhs, rhs, vectype;
stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
vec_info *vinfo = stmt_vinfo->vinfo;
gimple *pattern_stmt;
if (!is_gimple_assign (last_stmt))
......@@ -3268,7 +3251,7 @@ vect_recog_bool_pattern (vec<gimple *> *stmts, tree *type_in,
if (vectype == NULL_TREE)
return NULL;
if (!check_bool_pattern (var, loop_vinfo, bb_vinfo))
if (!check_bool_pattern (var, vinfo))
return NULL;
rhs = adjust_bool_pattern (var, TREE_TYPE (lhs), NULL_TREE, stmts);
......@@ -3306,7 +3289,7 @@ vect_recog_bool_pattern (vec<gimple *> *stmts, tree *type_in,
if (get_vectype_for_scalar_type (type) == NULL_TREE)
return NULL;
if (!check_bool_pattern (var, loop_vinfo, bb_vinfo))
if (!check_bool_pattern (var, vinfo))
return NULL;
rhs = adjust_bool_pattern (var, type, NULL_TREE, stmts);
......@@ -3334,7 +3317,7 @@ vect_recog_bool_pattern (vec<gimple *> *stmts, tree *type_in,
gcc_assert (vectype != NULL_TREE);
if (!VECTOR_MODE_P (TYPE_MODE (vectype)))
return NULL;
if (!check_bool_pattern (var, loop_vinfo, bb_vinfo))
if (!check_bool_pattern (var, vinfo))
return NULL;
rhs = adjust_bool_pattern (var, TREE_TYPE (vectype), NULL_TREE, stmts);
......@@ -3347,8 +3330,7 @@ vect_recog_bool_pattern (vec<gimple *> *stmts, tree *type_in,
rhs = rhs2;
}
pattern_stmt = gimple_build_assign (lhs, SSA_NAME, rhs);
pattern_stmt_info = new_stmt_vec_info (pattern_stmt, loop_vinfo,
bb_vinfo);
pattern_stmt_info = new_stmt_vec_info (pattern_stmt, vinfo);
set_vinfo_for_stmt (pattern_stmt, pattern_stmt_info);
STMT_VINFO_DATA_REF (pattern_stmt_info)
= STMT_VINFO_DATA_REF (stmt_vinfo);
......@@ -3382,15 +3364,13 @@ vect_mark_pattern_stmts (gimple *orig_stmt, gimple *pattern_stmt,
{
stmt_vec_info pattern_stmt_info, def_stmt_info;
stmt_vec_info orig_stmt_info = vinfo_for_stmt (orig_stmt);
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (orig_stmt_info);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (orig_stmt_info);
vec_info *vinfo = orig_stmt_info->vinfo;
gimple *def_stmt;
pattern_stmt_info = vinfo_for_stmt (pattern_stmt);
if (pattern_stmt_info == NULL)
{
pattern_stmt_info = new_stmt_vec_info (pattern_stmt, loop_vinfo,
bb_vinfo);
pattern_stmt_info = new_stmt_vec_info (pattern_stmt, vinfo);
set_vinfo_for_stmt (pattern_stmt, pattern_stmt_info);
}
gimple_set_bb (pattern_stmt, gimple_bb (orig_stmt));
......@@ -3413,8 +3393,7 @@ vect_mark_pattern_stmts (gimple *orig_stmt, gimple *pattern_stmt,
def_stmt_info = vinfo_for_stmt (def_stmt);
if (def_stmt_info == NULL)
{
def_stmt_info = new_stmt_vec_info (def_stmt, loop_vinfo,
bb_vinfo);
def_stmt_info = new_stmt_vec_info (def_stmt, vinfo);
set_vinfo_for_stmt (def_stmt, def_stmt_info);
}
gimple_set_bb (def_stmt, gimple_bb (orig_stmt));
......@@ -3629,7 +3608,7 @@ vect_pattern_recog_1 (vect_recog_func_ptr vect_recog_func,
be recorded in S3. */
void
vect_pattern_recog (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
vect_pattern_recog (vec_info *vinfo)
{
struct loop *loop;
basic_block *bbs;
......@@ -3644,7 +3623,7 @@ vect_pattern_recog (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
dump_printf_loc (MSG_NOTE, vect_location,
"=== vect_pattern_recog ===\n");
if (loop_vinfo)
if (loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo))
{
loop = LOOP_VINFO_LOOP (loop_vinfo);
bbs = LOOP_VINFO_BBS (loop_vinfo);
......@@ -3652,7 +3631,7 @@ vect_pattern_recog (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
}
else
{
bbs = &BB_VINFO_BB (bb_vinfo);
bbs = &as_a <bb_vec_info> (vinfo)->bb;
nbbs = 1;
}
......@@ -3663,7 +3642,8 @@ vect_pattern_recog (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
basic_block bb = bbs[i];
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
{
if (bb_vinfo && (stmt = gsi_stmt (si))
if (is_a <bb_vec_info> (vinfo)
&& (stmt = gsi_stmt (si))
&& vinfo_for_stmt (stmt)
&& !STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (stmt)))
continue;
......
gcc/tree-vect-slp.c
......@@ -211,7 +211,7 @@ vect_get_place_in_interleaving_chain (gimple *stmt, gimple *first_stmt)
operation return 1, if everything is ok return 0. */
static int
vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
vect_get_and_check_slp_defs (vec_info *vinfo,
gimple *stmt, unsigned stmt_num,
vec<slp_oprnd_info> *oprnds_info)
{
......@@ -229,8 +229,8 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
bool first = stmt_num == 0;
bool second = stmt_num == 1;
if (loop_vinfo)
loop = LOOP_VINFO_LOOP (loop_vinfo);
if (is_a <loop_vec_info> (vinfo))
loop = LOOP_VINFO_LOOP (as_a <loop_vec_info> (vinfo));
if (is_gimple_call (stmt))
{
......@@ -270,7 +270,7 @@ again:
oprnd_info = (*oprnds_info)[i];
if (!vect_is_simple_use (oprnd, NULL, loop_vinfo, bb_vinfo, &def_stmt,
if (!vect_is_simple_use (oprnd, NULL, vinfo, &def_stmt,
&def, &dt))
{
if (dump_enabled_p ())
......@@ -288,8 +288,10 @@ again:
from the pattern. Check that all the stmts of the node are in the
pattern. */
if (def_stmt && gimple_bb (def_stmt)
&& ((loop && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt)))
|| (!loop && gimple_bb (def_stmt) == BB_VINFO_BB (bb_vinfo)
&& ((is_a <loop_vec_info> (vinfo)
&& flow_bb_inside_loop_p (loop, gimple_bb (def_stmt)))
|| (is_a <bb_vec_info> (vinfo)
&& gimple_bb (def_stmt) == as_a <bb_vec_info> (vinfo)->bb
&& gimple_code (def_stmt) != GIMPLE_PHI))
&& vinfo_for_stmt (def_stmt)
&& STMT_VINFO_IN_PATTERN_P (vinfo_for_stmt (def_stmt))
......@@ -448,7 +450,7 @@ again:
carried out or the stmts will never be vectorized by SLP. */
static bool
vect_build_slp_tree_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
vect_build_slp_tree_1 (vec_info *vinfo,
vec<gimple *> stmts, unsigned int group_size,
unsigned nops, unsigned int *max_nunits,
unsigned int vectorization_factor, bool *matches,
......@@ -551,7 +553,7 @@ vect_build_slp_tree_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
/* If populating the vector type requires unrolling then fail
before adjusting *max_nunits for basic-block vectorization. */
if (bb_vinfo
if (is_a <bb_vec_info> (vinfo)
&& TYPE_VECTOR_SUBPARTS (vectype) > group_size)
{
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -566,7 +568,7 @@ vect_build_slp_tree_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
if (*max_nunits < TYPE_VECTOR_SUBPARTS (vectype))
{
*max_nunits = TYPE_VECTOR_SUBPARTS (vectype);
if (bb_vinfo)
if (is_a <bb_vec_info> (vinfo))
vectorization_factor = *max_nunits;
}
......@@ -745,7 +747,7 @@ vect_build_slp_tree_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
greater than the SLP group size. */
unsigned ncopies
= vectorization_factor / TYPE_VECTOR_SUBPARTS (vectype);
if (loop_vinfo
if (is_a <loop_vec_info> (vinfo)
&& GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)) == stmt
&& ((GROUP_SIZE (vinfo_for_stmt (stmt))
- GROUP_GAP (vinfo_for_stmt (stmt)))
......@@ -907,7 +909,7 @@ vect_build_slp_tree_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
was found. */
static bool
vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
vect_build_slp_tree (vec_info *vinfo,
slp_tree *node, unsigned int group_size,
unsigned int *max_nunits,
vec<slp_tree> *loads,
......@@ -933,7 +935,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
return false;
bool two_operators = false;
if (!vect_build_slp_tree_1 (loop_vinfo, bb_vinfo,
if (!vect_build_slp_tree_1 (vinfo,
SLP_TREE_SCALAR_STMTS (*node), group_size, nops,
max_nunits, vectorization_factor, matches,
&two_operators))
......@@ -953,8 +955,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
slp_oprnd_info oprnd_info;
FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (*node), i, stmt)
{
switch (vect_get_and_check_slp_defs (loop_vinfo, bb_vinfo,
stmt, i, &oprnds_info))
switch (vect_get_and_check_slp_defs (vinfo, stmt, i, &oprnds_info))
{
case 0:
break;
......@@ -999,7 +1000,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
return false;
}
if (vect_build_slp_tree (loop_vinfo, bb_vinfo, &child,
if (vect_build_slp_tree (vinfo, &child,
group_size, max_nunits, loads,
vectorization_factor, matches,
npermutes, &this_tree_size, max_tree_size))
......@@ -1046,7 +1047,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
fails (or we don't try permutation below). Ideally we'd
even compute a permutation that will end up with the maximum
SLP tree size... */
if (bb_vinfo
if (is_a <bb_vec_info> (vinfo)
&& !matches[0]
/* ??? Rejecting patterns this way doesn't work. We'd have to
do extra work to cancel the pattern so the uses see the
......@@ -1113,7 +1114,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
dump_printf (MSG_NOTE, "\n");
/* And try again with scratch 'matches' ... */
bool *tem = XALLOCAVEC (bool, group_size);
if (vect_build_slp_tree (loop_vinfo, bb_vinfo, &child,
if (vect_build_slp_tree (vinfo, &child,
group_size, max_nunits, loads,
vectorization_factor,
tem, npermutes, &this_tree_size,
......@@ -1542,9 +1543,7 @@ vect_analyze_slp_cost_1 (slp_instance instance, slp_tree node,
enum vect_def_type dt;
if (!op || op == lhs)
continue;
if (vect_is_simple_use (op, NULL, STMT_VINFO_LOOP_VINFO (stmt_info),
STMT_VINFO_BB_VINFO (stmt_info),
&def_stmt, &def, &dt))
if (vect_is_simple_use (op, NULL, stmt_info->vinfo, &def_stmt, &def, &dt))
{
/* Without looking at the actual initializer a vector of
constants can be implemented as load from the constant pool.
......@@ -1632,7 +1631,7 @@ vect_analyze_slp_cost (slp_instance instance, void *data)
Return FALSE if it's impossible to SLP any stmt in the loop. */
static bool
vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
vect_analyze_slp_instance (vec_info *vinfo,
gimple *stmt, unsigned max_tree_size)
{
slp_instance new_instance;
......@@ -1657,7 +1656,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
}
else
{
gcc_assert (loop_vinfo);
gcc_assert (is_a <loop_vec_info> (vinfo));
vectype = STMT_VINFO_VECTYPE (vinfo_for_stmt (stmt));
}
......@@ -1665,9 +1664,9 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
}
else
{
gcc_assert (loop_vinfo);
gcc_assert (is_a <loop_vec_info> (vinfo));
vectype = STMT_VINFO_VECTYPE (vinfo_for_stmt (stmt));
group_size = LOOP_VINFO_REDUCTIONS (loop_vinfo).length ();
group_size = as_a <loop_vec_info> (vinfo)->reductions.length ();
}
if (!vectype)
......@@ -1684,14 +1683,14 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
}
nunits = TYPE_VECTOR_SUBPARTS (vectype);
if (loop_vinfo)
vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
if (is_a <loop_vec_info> (vinfo))
vectorization_factor = as_a <loop_vec_info> (vinfo)->vectorization_factor;
else
vectorization_factor = nunits;
/* Calculate the unrolling factor. */
unrolling_factor = least_common_multiple (nunits, group_size) / group_size;
if (unrolling_factor != 1 && !loop_vinfo)
if (unrolling_factor != 1 && is_a <bb_vec_info> (vinfo))
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -1726,7 +1725,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
else
{
/* Collect reduction statements. */
vec<gimple *> reductions = LOOP_VINFO_REDUCTIONS (loop_vinfo);
vec<gimple *> reductions = as_a <loop_vec_info> (vinfo)->reductions;
for (i = 0; reductions.iterate (i, &next); i++)
scalar_stmts.safe_push (next);
}
......@@ -1738,7 +1737,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
/* Build the tree for the SLP instance. */
bool *matches = XALLOCAVEC (bool, group_size);
unsigned npermutes = 0;
if (vect_build_slp_tree (loop_vinfo, bb_vinfo, &node, group_size,
if (vect_build_slp_tree (vinfo, &node, group_size,
&max_nunits, &loads,
vectorization_factor, matches, &npermutes, NULL,
max_tree_size))
......@@ -1748,7 +1747,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
unrolling_factor = least_common_multiple (max_nunits, group_size)
/ group_size;
if (unrolling_factor != 1 && !loop_vinfo)
if (unrolling_factor != 1 && is_a <bb_vec_info> (vinfo))
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -1819,11 +1818,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
}
}
if (loop_vinfo)
LOOP_VINFO_SLP_INSTANCES (loop_vinfo).safe_push (new_instance);
else
BB_VINFO_SLP_INSTANCES (bb_vinfo).safe_push (new_instance);
vinfo->slp_instances.safe_push (new_instance);
if (dump_enabled_p ())
vect_print_slp_tree (MSG_NOTE, node);
......@@ -1844,39 +1839,27 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
trees of packed scalar stmts if SLP is possible. */
bool
vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
unsigned max_tree_size)
vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
{
unsigned int i;
vec<gimple *> grouped_stores;
vec<gimple *> reductions = vNULL;
vec<gimple *> reduc_chains = vNULL;
gimple *first_element;
bool ok = false;
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location, "=== vect_analyze_slp ===\n");
if (loop_vinfo)
{
grouped_stores = LOOP_VINFO_GROUPED_STORES (loop_vinfo);
reduc_chains = LOOP_VINFO_REDUCTION_CHAINS (loop_vinfo);
reductions = LOOP_VINFO_REDUCTIONS (loop_vinfo);
}
else
grouped_stores = BB_VINFO_GROUPED_STORES (bb_vinfo);
/* Find SLP sequences starting from groups of grouped stores. */
FOR_EACH_VEC_ELT (grouped_stores, i, first_element)
if (vect_analyze_slp_instance (loop_vinfo, bb_vinfo, first_element,
max_tree_size))
FOR_EACH_VEC_ELT (vinfo->grouped_stores, i, first_element)
if (vect_analyze_slp_instance (vinfo, first_element, max_tree_size))
ok = true;
if (reduc_chains.length () > 0)
if (loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo))
{
if (loop_vinfo->reduction_chains.length () > 0)
{
/* Find SLP sequences starting from reduction chains. */
FOR_EACH_VEC_ELT (reduc_chains, i, first_element)
if (vect_analyze_slp_instance (loop_vinfo, bb_vinfo, first_element,
FOR_EACH_VEC_ELT (loop_vinfo->reduction_chains, i, first_element)
if (vect_analyze_slp_instance (vinfo, first_element,
max_tree_size))
ok = true;
else
......@@ -1888,10 +1871,11 @@ vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
}
/* Find SLP sequences starting from groups of reductions. */
if (reductions.length () > 1
&& vect_analyze_slp_instance (loop_vinfo, bb_vinfo, reductions[0],
if (loop_vinfo->reductions.length () > 1
&& vect_analyze_slp_instance (vinfo, loop_vinfo->reductions[0],
max_tree_size))
ok = true;
}
return true;
}
......@@ -2110,13 +2094,14 @@ new_bb_vec_info (basic_block bb)
gimple_stmt_iterator gsi;
res = (bb_vec_info) xcalloc (1, sizeof (struct _bb_vec_info));
res->kind = vec_info::bb;
BB_VINFO_BB (res) = bb;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple *stmt = gsi_stmt (gsi);
gimple_set_uid (stmt, 0);
set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, NULL, res));
set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res));
}
BB_VINFO_GROUPED_STORES (res).create (10);
......@@ -2155,7 +2140,7 @@ destroy_bb_vec_info (bb_vec_info bb_vinfo)
free_stmt_vec_info (stmt);
}
vect_destroy_datarefs (NULL, bb_vinfo);
vect_destroy_datarefs (bb_vinfo);
free_dependence_relations (BB_VINFO_DDRS (bb_vinfo));
BB_VINFO_GROUPED_STORES (bb_vinfo).release ();
slp_instances = BB_VINFO_SLP_INSTANCES (bb_vinfo);
......@@ -2367,7 +2352,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
if (!bb_vinfo)
return NULL;
if (!vect_analyze_data_refs (NULL, bb_vinfo, &min_vf, &n_stmts))
if (!vect_analyze_data_refs (bb_vinfo, &min_vf, &n_stmts))
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -2389,7 +2374,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
return NULL;
}
if (!vect_analyze_data_ref_accesses (NULL, bb_vinfo))
if (!vect_analyze_data_ref_accesses (bb_vinfo))
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -2400,9 +2385,9 @@ vect_slp_analyze_bb_1 (basic_block bb)
return NULL;
}
vect_pattern_recog (NULL, bb_vinfo);
vect_pattern_recog (bb_vinfo);
if (!vect_analyze_data_refs_alignment (NULL, bb_vinfo))
if (!vect_analyze_data_refs_alignment (bb_vinfo))
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -2415,7 +2400,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
/* Check the SLP opportunities in the basic block, analyze and build SLP
trees. */
if (!vect_analyze_slp (NULL, bb_vinfo, n_stmts))
if (!vect_analyze_slp (bb_vinfo, n_stmts))
{
if (dump_enabled_p ())
{
......@@ -2463,7 +2448,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
return NULL;
}
if (!vect_verify_datarefs_alignment (NULL, bb_vinfo))
if (!vect_verify_datarefs_alignment (bb_vinfo))
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -3480,23 +3465,18 @@ vect_remove_slp_scalar_calls (slp_tree node)
/* Generate vector code for all SLP instances in the loop/basic block. */
bool
vect_schedule_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
vect_schedule_slp (vec_info *vinfo)
{
vec<slp_instance> slp_instances;
slp_instance instance;
unsigned int i, vf;
bool is_store = false;
if (loop_vinfo)
{
slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo);
vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
}
slp_instances = vinfo->slp_instances;
if (is_a <loop_vec_info> (vinfo))
vf = as_a <loop_vec_info> (vinfo)->vectorization_factor;
else
{
slp_instances = BB_VINFO_SLP_INSTANCES (bb_vinfo);
vf = 1;
}
FOR_EACH_VEC_ELT (slp_instances, i, instance)
{
......@@ -3522,7 +3502,7 @@ vect_schedule_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
??? For BB vectorization we can as well remove scalar
stmts starting from the SLP tree root if they have no
uses. */
if (loop_vinfo)
if (is_a <loop_vec_info> (vinfo))
vect_remove_slp_scalar_calls (root);
for (j = 0; SLP_TREE_SCALAR_STMTS (root).iterate (j, &store)
......@@ -3578,7 +3558,7 @@ vect_slp_transform_bb (basic_block bb)
/* Schedule all the SLP instances when the first SLP stmt is reached. */
if (STMT_SLP_TYPE (stmt_info))
{
vect_schedule_slp (NULL, bb_vinfo);
vect_schedule_slp (bb_vinfo);
break;
}
}
......
gcc/tree-vect-stmts.c
......@@ -102,19 +102,8 @@ record_stmt_cost (stmt_vector_for_cost *body_cost_vec, int count,
}
else
{
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
void *target_cost_data;
if (loop_vinfo)
target_cost_data = LOOP_VINFO_TARGET_COST_DATA (loop_vinfo);
else
target_cost_data = BB_VINFO_TARGET_COST_DATA (bb_vinfo);
return add_stmt_cost (target_cost_data, count, kind, stmt_info,
misalign, where);
}
return add_stmt_cost (stmt_info->vinfo->target_cost_data,
count, kind, stmt_info, misalign, where);
}
/* Return a variable of type ELEM_TYPE[NELEMS]. */
......@@ -470,7 +459,7 @@ process_use (gimple *stmt, tree use, loop_vec_info loop_vinfo, bool live_p,
if (!force && !exist_non_indexing_operands_for_use_p (use, stmt))
return true;
if (!vect_is_simple_use (use, stmt, loop_vinfo, NULL, &def_stmt, &def, &dt))
if (!vect_is_simple_use (use, stmt, loop_vinfo, &def_stmt, &def, &dt))
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
......@@ -1375,7 +1364,7 @@ vect_get_vec_def_for_operand (tree op, gimple *stmt, tree *scalar_def)
dump_printf (MSG_NOTE, "\n");
}
is_simple_use = vect_is_simple_use (op, stmt, loop_vinfo, NULL,
is_simple_use = vect_is_simple_use (op, stmt, loop_vinfo,
&def_stmt, &def, &dt);
gcc_assert (is_simple_use);
if (dump_enabled_p ())
......@@ -1651,8 +1640,7 @@ vect_finish_stmt_generation (gimple *stmt, gimple *vec_stmt,
gimple_stmt_iterator *gsi)
{
stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
vec_info *vinfo = stmt_info->vinfo;
gcc_assert (gimple_code (stmt) != GIMPLE_LABEL);
......@@ -1684,8 +1672,7 @@ vect_finish_stmt_generation (gimple *stmt, gimple *vec_stmt,
}
gsi_insert_before (gsi, vec_stmt, GSI_SAME_STMT);
set_vinfo_for_stmt (vec_stmt, new_stmt_vec_info (vec_stmt, loop_vinfo,
bb_vinfo));
set_vinfo_for_stmt (vec_stmt, new_stmt_vec_info (vec_stmt, vinfo));
if (dump_enabled_p ())
{
......@@ -1814,7 +1801,7 @@ vectorizable_mask_load_store (gimple *stmt, gimple_stmt_iterator *gsi,
gather_decl = vect_check_gather_scatter (stmt, loop_vinfo, &gather_base,
&gather_off, &gather_scale);
gcc_assert (gather_decl);
if (!vect_is_simple_use_1 (gather_off, NULL, loop_vinfo, NULL,
if (!vect_is_simple_use_1 (gather_off, NULL, loop_vinfo,
&def_stmt, &def, &gather_dt,
&gather_off_vectype))
{
......@@ -1846,14 +1833,14 @@ vectorizable_mask_load_store (gimple *stmt, gimple_stmt_iterator *gsi,
if (TREE_CODE (mask) != SSA_NAME)
return false;
if (!vect_is_simple_use (mask, stmt, loop_vinfo, NULL,
if (!vect_is_simple_use (mask, stmt, loop_vinfo,
&def_stmt, &def, &dt))
return false;
if (is_store)
{
tree rhs = gimple_call_arg (stmt, 3);
if (!vect_is_simple_use (rhs, stmt, loop_vinfo, NULL,
if (!vect_is_simple_use (rhs, stmt, loop_vinfo,
&def_stmt, &def, &dt))
return false;
}
......@@ -1971,7 +1958,7 @@ vectorizable_mask_load_store (gimple *stmt, gimple_stmt_iterator *gsi,
vec_mask = vect_get_vec_def_for_operand (mask, stmt, NULL);
else
{
vect_is_simple_use (vec_mask, NULL, loop_vinfo, NULL,
vect_is_simple_use (vec_mask, NULL, loop_vinfo,
&def_stmt, &def, &dt);
vec_mask = vect_get_vec_def_for_stmt_copy (dt, vec_mask);
}
......@@ -2068,10 +2055,10 @@ vectorizable_mask_load_store (gimple *stmt, gimple_stmt_iterator *gsi,
}
else
{
vect_is_simple_use (vec_rhs, NULL, loop_vinfo, NULL, &def_stmt,
vect_is_simple_use (vec_rhs, NULL, loop_vinfo, &def_stmt,
&def, &dt);
vec_rhs = vect_get_vec_def_for_stmt_copy (dt, vec_rhs);
vect_is_simple_use (vec_mask, NULL, loop_vinfo, NULL, &def_stmt,
vect_is_simple_use (vec_mask, NULL, loop_vinfo, &def_stmt,
&def, &dt);
vec_mask = vect_get_vec_def_for_stmt_copy (dt, vec_mask);
dataref_ptr = bump_vector_ptr (dataref_ptr, ptr_incr, gsi, stmt,
......@@ -2121,7 +2108,7 @@ vectorizable_mask_load_store (gimple *stmt, gimple_stmt_iterator *gsi,
}
else
{
vect_is_simple_use (vec_mask, NULL, loop_vinfo, NULL, &def_stmt,
vect_is_simple_use (vec_mask, NULL, loop_vinfo, &def_stmt,
&def, &dt);
vec_mask = vect_get_vec_def_for_stmt_copy (dt, vec_mask);
dataref_ptr = bump_vector_ptr (dataref_ptr, ptr_incr, gsi, stmt,
......@@ -2192,6 +2179,7 @@ vectorizable_call (gimple *gs, gimple_stmt_iterator *gsi, gimple **vec_stmt,
int nunits_out;
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
vec_info *vinfo = stmt_info->vinfo;
tree fndecl, new_temp, def, rhs_type;
gimple *def_stmt;
enum vect_def_type dt[3]
......@@ -2265,7 +2253,7 @@ vectorizable_call (gimple *gs, gimple_stmt_iterator *gsi, gimple **vec_stmt,
if (!rhs_type)
rhs_type = TREE_TYPE (op);
if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (op, stmt, vinfo,
&def_stmt, &def, &dt[i], &opvectype))
{
if (dump_enabled_p ())
......@@ -2715,6 +2703,7 @@ vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi,
unsigned int nunits;
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
vec_info *vinfo = stmt_info->vinfo;
struct loop *loop = loop_vinfo ? LOOP_VINFO_LOOP (loop_vinfo) : NULL;
tree fndecl, new_temp, def;
gimple *def_stmt;
......@@ -2779,7 +2768,7 @@ vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi,
thisarginfo.simd_lane_linear = false;
op = gimple_call_arg (stmt, i);
if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (op, stmt, vinfo,
&def_stmt, &def, &thisarginfo.dt,
&thisarginfo.vectype)
|| thisarginfo.dt == vect_uninitialized_def)
......@@ -3139,8 +3128,7 @@ vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi,
tree phi_res = copy_ssa_name (op);
gphi *new_phi = create_phi_node (phi_res, loop->header);
set_vinfo_for_stmt (new_phi,
new_stmt_vec_info (new_phi, loop_vinfo,
NULL));
new_stmt_vec_info (new_phi, loop_vinfo));
add_phi_arg (new_phi, arginfo[i].op,
loop_preheader_edge (loop), UNKNOWN_LOCATION);
enum tree_code code
......@@ -3158,8 +3146,7 @@ vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi,
gimple_stmt_iterator si = gsi_after_labels (loop->header);
gsi_insert_after (&si, new_stmt, GSI_NEW_STMT);
set_vinfo_for_stmt (new_stmt,
new_stmt_vec_info (new_stmt, loop_vinfo,
NULL));
new_stmt_vec_info (new_stmt, loop_vinfo));
add_phi_arg (new_phi, phi_arg, loop_latch_edge (loop),
UNKNOWN_LOCATION);
arginfo[i].op = phi_res;
......@@ -3580,6 +3567,7 @@ vectorizable_conversion (gimple *stmt, gimple_stmt_iterator *gsi,
vec<tree> vec_oprnds1 = vNULL;
tree vop0;
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
vec_info *vinfo = stmt_info->vinfo;
int multi_step_cvt = 0;
vec<tree> vec_dsts = vNULL;
vec<tree> interm_types = vNULL;
......@@ -3642,7 +3630,7 @@ vectorizable_conversion (gimple *stmt, gimple_stmt_iterator *gsi,
}
/* Check the operands of the operation. */
if (!vect_is_simple_use_1 (op0, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (op0, stmt, vinfo,
&def_stmt, &def, &dt[0], &vectype_in))
{
if (dump_enabled_p ())
......@@ -3659,10 +3647,10 @@ vectorizable_conversion (gimple *stmt, gimple_stmt_iterator *gsi,
/* For WIDEN_MULT_EXPR, if OP0 is a constant, use the type of
OP1. */
if (CONSTANT_CLASS_P (op0))
ok = vect_is_simple_use_1 (op1, stmt, loop_vinfo, bb_vinfo,
ok = vect_is_simple_use_1 (op1, stmt, vinfo,
&def_stmt, &def, &dt[1], &vectype_in);
else
ok = vect_is_simple_use (op1, stmt, loop_vinfo, bb_vinfo, &def_stmt,
ok = vect_is_simple_use (op1, stmt, vinfo, &def_stmt,
&def, &dt[1]);
if (!ok)
......@@ -4150,6 +4138,7 @@ vectorizable_assignment (gimple *stmt, gimple_stmt_iterator *gsi,
vec<tree> vec_oprnds = vNULL;
tree vop;
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
vec_info *vinfo = stmt_info->vinfo;
gimple *new_stmt = NULL;
stmt_vec_info prev_stmt_info = NULL;
enum tree_code code;
......@@ -4193,7 +4182,7 @@ vectorizable_assignment (gimple *stmt, gimple_stmt_iterator *gsi,
gcc_assert (ncopies >= 1);
if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (op, stmt, vinfo,
&def_stmt, &def, &dt[0], &vectype_in))
{
if (dump_enabled_p ())
......@@ -4365,6 +4354,7 @@ vectorizable_shift (gimple *stmt, gimple_stmt_iterator *gsi,
unsigned int k;
bool scalar_shift_arg = true;
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
vec_info *vinfo = stmt_info->vinfo;
int vf;
if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
......@@ -4398,7 +4388,7 @@ vectorizable_shift (gimple *stmt, gimple_stmt_iterator *gsi,
}
op0 = gimple_assign_rhs1 (stmt);
if (!vect_is_simple_use_1 (op0, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (op0, stmt, vinfo,
&def_stmt, &def, &dt[0], &vectype))
{
if (dump_enabled_p ())
......@@ -4426,7 +4416,7 @@ vectorizable_shift (gimple *stmt, gimple_stmt_iterator *gsi,
return false;
op1 = gimple_assign_rhs2 (stmt);
if (!vect_is_simple_use_1 (op1, stmt, loop_vinfo, bb_vinfo, &def_stmt,
if (!vect_is_simple_use_1 (op1, stmt, vinfo, &def_stmt,
&def, &dt[1], &op1_vectype))
{
if (dump_enabled_p ())
......@@ -4728,6 +4718,7 @@ vectorizable_operation (gimple *stmt, gimple_stmt_iterator *gsi,
vec<tree> vec_oprnds2 = vNULL;
tree vop0, vop1, vop2;
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
vec_info *vinfo = stmt_info->vinfo;
int vf;
if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
......@@ -4780,7 +4771,7 @@ vectorizable_operation (gimple *stmt, gimple_stmt_iterator *gsi,
}
op0 = gimple_assign_rhs1 (stmt);
if (!vect_is_simple_use_1 (op0, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (op0, stmt, vinfo,
&def_stmt, &def, &dt[0], &vectype))
{
if (dump_enabled_p ())
......@@ -4816,7 +4807,7 @@ vectorizable_operation (gimple *stmt, gimple_stmt_iterator *gsi,
if (op_type == binary_op || op_type == ternary_op)
{
op1 = gimple_assign_rhs2 (stmt);
if (!vect_is_simple_use (op1, stmt, loop_vinfo, bb_vinfo, &def_stmt,
if (!vect_is_simple_use (op1, stmt, vinfo, &def_stmt,
&def, &dt[1]))
{
if (dump_enabled_p ())
......@@ -4828,7 +4819,7 @@ vectorizable_operation (gimple *stmt, gimple_stmt_iterator *gsi,
if (op_type == ternary_op)
{
op2 = gimple_assign_rhs3 (stmt);
if (!vect_is_simple_use (op2, stmt, loop_vinfo, bb_vinfo, &def_stmt,
if (!vect_is_simple_use (op2, stmt, vinfo, &def_stmt,
&def, &dt[2]))
{
if (dump_enabled_p ())
......@@ -5131,6 +5122,7 @@ vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
bool slp = (slp_node != NULL);
unsigned int vec_num;
bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
vec_info *vinfo = stmt_info->vinfo;
tree aggr_type;
tree scatter_base = NULL_TREE, scatter_off = NULL_TREE;
tree scatter_off_vectype = NULL_TREE, scatter_decl = NULL_TREE;
......@@ -5191,7 +5183,7 @@ vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
}
op = gimple_assign_rhs1 (stmt);
if (!vect_is_simple_use (op, stmt, loop_vinfo, bb_vinfo, &def_stmt,
if (!vect_is_simple_use (op, stmt, vinfo, &def_stmt,
&def, &dt))
{
if (dump_enabled_p ())
......@@ -5282,7 +5274,7 @@ vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
{
gcc_assert (gimple_assign_single_p (next_stmt));
op = gimple_assign_rhs1 (next_stmt);
if (!vect_is_simple_use (op, next_stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use (op, next_stmt, vinfo,
&def_stmt, &def, &dt))
{
if (dump_enabled_p ())
......@@ -5302,7 +5294,7 @@ vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
scatter_decl = vect_check_gather_scatter (stmt, loop_vinfo, &scatter_base,
&scatter_off, &scatter_scale);
gcc_assert (scatter_decl);
if (!vect_is_simple_use_1 (scatter_off, NULL, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (scatter_off, NULL, vinfo,
&def_stmt, &def, &scatter_idx_dt,
&scatter_off_vectype))
{
......@@ -5579,7 +5571,7 @@ vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
loop, &incr_gsi, insert_after,
&offvar, NULL);
incr = gsi_stmt (incr_gsi);
set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo, NULL));
set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo));
stride_step = force_gimple_operand (stride_step, &stmts, true, NULL_TREE);
if (stmts)
......@@ -5628,8 +5620,8 @@ vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
vec_oprnd = vec_oprnds[j];
else
{
vect_is_simple_use (vec_oprnd, NULL, loop_vinfo,
bb_vinfo, &def_stmt, &def, &dt);
vect_is_simple_use (vec_oprnd, NULL, vinfo,
&def_stmt, &def, &dt);
vec_oprnd = vect_get_vec_def_for_stmt_copy (dt, vec_oprnd);
}
}
......@@ -5818,7 +5810,7 @@ vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
for (i = 0; i < group_size; i++)
{
op = oprnds[i];
vect_is_simple_use (op, NULL, loop_vinfo, bb_vinfo, &def_stmt,
vect_is_simple_use (op, NULL, vinfo, &def_stmt,
&def, &dt);
vec_oprnd = vect_get_vec_def_for_stmt_copy (dt, op);
dr_chain[i] = vec_oprnd;
......@@ -6134,6 +6126,7 @@ vectorizable_load (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
tree gather_off_vectype = NULL_TREE, gather_decl = NULL_TREE;
int gather_scale = 1;
enum vect_def_type gather_dt = vect_unknown_def_type;
vec_info *vinfo = stmt_info->vinfo;
if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
return false;
......@@ -6296,7 +6289,7 @@ vectorizable_load (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
gather_decl = vect_check_gather_scatter (stmt, loop_vinfo, &gather_base,
&gather_off, &gather_scale);
gcc_assert (gather_decl);
if (!vect_is_simple_use_1 (gather_off, NULL, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (gather_off, NULL, vinfo,
&def_stmt, &def, &gather_dt,
&gather_off_vectype))
{
......@@ -6602,7 +6595,7 @@ vectorizable_load (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
loop, &incr_gsi, insert_after,
&offvar, NULL);
incr = gsi_stmt (incr_gsi);
set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo, NULL));
set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo));
stride_step = force_gimple_operand (unshare_expr (stride_step),
&stmts, true, NULL_TREE);
......@@ -7146,8 +7139,7 @@ vectorizable_load (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
}
new_stmt = SSA_NAME_DEF_STMT (new_temp);
set_vinfo_for_stmt (new_stmt,
new_stmt_vec_info (new_stmt, loop_vinfo,
bb_vinfo));
new_stmt_vec_info (new_stmt, vinfo));
}
if (negative)
......@@ -7229,8 +7221,8 @@ vectorizable_load (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
condition operands are supportable using vec_is_simple_use. */
static bool
vect_is_simple_cond (tree cond, gimple *stmt, loop_vec_info loop_vinfo,
bb_vec_info bb_vinfo, tree *comp_vectype)
vect_is_simple_cond (tree cond, gimple *stmt, vec_info *vinfo,
tree *comp_vectype)
{
tree lhs, rhs;
tree def;
......@@ -7246,7 +7238,7 @@ vect_is_simple_cond (tree cond, gimple *stmt, loop_vec_info loop_vinfo,
if (TREE_CODE (lhs) == SSA_NAME)
{
gimple *lhs_def_stmt = SSA_NAME_DEF_STMT (lhs);
if (!vect_is_simple_use_1 (lhs, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (lhs, stmt, vinfo,
&lhs_def_stmt, &def, &dt, &vectype1))
return false;
}
......@@ -7257,7 +7249,7 @@ vect_is_simple_cond (tree cond, gimple *stmt, loop_vec_info loop_vinfo,
if (TREE_CODE (rhs) == SSA_NAME)
{
gimple *rhs_def_stmt = SSA_NAME_DEF_STMT (rhs);
if (!vect_is_simple_use_1 (rhs, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use_1 (rhs, stmt, vinfo,
&rhs_def_stmt, &def, &dt, &vectype2))
return false;
}
......@@ -7355,15 +7347,14 @@ vectorizable_condition (gimple *stmt, gimple_stmt_iterator *gsi,
then_clause = gimple_assign_rhs2 (stmt);
else_clause = gimple_assign_rhs3 (stmt);
if (!vect_is_simple_cond (cond_expr, stmt, loop_vinfo, bb_vinfo,
&comp_vectype)
if (!vect_is_simple_cond (cond_expr, stmt, stmt_info->vinfo, &comp_vectype)
|| !comp_vectype)
return false;
if (TREE_CODE (then_clause) == SSA_NAME)
{
gimple *then_def_stmt = SSA_NAME_DEF_STMT (then_clause);
if (!vect_is_simple_use (then_clause, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use (then_clause, stmt, stmt_info->vinfo,
&then_def_stmt, &def, &dt))
return false;
}
......@@ -7375,7 +7366,7 @@ vectorizable_condition (gimple *stmt, gimple_stmt_iterator *gsi,
if (TREE_CODE (else_clause) == SSA_NAME)
{
gimple *else_def_stmt = SSA_NAME_DEF_STMT (else_clause);
if (!vect_is_simple_use (else_clause, stmt, loop_vinfo, bb_vinfo,
if (!vect_is_simple_use (else_clause, stmt, stmt_info->vinfo,
&else_def_stmt, &def, &dt))
return false;
}
......@@ -7442,13 +7433,13 @@ vectorizable_condition (gimple *stmt, gimple_stmt_iterator *gsi,
vect_get_vec_def_for_operand (TREE_OPERAND (cond_expr, 0),
stmt, NULL);
vect_is_simple_use (TREE_OPERAND (cond_expr, 0), stmt,
loop_vinfo, NULL, &gtemp, &def, &dts[0]);
loop_vinfo, &gtemp, &def, &dts[0]);
vec_cond_rhs =
vect_get_vec_def_for_operand (TREE_OPERAND (cond_expr, 1),
stmt, NULL);
vect_is_simple_use (TREE_OPERAND (cond_expr, 1), stmt,
loop_vinfo, NULL, &gtemp, &def, &dts[1]);
loop_vinfo, &gtemp, &def, &dts[1]);
if (reduc_index == 1)
vec_then_clause = reduc_def;
else
......@@ -7456,7 +7447,7 @@ vectorizable_condition (gimple *stmt, gimple_stmt_iterator *gsi,
vec_then_clause = vect_get_vec_def_for_operand (then_clause,
stmt, NULL);
vect_is_simple_use (then_clause, stmt, loop_vinfo,
NULL, &gtemp, &def, &dts[2]);
&gtemp, &def, &dts[2]);
}
if (reduc_index == 2)
vec_else_clause = reduc_def;
......@@ -7465,7 +7456,7 @@ vectorizable_condition (gimple *stmt, gimple_stmt_iterator *gsi,
vec_else_clause = vect_get_vec_def_for_operand (else_clause,
stmt, NULL);
vect_is_simple_use (else_clause, stmt, loop_vinfo,
NULL, &gtemp, &def, &dts[3]);
&gtemp, &def, &dts[3]);
}
}
}
......@@ -7983,16 +7974,14 @@ vect_remove_stores (gimple *first_stmt)
Create and initialize a new stmt_vec_info struct for STMT. */
stmt_vec_info
new_stmt_vec_info (gimple *stmt, loop_vec_info loop_vinfo,
bb_vec_info bb_vinfo)
new_stmt_vec_info (gimple *stmt, vec_info *vinfo)
{
stmt_vec_info res;
res = (stmt_vec_info) xcalloc (1, sizeof (struct _stmt_vec_info));
STMT_VINFO_TYPE (res) = undef_vec_info_type;
STMT_VINFO_STMT (res) = stmt;
STMT_VINFO_LOOP_VINFO (res) = loop_vinfo;
STMT_VINFO_BB_VINFO (res) = bb_vinfo;
res->vinfo = vinfo;
STMT_VINFO_RELEVANT (res) = vect_unused_in_scope;
STMT_VINFO_LIVE_P (res) = false;
STMT_VINFO_VECTYPE (res) = NULL;
......@@ -8222,9 +8211,8 @@ get_same_sized_vectype (tree scalar_type, tree vector_type)
For now, operands defined outside the basic block are not supported. */
bool
vect_is_simple_use (tree operand, gimple *stmt, loop_vec_info loop_vinfo,
bb_vec_info bb_vinfo, gimple **def_stmt,
tree *def, enum vect_def_type *dt)
vect_is_simple_use (tree operand, gimple *stmt, vec_info *vinfo,
gimple **def_stmt, tree *def, enum vect_def_type *dt)
{
*def_stmt = NULL;
*def = NULL_TREE;
......@@ -8274,15 +8262,16 @@ vect_is_simple_use (tree operand, gimple *stmt, loop_vec_info loop_vinfo,
}
basic_block bb = gimple_bb (*def_stmt);
if ((loop_vinfo && !flow_bb_inside_loop_p (LOOP_VINFO_LOOP (loop_vinfo), bb))
|| (bb_vinfo
&& (bb != BB_VINFO_BB (bb_vinfo)
if ((is_a <loop_vec_info> (vinfo)
&& !flow_bb_inside_loop_p (as_a <loop_vec_info> (vinfo)->loop, bb))
|| (is_a <bb_vec_info> (vinfo)
&& (bb != as_a <bb_vec_info> (vinfo)->bb
|| gimple_code (*def_stmt) == GIMPLE_PHI)))
*dt = vect_external_def;
else
{
stmt_vec_info stmt_vinfo = vinfo_for_stmt (*def_stmt);
if (bb_vinfo && !STMT_VINFO_VECTORIZABLE (stmt_vinfo))
if (is_a <bb_vec_info> (vinfo) && !STMT_VINFO_VECTORIZABLE (stmt_vinfo))
*dt = vect_external_def;
else
*dt = STMT_VINFO_DEF_TYPE (stmt_vinfo);
......@@ -8369,12 +8358,11 @@ vect_is_simple_use (tree operand, gimple *stmt, loop_vec_info loop_vinfo,
scalar operand. */
bool
vect_is_simple_use_1 (tree operand, gimple *stmt, loop_vec_info loop_vinfo,
bb_vec_info bb_vinfo, gimple **def_stmt,
vect_is_simple_use_1 (tree operand, gimple *stmt, vec_info *vinfo,
gimple **def_stmt,
tree *def, enum vect_def_type *dt, tree *vectype)
{
if (!vect_is_simple_use (operand, stmt, loop_vinfo, bb_vinfo, def_stmt,
def, dt))
if (!vect_is_simple_use (operand, stmt, vinfo, def_stmt, def, dt))
return false;
/* Now get a vector type if the def is internal, otherwise supply
......
gcc/tree-vectorizer.c
......@@ -329,25 +329,19 @@ shrink_simd_arrays
/* A helper function to free data refs. */
void
vect_destroy_datarefs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
vect_destroy_datarefs (vec_info *vinfo)
{
vec<data_reference_p> datarefs;
struct data_reference *dr;
unsigned int i;
if (loop_vinfo)
datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
else
datarefs = BB_VINFO_DATAREFS (bb_vinfo);
FOR_EACH_VEC_ELT (datarefs, i, dr)
FOR_EACH_VEC_ELT (vinfo->datarefs, i, dr)
if (dr->aux)
{
free (dr->aux);
dr->aux = NULL;
}
free_data_refs (datarefs);
free_data_refs (vinfo->datarefs);
}
......
gcc/tree-vectorizer.h
......@@ -230,11 +230,51 @@ peel_info_hasher::equal (const _vect_peel_info *a, const _vect_peel_info *b)
return (a->npeel == b->npeel);
}
/* Vectorizer state common between loop and basic-block vectorization. */
struct vec_info {
enum { bb, loop } kind;
/* All SLP instances. */
vec<slp_instance> slp_instances;
/* All data references. */
vec<data_reference_p> datarefs;
/* All data dependences. */
vec<ddr_p> ddrs;
/* All interleaving chains of stores, represented by the first
stmt in the chain. */
vec<gimple *> grouped_stores;
/* Cost data used by the target cost model. */
void *target_cost_data;
};
struct _loop_vec_info;
struct _bb_vec_info;
template<>
template<>
inline bool
is_a_helper <_loop_vec_info *>::test (vec_info *i)
{
return i->kind == vec_info::loop;
}
template<>
template<>
inline bool
is_a_helper <_bb_vec_info *>::test (vec_info *i)
{
return i->kind == vec_info::bb;
}
/*-----------------------------------------------------------------*/
/* Info on vectorized loops. */
/*-----------------------------------------------------------------*/
typedef struct _loop_vec_info {
typedef struct _loop_vec_info : public vec_info {
/* The loop to which this info struct refers to. */
struct loop *loop;
......@@ -286,12 +326,6 @@ typedef struct _loop_vec_info {
/* The loop nest in which the data dependences are computed. */
vec<loop_p> loop_nest;
/* All data references in the loop. */
vec<data_reference_p> datarefs;
/* All data dependences in the loop. */
vec<ddr_p> ddrs;
/* Data Dependence Relations defining address ranges that are candidates
for a run-time aliasing check. */
vec<ddr_p> may_alias_ddrs;
......@@ -304,14 +338,6 @@ typedef struct _loop_vec_info {
runtime (loop versioning) misalignment check. */
vec<gimple *> may_misalign_stmts;
/* All interleaving chains of stores in the loop, represented by the first
stmt in the chain. */
vec<gimple *> grouped_stores;
/* All SLP instances in the loop. This is a subset of the set of GROUP_STORES
of the loop. */
vec<slp_instance> slp_instances;
/* The unrolling factor needed to SLP the loop. In case of that pure SLP is
applied to the loop, i.e., no unrolling is needed, this is 1. */
unsigned slp_unrolling_factor;
......@@ -332,9 +358,6 @@ typedef struct _loop_vec_info {
/* Cost of a single scalar iteration. */
int single_scalar_iteration_cost;
/* Cost data used by the target cost model. */
void *target_cost_data;
/* When we have grouped data accesses with gaps, we may introduce invalid
memory accesses. We peel the last iteration of the loop to prevent
this. */
......@@ -434,26 +457,9 @@ nested_in_vect_loop_p (struct loop *loop, gimple *stmt)
&& (loop->inner == (gimple_bb (stmt))->loop_father));
}
typedef struct _bb_vec_info {
typedef struct _bb_vec_info : public vec_info
{
basic_block bb;
/* All interleaving chains of stores in the basic block, represented by the
first stmt in the chain. */
vec<gimple *> grouped_stores;
/* All SLP instances in the basic block. This is a subset of the set of
GROUP_STORES of the basic block. */
vec<slp_instance> slp_instances;
/* All data references in the basic block. */
vec<data_reference_p> datarefs;
/* All data dependences in the basic block. */
vec<ddr_p> ddrs;
/* Cost data used by the target cost model. */
void *target_cost_data;
} *bb_vec_info;
#define BB_VINFO_BB(B) (B)->bb
......@@ -551,8 +557,8 @@ typedef struct _stmt_vec_info {
/* The stmt to which this info struct refers to. */
gimple *stmt;
/* The loop_vec_info with respect to which STMT is vectorized. */
loop_vec_info loop_vinfo;
/* The vec_info with respect to which STMT is vectorized. */
vec_info *vinfo;
/* The vector type to be used for the LHS of this statement. */
tree vectype;
......@@ -639,9 +645,6 @@ typedef struct _stmt_vec_info {
indicates whether the stmt needs to be vectorized. */
enum vect_relevant relevant;
/* The bb_vec_info with respect to which STMT is vectorized. */
bb_vec_info bb_vinfo;
/* Is this statement vectorizable or should it be skipped in (partial)
vectorization. */
bool vectorizable;
......@@ -659,8 +662,20 @@ typedef struct _stmt_vec_info {
/* Access Functions. */
#define STMT_VINFO_TYPE(S) (S)->type
#define STMT_VINFO_STMT(S) (S)->stmt
#define STMT_VINFO_LOOP_VINFO(S) (S)->loop_vinfo
#define STMT_VINFO_BB_VINFO(S) (S)->bb_vinfo
inline loop_vec_info
STMT_VINFO_LOOP_VINFO (stmt_vec_info stmt_vinfo)
{
if (loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (stmt_vinfo->vinfo))
return loop_vinfo;
return NULL;
}
inline bb_vec_info
STMT_VINFO_BB_VINFO (stmt_vec_info stmt_vinfo)
{
if (bb_vec_info bb_vinfo = dyn_cast <bb_vec_info> (stmt_vinfo->vinfo))
return bb_vinfo;
return NULL;
}
#define STMT_VINFO_RELEVANT(S) (S)->relevant
#define STMT_VINFO_LIVE_P(S) (S)->live
#define STMT_VINFO_VECTYPE(S) (S)->vectype
......@@ -996,11 +1011,9 @@ extern bool vect_can_advance_ivs_p (loop_vec_info);
extern unsigned int current_vector_size;
extern tree get_vectype_for_scalar_type (tree);
extern tree get_same_sized_vectype (tree, tree);
extern bool vect_is_simple_use (tree, gimple *, loop_vec_info,
bb_vec_info, gimple **,
extern bool vect_is_simple_use (tree, gimple *, vec_info *, gimple **,
tree *, enum vect_def_type *);
extern bool vect_is_simple_use_1 (tree, gimple *, loop_vec_info,
bb_vec_info, gimple **,
extern bool vect_is_simple_use_1 (tree, gimple *, vec_info *, gimple **,
tree *, enum vect_def_type *, tree *);
extern bool supportable_widening_operation (enum tree_code, gimple *, tree,
tree, enum tree_code *,
......@@ -1009,8 +1022,7 @@ extern bool supportable_widening_operation (enum tree_code, gimple *, tree,
extern bool supportable_narrowing_operation (enum tree_code, tree, tree,
enum tree_code *,
int *, vec<tree> *);
extern stmt_vec_info new_stmt_vec_info (gimple *stmt, loop_vec_info,
bb_vec_info);
extern stmt_vec_info new_stmt_vec_info (gimple *stmt, vec_info *);
extern void free_stmt_vec_info (gimple *stmt);
extern tree vectorizable_function (gcall *, tree, tree);
extern void vect_model_simple_cost (stmt_vec_info, int, enum vect_def_type *,
......@@ -1060,14 +1072,13 @@ extern tree vect_get_smallest_scalar_type (gimple *, HOST_WIDE_INT *,
extern bool vect_analyze_data_ref_dependences (loop_vec_info, int *);
extern bool vect_slp_analyze_data_ref_dependences (bb_vec_info);
extern bool vect_enhance_data_refs_alignment (loop_vec_info);
extern bool vect_analyze_data_refs_alignment (loop_vec_info, bb_vec_info);
extern bool vect_verify_datarefs_alignment (loop_vec_info, bb_vec_info);
extern bool vect_analyze_data_ref_accesses (loop_vec_info, bb_vec_info);
extern bool vect_analyze_data_refs_alignment (vec_info *);
extern bool vect_verify_datarefs_alignment (vec_info *);
extern bool vect_analyze_data_ref_accesses (vec_info *);
extern bool vect_prune_runtime_alias_test_list (loop_vec_info);
extern tree vect_check_gather_scatter (gimple *, loop_vec_info, tree *, tree *,
int *);
extern bool vect_analyze_data_refs (loop_vec_info, bb_vec_info, int *,
unsigned *);
extern bool vect_analyze_data_refs (vec_info *, int *, unsigned *);
extern tree vect_create_data_ref_ptr (gimple *, tree, struct loop *, tree,
tree *, gimple_stmt_iterator *,
gimple **, bool, bool *,
......@@ -1121,8 +1132,8 @@ extern bool vect_transform_slp_perm_load (slp_tree, vec<tree> ,
slp_instance, bool);
extern bool vect_slp_analyze_operations (vec<slp_instance> slp_instances,
void *);
extern bool vect_schedule_slp (loop_vec_info, bb_vec_info);
extern bool vect_analyze_slp (loop_vec_info, bb_vec_info, unsigned);
extern bool vect_schedule_slp (vec_info *);
extern bool vect_analyze_slp (vec_info *, unsigned);
extern bool vect_make_slp_decision (loop_vec_info);
extern void vect_detect_hybrid_slp (loop_vec_info);
extern void vect_get_slp_defs (vec<tree> , slp_tree,
......@@ -1138,10 +1149,10 @@ extern void vect_slp_transform_bb (basic_block);
in the future. */
typedef gimple *(* vect_recog_func_ptr) (vec<gimple *> *, tree *, tree *);
#define NUM_PATTERNS 13
void vect_pattern_recog (loop_vec_info, bb_vec_info);
void vect_pattern_recog (vec_info *);
/* In tree-vectorizer.c. */
unsigned vectorize_loops (void);
void vect_destroy_datarefs (loop_vec_info, bb_vec_info);
void vect_destroy_datarefs (vec_info *);
#endif /* GCC_TREE_VECTORIZER_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment