On Wed, Jun 27, 2018 at 11:31 AM Richard Sandiford
<richard.sandif...@arm.com> wrote:
>
> Richard Sandiford <richard.sandif...@arm.com> writes:
> > Richard Biener <richard.guent...@gmail.com> writes:
> >> On Mon, Jun 18, 2018 at 5:04 PM Richard Sandiford
> >> <richard.sandif...@arm.com> wrote:
> >>>
> >>> When following the definitions of SSA names, some recognisers
> >>> already cope with statements that have been replaced by patterns.
> >>> This patch makes that happen automatically for users of
> >>> type_conversion_p and vect_get_internal_def. It also adds
> >>> a vect_look_through_pattern helper that can be used directly.
> >>>
> >>> The reason for doing this is that the main patch for PR85694
> >>> makes over_widening handle more general cases. These over-widened
> >>> patterns can still be useful when matching later statements;
> >>> e.g. an overwidened MULT_EXPR could be the input to a DOT_PROD_EXPR.
> >>>
> >>> The patch doesn't do anything with the STMT_VINFO_IN_PATTERN_P checks
> >>> in vect_recog_over_widening_pattern or vect_recog_widen_shift_pattern
> >>> since later patches rewrite them anyway.
> >>>
> >>> Doing this fixed an XFAIL in vect-reduc-dot-u16b.c.
> >>>
> >>> Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install?
> >>
> >> Hmm. It seems to me that *def_stmt for vect_is_simple_use should
> >> eventually be the pattern def given the vectype overload takes the
> >> vectype from the pattern def already but oddly enough the
> >> DEF_TYPE is taken from the non-pattern stmt.
> >>
> >> I wonder which callers look at def_stmt at all (and how...)
> >>
> >> I guess swapping the def_stmt and dt arguments and adding yet another
> >> overload to remove all unused &def_stmt args might this easier to review...
> >>
> >> So - I'm suggesting to change vect_is_simple_use.
> >
> > OK, I'll try that. Might end up being its own mini-series. :-)
>
> Turned out to be simpler than feared. :-)
>
> This patch does the first bit: reorder the arguments to
> vect_is_simple_use so that def_stmt comes last and is optional.
> Many callers can then drop it, making it more obvious which of the
> remaining calls would be affected by the next patch.
>
> Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install?
OK.
Richard.
> Richard
>
>
> 2018-06-27 Richard Sandiford <richard.sandif...@arm.com>
>
> gcc/
> * tree-vectorizer.h (vect_is_simple_use): Move the gimple ** to the
> end and default to null.
> * tree-vect-loop.c (vect_create_epilog_for_reduction)
> (vectorizable_reduction): Update calls accordingly, dropping the
> gimple ** argument if the passed-back statement isn't needed.
> * tree-vect-patterns.c (vect_get_internal_def, type_conversion_p)
> (vect_recog_rotate_pattern): Likewise.
> (vect_recog_mask_conversion_pattern): Likewise.
> * tree-vect-slp.c (vect_get_and_check_slp_defs): Likewise.
> (vect_mask_constant_operand_p): Likewise.
> * tree-vect-stmts.c (is_simple_and_all_uses_invariant, process_use):
> (vect_model_simple_cost, vect_get_vec_def_for_operand): Likewise.
> (get_group_load_store_type, get_load_store_type): Likewise.
> (vect_check_load_store_mask, vect_check_store_rhs): Likewise.
> (vectorizable_call, vectorizable_simd_clone_call): Likewise.
> (vectorizable_conversion, vectorizable_assignment): Likewise.
> (vectorizable_shift, vectorizable_operation): Likewise.
> (vectorizable_store, vect_is_simple_cond): Likewise.
> (vectorizable_condition, vectorizable_comparison): Likewise.
> (get_same_sized_vectype, vect_get_mask_type_for_stmt): Likewise.
> (vect_is_simple_use): Rename the def_stmt argument to def_stmt_out
> and move it to the end. Cope with null def_stmt_outs.
>
> Index: gcc/tree-vectorizer.h
> ===================================================================
> --- gcc/tree-vectorizer.h 2018-06-27 10:27:12.366628072 +0100
> +++ gcc/tree-vectorizer.h 2018-06-27 10:27:31.782458413 +0100
> @@ -1476,10 +1476,10 @@ extern tree get_vectype_for_scalar_type_
> extern tree get_mask_type_for_scalar_type (tree);
> extern tree get_same_sized_vectype (tree, tree);
> extern bool vect_get_loop_mask_type (loop_vec_info);
> -extern bool vect_is_simple_use (tree, vec_info *, gimple **,
> - enum vect_def_type *);
> -extern bool vect_is_simple_use (tree, vec_info *, gimple **,
> - enum vect_def_type *, tree *);
> +extern bool vect_is_simple_use (tree, vec_info *, enum vect_def_type *,
> + gimple ** = NULL);
> +extern bool vect_is_simple_use (tree, vec_info *, enum vect_def_type *,
> + tree *, gimple ** = NULL);
> extern bool supportable_widening_operation (enum tree_code, gimple *, tree,
> tree, enum tree_code *,
> enum tree_code *, int *,
> Index: gcc/tree-vect-loop.c
> ===================================================================
> --- gcc/tree-vect-loop.c 2018-06-27 10:27:09.038657152 +0100
> +++ gcc/tree-vect-loop.c 2018-06-27 10:27:31.782458413 +0100
> @@ -4567,7 +4567,6 @@ vect_create_epilog_for_reduction (vec<tr
> {
> /* Get at the scalar def before the loop, that defines the initial
> value
> of the reduction variable. */
> - gimple *def_stmt;
> initial_def = PHI_ARG_DEF_FROM_EDGE (reduc_def_stmt,
> loop_preheader_edge (loop));
> /* Optimize: if initial_def is for REDUC_MAX smaller than the base
> @@ -4582,7 +4581,7 @@ vect_create_epilog_for_reduction (vec<tr
> || (induc_code == MIN_EXPR
> && tree_int_cst_lt (induc_val, initial_def))))
> induc_val = initial_def;
> - vect_is_simple_use (initial_def, loop_vinfo, &def_stmt,
> &initial_def_dt);
> + vect_is_simple_use (initial_def, loop_vinfo, &initial_def_dt);
> vec_initial_def = get_initial_def_for_reduction (stmt, initial_def,
> &adjustment_def);
> vec_initial_defs.create (1);
> @@ -6391,7 +6390,7 @@ vectorizable_reduction (gimple *stmt, gi
> continue;
>
> is_simple_use = vect_is_simple_use (ops[i], loop_vinfo,
> - &def_stmt, &dts[i], &tem);
> + &dts[i], &tem, &def_stmt);
> dt = dts[i];
> gcc_assert (is_simple_use);
> if (dt == vect_reduction_def)
> @@ -6587,8 +6586,7 @@ vectorizable_reduction (gimple *stmt, gi
> = PHI_ARG_DEF_FROM_EDGE (def_stmt, loop_preheader_edge (loop));
>
> gcc_assert (cond_reduc_val != NULL_TREE);
> - vect_is_simple_use (cond_initial_val, loop_vinfo,
> - &def_stmt, &cond_initial_dt);
> + vect_is_simple_use (cond_initial_val, loop_vinfo, &cond_initial_dt);
> if (cond_initial_dt == vect_constant_def
> && types_compatible_p (TREE_TYPE (cond_initial_val),
> TREE_TYPE (cond_reduc_val)))
> Index: gcc/tree-vect-patterns.c
> ===================================================================
> --- gcc/tree-vect-patterns.c 2018-06-27 10:27:12.366628072 +0100
> +++ gcc/tree-vect-patterns.c 2018-06-27 10:27:31.782458413 +0100
> @@ -160,7 +160,7 @@ vect_get_internal_def (vec_info *vinfo,
> vect_def_type dt;
> gimple *def_stmt;
> if (TREE_CODE (op) != SSA_NAME
> - || !vect_is_simple_use (op, vinfo, &def_stmt, &dt)
> + || !vect_is_simple_use (op, vinfo, &dt, &def_stmt)
> || dt != vect_internal_def)
> return NULL;
>
> @@ -177,14 +177,13 @@ vect_get_internal_def (vec_info *vinfo,
> type_conversion_p (tree name, gimple *use_stmt, bool check_sign,
> tree *orig_type, gimple **def_stmt, bool *promotion)
> {
> - gimple *dummy_gimple;
> stmt_vec_info stmt_vinfo;
> tree type = TREE_TYPE (name);
> tree oprnd0;
> enum vect_def_type dt;
>
> stmt_vinfo = vinfo_for_stmt (use_stmt);
> - if (!vect_is_simple_use (name, stmt_vinfo->vinfo, def_stmt, &dt))
> + if (!vect_is_simple_use (name, stmt_vinfo->vinfo, &dt, def_stmt))
> return false;
>
> if (dt != vect_internal_def
> @@ -219,7 +218,7 @@ type_conversion_p (tree name, gimple *us
> else
> *promotion = false;
>
> - if (!vect_is_simple_use (oprnd0, stmt_vinfo->vinfo, &dummy_gimple, &dt))
> + if (!vect_is_simple_use (oprnd0, stmt_vinfo->vinfo, &dt))
> return false;
>
> return true;
> @@ -1795,7 +1794,7 @@ vect_recog_rotate_pattern (vec<gimple *>
> || !TYPE_UNSIGNED (type))
> return NULL;
>
> - if (!vect_is_simple_use (oprnd1, vinfo, &def_stmt, &dt))
> + if (!vect_is_simple_use (oprnd1, vinfo, &dt, &def_stmt))
> return NULL;
>
> if (dt != vect_internal_def
> @@ -3930,13 +3929,10 @@ vect_recog_mask_conversion_pattern (vec<
> && known_le (TYPE_VECTOR_SUBPARTS (vectype1),
> TYPE_VECTOR_SUBPARTS (vectype2)))
> {
> - gimple *dummy;
> enum vect_def_type dt;
> - if (vect_is_simple_use (TREE_OPERAND (rhs1, 0), stmt_vinfo->vinfo,
> - &dummy, &dt)
> + if (vect_is_simple_use (TREE_OPERAND (rhs1, 0), vinfo, &dt)
> && dt == vect_external_def
> - && vect_is_simple_use (TREE_OPERAND (rhs1, 1),
> stmt_vinfo->vinfo,
> - &dummy, &dt)
> + && vect_is_simple_use (TREE_OPERAND (rhs1, 1), vinfo, &dt)
> && (dt == vect_external_def
> || dt == vect_constant_def))
> {
> Index: gcc/tree-vect-slp.c
> ===================================================================
> --- gcc/tree-vect-slp.c 2018-06-27 10:27:10.106647819 +0100
> +++ gcc/tree-vect-slp.c 2018-06-27 10:27:31.782458413 +0100
> @@ -348,7 +348,7 @@ vect_get_and_check_slp_defs (vec_info *v
>
> oprnd_info = (*oprnds_info)[i];
>
> - if (!vect_is_simple_use (oprnd, vinfo, &def_stmt, &dt))
> + if (!vect_is_simple_use (oprnd, vinfo, &dt, &def_stmt))
> {
> if (dump_enabled_p ())
> {
> @@ -3105,7 +3105,6 @@ vect_mask_constant_operand_p (gimple *st
> stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
> enum tree_code code = gimple_expr_code (stmt);
> tree op, vectype;
> - gimple *def_stmt;
> enum vect_def_type dt;
>
> /* For comparison and COND_EXPR type is chosen depending
> @@ -3117,8 +3116,7 @@ vect_mask_constant_operand_p (gimple *st
> else
> op = gimple_assign_rhs2 (stmt);
>
> - if (!vect_is_simple_use (op, stmt_vinfo->vinfo, &def_stmt,
> - &dt, &vectype))
> + if (!vect_is_simple_use (op, stmt_vinfo->vinfo, &dt, &vectype))
> gcc_unreachable ();
>
> return !vectype || VECTOR_BOOLEAN_TYPE_P (vectype);
> @@ -3135,8 +3133,7 @@ vect_mask_constant_operand_p (gimple *st
> else
> op = TREE_OPERAND (cond, 0);
>
> - if (!vect_is_simple_use (op, stmt_vinfo->vinfo, &def_stmt,
> - &dt, &vectype))
> + if (!vect_is_simple_use (op, stmt_vinfo->vinfo, &dt, &vectype))
> gcc_unreachable ();
>
> return !vectype || VECTOR_BOOLEAN_TYPE_P (vectype);
> Index: gcc/tree-vect-stmts.c
> ===================================================================
> --- gcc/tree-vect-stmts.c 2018-06-27 10:27:09.042657117 +0100
> +++ gcc/tree-vect-stmts.c 2018-06-27 10:27:31.782458413 +0100
> @@ -260,7 +260,6 @@ vect_mark_relevant (vec<gimple *> *workl
> is_simple_and_all_uses_invariant (gimple *stmt, loop_vec_info loop_vinfo)
> {
> tree op;
> - gimple *def_stmt;
> ssa_op_iter iter;
>
> if (!is_gimple_assign (stmt))
> @@ -270,7 +269,7 @@ is_simple_and_all_uses_invariant (gimple
> {
> enum vect_def_type dt = vect_uninitialized_def;
>
> - if (!vect_is_simple_use (op, loop_vinfo, &def_stmt, &dt))
> + if (!vect_is_simple_use (op, loop_vinfo, &dt))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -472,7 +471,7 @@ process_use (gimple *stmt, tree use, loo
> if (!force && !exist_non_indexing_operands_for_use_p (use, stmt))
> return true;
>
> - if (!vect_is_simple_use (use, loop_vinfo, &def_stmt, &dt))
> + if (!vect_is_simple_use (use, loop_vinfo, &dt, &def_stmt))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -908,11 +907,10 @@ vect_model_simple_cost (stmt_vec_info st
> for (unsigned i = 0; i < gimple_num_ops (stmt); ++i)
> {
> tree op = gimple_op (stmt, i);
> - gimple *def_stmt;
> enum vect_def_type dt;
> if (!op || op == lhs)
> continue;
> - if (vect_is_simple_use (op, stmt_info->vinfo, &def_stmt, &dt)
> + if (vect_is_simple_use (op, stmt_info->vinfo, &dt)
> && (dt == vect_constant_def || dt == vect_external_def))
> prologue_cost += vect_prologue_cost_for_slp_op (node, stmt_info,
> i, dt, cost_vec);
> @@ -1567,7 +1565,7 @@ vect_get_vec_def_for_operand (tree op, g
> dump_printf (MSG_NOTE, "\n");
> }
>
> - is_simple_use = vect_is_simple_use (op, loop_vinfo, &def_stmt, &dt);
> + is_simple_use = vect_is_simple_use (op, loop_vinfo, &dt, &def_stmt);
> gcc_assert (is_simple_use);
> if (def_stmt && dump_enabled_p ())
> {
> @@ -2336,9 +2334,8 @@ get_group_load_store_type (gimple *stmt,
> while (next_stmt)
> {
> tree op = vect_get_store_rhs (next_stmt);
> - gimple *def_stmt;
> enum vect_def_type dt;
> - if (!vect_is_simple_use (op, vinfo, &def_stmt, &dt))
> + if (!vect_is_simple_use (op, vinfo, &dt))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -2436,10 +2433,9 @@ get_load_store_type (gimple *stmt, tree
> if (STMT_VINFO_GATHER_SCATTER_P (stmt_info))
> {
> *memory_access_type = VMAT_GATHER_SCATTER;
> - gimple *def_stmt;
> if (!vect_check_gather_scatter (stmt, loop_vinfo, gs_info))
> gcc_unreachable ();
> - else if (!vect_is_simple_use (gs_info->offset, vinfo, &def_stmt,
> + else if (!vect_is_simple_use (gs_info->offset, vinfo,
> &gs_info->offset_dt,
> &gs_info->offset_vectype))
> {
> @@ -2536,11 +2532,9 @@ vect_check_load_store_mask (gimple *stmt
> }
>
> stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
> - gimple *def_stmt;
> enum vect_def_type mask_dt;
> tree mask_vectype;
> - if (!vect_is_simple_use (mask, stmt_info->vinfo, &def_stmt, &mask_dt,
> - &mask_vectype))
> + if (!vect_is_simple_use (mask, stmt_info->vinfo, &mask_dt, &mask_vectype))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -2601,11 +2595,9 @@ vect_check_store_rhs (gimple *stmt, tree
> }
>
> stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
> - gimple *def_stmt;
> enum vect_def_type rhs_dt;
> tree rhs_vectype;
> - if (!vect_is_simple_use (rhs, stmt_info->vinfo, &def_stmt, &rhs_dt,
> - &rhs_vectype))
> + if (!vect_is_simple_use (rhs, stmt_info->vinfo, &rhs_dt, &rhs_vectype))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -3136,7 +3128,6 @@ vectorizable_call (gimple *gs, gimple_st
> bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
> vec_info *vinfo = stmt_info->vinfo;
> tree fndecl, new_temp, rhs_type;
> - gimple *def_stmt;
> enum vect_def_type dt[3]
> = {vect_unknown_def_type, vect_unknown_def_type, vect_unknown_def_type};
> int ndts = 3;
> @@ -3210,7 +3201,7 @@ vectorizable_call (gimple *gs, gimple_st
> if (!rhs_type)
> rhs_type = TREE_TYPE (op);
>
> - if (!vect_is_simple_use (op, vinfo, &def_stmt, &dt[i], &opvectype))
> + if (!vect_is_simple_use (op, vinfo, &dt[i], &opvectype))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -3731,7 +3722,6 @@ vectorizable_simd_clone_call (gimple *st
> vec_info *vinfo = stmt_info->vinfo;
> struct loop *loop = loop_vinfo ? LOOP_VINFO_LOOP (loop_vinfo) : NULL;
> tree fndecl, new_temp;
> - gimple *def_stmt;
> gimple *new_stmt = NULL;
> int ncopies, j;
> auto_vec<simd_call_arg_info> arginfo;
> @@ -3794,7 +3784,7 @@ vectorizable_simd_clone_call (gimple *st
> thisarginfo.simd_lane_linear = false;
>
> op = gimple_call_arg (stmt, i);
> - if (!vect_is_simple_use (op, vinfo, &def_stmt, &thisarginfo.dt,
> + if (!vect_is_simple_use (op, vinfo, &thisarginfo.dt,
> &thisarginfo.vectype)
> || thisarginfo.dt == vect_uninitialized_def)
> {
> @@ -4575,7 +4565,6 @@ vectorizable_conversion (gimple *stmt, g
> enum tree_code codecvt1 = ERROR_MARK, codecvt2 = ERROR_MARK;
> tree decl1 = NULL_TREE, decl2 = NULL_TREE;
> tree new_temp;
> - gimple *def_stmt;
> enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type};
> int ndts = 2;
> gimple *new_stmt = NULL;
> @@ -4651,7 +4640,7 @@ vectorizable_conversion (gimple *stmt, g
> }
>
> /* Check the operands of the operation. */
> - if (!vect_is_simple_use (op0, vinfo, &def_stmt, &dt[0], &vectype_in))
> + if (!vect_is_simple_use (op0, vinfo, &dt[0], &vectype_in))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -4667,9 +4656,9 @@ vectorizable_conversion (gimple *stmt, g
> /* For WIDEN_MULT_EXPR, if OP0 is a constant, use the type of
> OP1. */
> if (CONSTANT_CLASS_P (op0))
> - ok = vect_is_simple_use (op1, vinfo, &def_stmt, &dt[1], &vectype_in);
> + ok = vect_is_simple_use (op1, vinfo, &dt[1], &vectype_in);
> else
> - ok = vect_is_simple_use (op1, vinfo, &def_stmt, &dt[1]);
> + ok = vect_is_simple_use (op1, vinfo, &dt[1]);
>
> if (!ok)
> {
> @@ -5171,7 +5160,6 @@ vectorizable_assignment (gimple *stmt, g
> stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
> loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
> tree new_temp;
> - gimple *def_stmt;
> enum vect_def_type dt[1] = {vect_unknown_def_type};
> int ndts = 1;
> int ncopies;
> @@ -5224,7 +5212,7 @@ vectorizable_assignment (gimple *stmt, g
>
> gcc_assert (ncopies >= 1);
>
> - if (!vect_is_simple_use (op, vinfo, &def_stmt, &dt[0], &vectype_in))
> + if (!vect_is_simple_use (op, vinfo, &dt[0], &vectype_in))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -5380,7 +5368,6 @@ vectorizable_shift (gimple *stmt, gimple
> optab optab;
> int icode;
> machine_mode optab_op2_mode;
> - gimple *def_stmt;
> enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type};
> int ndts = 2;
> gimple *new_stmt = NULL;
> @@ -5430,7 +5417,7 @@ vectorizable_shift (gimple *stmt, gimple
> }
>
> op0 = gimple_assign_rhs1 (stmt);
> - if (!vect_is_simple_use (op0, vinfo, &def_stmt, &dt[0], &vectype))
> + if (!vect_is_simple_use (op0, vinfo, &dt[0], &vectype))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -5457,7 +5444,7 @@ vectorizable_shift (gimple *stmt, gimple
> return false;
>
> op1 = gimple_assign_rhs2 (stmt);
> - if (!vect_is_simple_use (op1, vinfo, &def_stmt, &dt[1], &op1_vectype))
> + if (!vect_is_simple_use (op1, vinfo, &dt[1], &op1_vectype))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -5746,7 +5733,6 @@ vectorizable_operation (gimple *stmt, gi
> int op_type;
> optab optab;
> bool target_support_p;
> - gimple *def_stmt;
> enum vect_def_type dt[3]
> = {vect_unknown_def_type, vect_unknown_def_type, vect_unknown_def_type};
> int ndts = 3;
> @@ -5817,7 +5803,7 @@ vectorizable_operation (gimple *stmt, gi
> }
>
> op0 = gimple_assign_rhs1 (stmt);
> - if (!vect_is_simple_use (op0, vinfo, &def_stmt, &dt[0], &vectype))
> + if (!vect_is_simple_use (op0, vinfo, &dt[0], &vectype))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -5871,7 +5857,7 @@ vectorizable_operation (gimple *stmt, gi
> if (op_type == binary_op || op_type == ternary_op)
> {
> op1 = gimple_assign_rhs2 (stmt);
> - if (!vect_is_simple_use (op1, vinfo, &def_stmt, &dt[1]))
> + if (!vect_is_simple_use (op1, vinfo, &dt[1]))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -5882,7 +5868,7 @@ vectorizable_operation (gimple *stmt, gi
> if (op_type == ternary_op)
> {
> op2 = gimple_assign_rhs3 (stmt);
> - if (!vect_is_simple_use (op2, vinfo, &def_stmt, &dt[2]))
> + if (!vect_is_simple_use (op2, vinfo, &dt[2]))
> {
> if (dump_enabled_p ())
> dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -6196,7 +6182,6 @@ vectorizable_store (gimple *stmt, gimple
> machine_mode vec_mode;
> tree dummy;
> enum dr_alignment_support alignment_support_scheme;
> - gimple *def_stmt;
> enum vect_def_type rhs_dt = vect_unknown_def_type;
> enum vect_def_type mask_dt = vect_unknown_def_type;
> stmt_vec_info prev_stmt_info = NULL;
> @@ -6757,7 +6742,7 @@ vectorizable_store (gimple *stmt, gimple
> vec_oprnd = vec_oprnds[j];
> else
> {
> - vect_is_simple_use (op, vinfo, &def_stmt, &rhs_dt);
> + vect_is_simple_use (op, vinfo, &rhs_dt);
> vec_oprnd = vect_get_vec_def_for_stmt_copy (rhs_dt,
> vec_oprnd);
> }
> @@ -7003,7 +6988,7 @@ vectorizable_store (gimple *stmt, gimple
> for (i = 0; i < group_size; i++)
> {
> op = oprnds[i];
> - vect_is_simple_use (op, vinfo, &def_stmt, &rhs_dt);
> + vect_is_simple_use (op, vinfo, &rhs_dt);
> vec_oprnd = vect_get_vec_def_for_stmt_copy (rhs_dt, op);
> dr_chain[i] = vec_oprnd;
> oprnds[i] = vec_oprnd;
> @@ -8588,9 +8573,7 @@ vect_is_simple_cond (tree cond, vec_info
> if (TREE_CODE (cond) == SSA_NAME
> && VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (cond)))
> {
> - gimple *lhs_def_stmt = SSA_NAME_DEF_STMT (cond);
> - if (!vect_is_simple_use (cond, vinfo, &lhs_def_stmt,
> - &dts[0], comp_vectype)
> + if (!vect_is_simple_use (cond, vinfo, &dts[0], comp_vectype)
> || !*comp_vectype
> || !VECTOR_BOOLEAN_TYPE_P (*comp_vectype))
> return false;
> @@ -8605,8 +8588,7 @@ vect_is_simple_cond (tree cond, vec_info
>
> if (TREE_CODE (lhs) == SSA_NAME)
> {
> - gimple *lhs_def_stmt = SSA_NAME_DEF_STMT (lhs);
> - if (!vect_is_simple_use (lhs, vinfo, &lhs_def_stmt, &dts[0],
> &vectype1))
> + if (!vect_is_simple_use (lhs, vinfo, &dts[0], &vectype1))
> return false;
> }
> else if (TREE_CODE (lhs) == INTEGER_CST || TREE_CODE (lhs) == REAL_CST
> @@ -8617,8 +8599,7 @@ vect_is_simple_cond (tree cond, vec_info
>
> if (TREE_CODE (rhs) == SSA_NAME)
> {
> - gimple *rhs_def_stmt = SSA_NAME_DEF_STMT (rhs);
> - if (!vect_is_simple_use (rhs, vinfo, &rhs_def_stmt, &dts[1],
> &vectype2))
> + if (!vect_is_simple_use (rhs, vinfo, &dts[1], &vectype2))
> return false;
> }
> else if (TREE_CODE (rhs) == INTEGER_CST || TREE_CODE (rhs) == REAL_CST
> @@ -8750,12 +8731,9 @@ vectorizable_condition (gimple *stmt, gi
> || !comp_vectype)
> return false;
>
> - gimple *def_stmt;
> - if (!vect_is_simple_use (then_clause, stmt_info->vinfo, &def_stmt, &dts[2],
> - &vectype1))
> + if (!vect_is_simple_use (then_clause, stmt_info->vinfo, &dts[2],
> &vectype1))
> return false;
> - if (!vect_is_simple_use (else_clause, stmt_info->vinfo, &def_stmt, &dts[3],
> - &vectype2))
> + if (!vect_is_simple_use (else_clause, stmt_info->vinfo, &dts[3],
> &vectype2))
> return false;
>
> if (vectype1 && !useless_type_conversion_p (vectype, vectype1))
> @@ -8892,26 +8870,24 @@ vectorizable_condition (gimple *stmt, gi
> }
> else
> {
> - gimple *gtemp;
> if (masked)
> {
> vec_cond_lhs
> = vect_get_vec_def_for_operand (cond_expr, stmt,
> comp_vectype);
> - vect_is_simple_use (cond_expr, stmt_info->vinfo,
> - >emp, &dts[0]);
> + vect_is_simple_use (cond_expr, stmt_info->vinfo, &dts[0]);
> }
> else
> {
> vec_cond_lhs
> = vect_get_vec_def_for_operand (cond_expr0,
> stmt, comp_vectype);
> - vect_is_simple_use (cond_expr0, loop_vinfo, >emp,
> &dts[0]);
> + vect_is_simple_use (cond_expr0, loop_vinfo, &dts[0]);
>
> vec_cond_rhs
> = vect_get_vec_def_for_operand (cond_expr1,
> stmt, comp_vectype);
> - vect_is_simple_use (cond_expr1, loop_vinfo, >emp,
> &dts[1]);
> + vect_is_simple_use (cond_expr1, loop_vinfo, &dts[1]);
> }
> if (reduc_index == 1)
> vec_then_clause = reduc_def;
> @@ -8919,8 +8895,7 @@ vectorizable_condition (gimple *stmt, gi
> {
> vec_then_clause = vect_get_vec_def_for_operand (then_clause,
> stmt);
> - vect_is_simple_use (then_clause, loop_vinfo,
> - >emp, &dts[2]);
> + vect_is_simple_use (then_clause, loop_vinfo, &dts[2]);
> }
> if (reduc_index == 2)
> vec_else_clause = reduc_def;
> @@ -8928,7 +8903,7 @@ vectorizable_condition (gimple *stmt, gi
> {
> vec_else_clause = vect_get_vec_def_for_operand (else_clause,
> stmt);
> - vect_is_simple_use (else_clause, loop_vinfo, >emp,
> &dts[3]);
> + vect_is_simple_use (else_clause, loop_vinfo, &dts[3]);
> }
> }
> }
> @@ -9089,7 +9064,6 @@ vectorizable_comparison (gimple *stmt, g
> bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
> vec<tree> vec_oprnds0 = vNULL;
> vec<tree> vec_oprnds1 = vNULL;
> - gimple *def_stmt;
> tree mask_type;
> tree mask;
>
> @@ -9132,12 +9106,10 @@ vectorizable_comparison (gimple *stmt, g
> rhs1 = gimple_assign_rhs1 (stmt);
> rhs2 = gimple_assign_rhs2 (stmt);
>
> - if (!vect_is_simple_use (rhs1, stmt_info->vinfo, &def_stmt,
> - &dts[0], &vectype1))
> + if (!vect_is_simple_use (rhs1, stmt_info->vinfo, &dts[0], &vectype1))
> return false;
>
> - if (!vect_is_simple_use (rhs2, stmt_info->vinfo, &def_stmt,
> - &dts[1], &vectype2))
> + if (!vect_is_simple_use (rhs2, stmt_info->vinfo, &dts[1], &vectype2))
> return false;
>
> if (vectype1 && vectype2
> @@ -10043,7 +10015,7 @@ get_same_sized_vectype (tree scalar_type
> VINFO - the vect info of the loop or basic block that is being vectorized.
> OPERAND - operand in the loop or bb.
> Output:
> - DEF_STMT - the defining stmt in case OPERAND is an SSA_NAME.
> + DEF_STMT_OUT (optional) - the defining stmt in case OPERAND is an
> SSA_NAME.
> DT - the type of definition
>
> Returns whether a stmt with OPERAND can be vectorized.
> @@ -10055,10 +10027,11 @@ get_same_sized_vectype (tree scalar_type
> For now, operands defined outside the basic block are not supported. */
>
> bool
> -vect_is_simple_use (tree operand, vec_info *vinfo,
> - gimple **def_stmt, enum vect_def_type *dt)
> +vect_is_simple_use (tree operand, vec_info *vinfo, enum vect_def_type *dt,
> + gimple **def_stmt_out)
> {
> - *def_stmt = NULL;
> + if (def_stmt_out)
> + *def_stmt_out = NULL;
> *dt = vect_unknown_def_type;
>
> if (dump_enabled_p ())
> @@ -10095,18 +10068,20 @@ vect_is_simple_use (tree operand, vec_in
> return true;
> }
>
> - *def_stmt = SSA_NAME_DEF_STMT (operand);
> + gimple *def_stmt = SSA_NAME_DEF_STMT (operand);
> + if (def_stmt_out)
> + *def_stmt_out = def_stmt;
> if (dump_enabled_p ())
> {
> dump_printf_loc (MSG_NOTE, vect_location, "def_stmt: ");
> - dump_gimple_stmt (MSG_NOTE, TDF_SLIM, *def_stmt, 0);
> + dump_gimple_stmt (MSG_NOTE, TDF_SLIM, def_stmt, 0);
> }
>
> - if (! vect_stmt_in_region_p (vinfo, *def_stmt))
> + if (! vect_stmt_in_region_p (vinfo, def_stmt))
> *dt = vect_external_def;
> else
> {
> - stmt_vec_info stmt_vinfo = vinfo_for_stmt (*def_stmt);
> + stmt_vec_info stmt_vinfo = vinfo_for_stmt (def_stmt);
> *dt = STMT_VINFO_DEF_TYPE (stmt_vinfo);
> }
>
> @@ -10153,7 +10128,7 @@ vect_is_simple_use (tree operand, vec_in
> return false;
> }
>
> - switch (gimple_code (*def_stmt))
> + switch (gimple_code (def_stmt))
> {
> case GIMPLE_PHI:
> case GIMPLE_ASSIGN:
> @@ -10179,12 +10154,16 @@ vect_is_simple_use (tree operand, vec_in
> scalar operand. */
>
> bool
> -vect_is_simple_use (tree operand, vec_info *vinfo,
> - gimple **def_stmt, enum vect_def_type *dt, tree *vectype)
> +vect_is_simple_use (tree operand, vec_info *vinfo, enum vect_def_type *dt,
> + tree *vectype, gimple **def_stmt_out)
> {
> - if (!vect_is_simple_use (operand, vinfo, def_stmt, dt))
> + gimple *def_stmt;
> + if (!vect_is_simple_use (operand, vinfo, dt, &def_stmt))
> return false;
>
> + if (def_stmt_out)
> + *def_stmt_out = def_stmt;
> +
> /* Now get a vector type if the def is internal, otherwise supply
> NULL_TREE and leave it up to the caller to figure out a proper
> type for the use stmt. */
> @@ -10194,7 +10173,7 @@ vect_is_simple_use (tree operand, vec_in
> || *dt == vect_double_reduction_def
> || *dt == vect_nested_cycle)
> {
> - stmt_vec_info stmt_info = vinfo_for_stmt (*def_stmt);
> + stmt_vec_info stmt_info = vinfo_for_stmt (def_stmt);
>
> if (STMT_VINFO_IN_PATTERN_P (stmt_info)
> && !STMT_VINFO_RELEVANT (stmt_info)
> @@ -10869,13 +10848,11 @@ vect_get_mask_type_for_stmt (stmt_vec_in
> {
> tree rhs;
> ssa_op_iter iter;
> - gimple *def_stmt;
> enum vect_def_type dt;
>
> FOR_EACH_SSA_TREE_OPERAND (rhs, stmt, iter, SSA_OP_USE)
> {
> - if (!vect_is_simple_use (rhs, stmt_info->vinfo,
> - &def_stmt, &dt, &vectype))
> + if (!vect_is_simple_use (rhs, stmt_info->vinfo, &dt, &vectype))
> {
> if (dump_enabled_p ())
> {
