[2/3] Pass vec_infos to more routines
diff mbox series

Message ID mpta79vlf50.fsf@arm.com
State New
Headers show
Series
  • Turn current_vector_size into a vec_info field
Related show

Commit Message

Richard Sandiford Oct. 20, 2019, 1:28 p.m. UTC
These 11 patches just pass vec_infos to one routine each.  Splitting
them up make it easier to write the changelogs, but they're so trivial
that it seemed better to send them all in one message.


Pass a vec_info to vect_supportable_shift

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (vect_supportable_shift): Take a vec_info.
	* tree-vect-stmts.c (vect_supportable_shift): Likewise.
	* tree-vect-patterns.c (vect_synth_mult_by_constant): Update call
	accordingly.

Comments

Richard Biener Oct. 30, 2019, 2:21 p.m. UTC | #1
On Sun, Oct 20, 2019 at 3:29 PM Richard Sandiford
<richard.sandiford@arm.com> wrote:
>
> These 11 patches just pass vec_infos to one routine each.  Splitting
> them up make it easier to write the changelogs, but they're so trivial
> that it seemed better to send them all in one message.

OK.

>
> Pass a vec_info to vect_supportable_shift
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vectorizer.h (vect_supportable_shift): Take a vec_info.
>         * tree-vect-stmts.c (vect_supportable_shift): Likewise.
>         * tree-vect-patterns.c (vect_synth_mult_by_constant): Update call
>         accordingly.
>
> Index: gcc/tree-vectorizer.h
> ===================================================================
> --- gcc/tree-vectorizer.h       2019-10-20 13:58:02.095634389 +0100
> +++ gcc/tree-vectorizer.h       2019-10-20 14:14:00.632786715 +0100
> @@ -1634,7 +1634,7 @@ extern void vect_get_load_cost (stmt_vec
>                                 stmt_vector_for_cost *, bool);
>  extern void vect_get_store_cost (stmt_vec_info, int,
>                                  unsigned int *, stmt_vector_for_cost *);
> -extern bool vect_supportable_shift (enum tree_code, tree);
> +extern bool vect_supportable_shift (vec_info *, enum tree_code, tree);
>  extern tree vect_gen_perm_mask_any (tree, const vec_perm_indices &);
>  extern tree vect_gen_perm_mask_checked (tree, const vec_perm_indices &);
>  extern void optimize_mask_stores (class loop*);
> Index: gcc/tree-vect-stmts.c
> ===================================================================
> --- gcc/tree-vect-stmts.c       2019-10-20 13:58:02.111634275 +0100
> +++ gcc/tree-vect-stmts.c       2019-10-20 14:14:00.628786742 +0100
> @@ -5465,7 +5465,7 @@ vectorizable_assignment (stmt_vec_info s
>     either as shift by a scalar or by a vector.  */
>
>  bool
> -vect_supportable_shift (enum tree_code code, tree scalar_type)
> +vect_supportable_shift (vec_info *, enum tree_code code, tree scalar_type)
>  {
>
>    machine_mode vec_mode;
> Index: gcc/tree-vect-patterns.c
> ===================================================================
> --- gcc/tree-vect-patterns.c    2019-10-17 14:22:55.519309037 +0100
> +++ gcc/tree-vect-patterns.c    2019-10-20 14:14:00.628786742 +0100
> @@ -2720,6 +2720,7 @@ apply_binop_and_append_stmt (tree_code c
>  vect_synth_mult_by_constant (tree op, tree val,
>                              stmt_vec_info stmt_vinfo)
>  {
> +  vec_info *vinfo = stmt_vinfo->vinfo;
>    tree itype = TREE_TYPE (op);
>    machine_mode mode = TYPE_MODE (itype);
>    struct algorithm alg;
> @@ -2738,7 +2739,7 @@ vect_synth_mult_by_constant (tree op, tr
>
>    /* Targets that don't support vector shifts but support vector additions
>       can synthesize shifts that way.  */
> -  bool synth_shift_p = !vect_supportable_shift (LSHIFT_EXPR, multtype);
> +  bool synth_shift_p = !vect_supportable_shift (vinfo, LSHIFT_EXPR, multtype);
>
>    HOST_WIDE_INT hwval = tree_to_shwi (val);
>    /* Use MAX_COST here as we don't want to limit the sequence on rtx costs.
>
>
> Pass a vec_info to vect_supportable_direct_optab_p
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vect-patterns.c (vect_supportable_direct_optab_p): Take
>         a vec_info.
>         (vect_recog_dot_prod_pattern): Update call accordingly.
>         (vect_recog_sad_pattern, vect_recog_pow_pattern): Likewise.
>         (vect_recog_widen_sum_pattern): Likewise.
>
> Index: gcc/tree-vect-patterns.c
> ===================================================================
> --- gcc/tree-vect-patterns.c    2019-10-20 14:14:00.628786742 +0100
> +++ gcc/tree-vect-patterns.c    2019-10-20 14:14:03.588765602 +0100
> @@ -187,7 +187,7 @@ vect_get_external_def_edge (vec_info *vi
>     is nonnull.  */
>
>  static bool
> -vect_supportable_direct_optab_p (tree otype, tree_code code,
> +vect_supportable_direct_optab_p (vec_info *, tree otype, tree_code code,
>                                  tree itype, tree *vecotype_out,
>                                  tree *vecitype_out = NULL)
>  {
> @@ -985,7 +985,7 @@ vect_recog_dot_prod_pattern (stmt_vec_in
>    vect_pattern_detected ("vect_recog_dot_prod_pattern", last_stmt);
>
>    tree half_vectype;
> -  if (!vect_supportable_direct_optab_p (type, DOT_PROD_EXPR, half_type,
> +  if (!vect_supportable_direct_optab_p (vinfo, type, DOT_PROD_EXPR, half_type,
>                                         type_out, &half_vectype))
>      return NULL;
>
> @@ -1143,7 +1143,7 @@ vect_recog_sad_pattern (stmt_vec_info st
>    vect_pattern_detected ("vect_recog_sad_pattern", last_stmt);
>
>    tree half_vectype;
> -  if (!vect_supportable_direct_optab_p (sum_type, SAD_EXPR, half_type,
> +  if (!vect_supportable_direct_optab_p (vinfo, sum_type, SAD_EXPR, half_type,
>                                         type_out, &half_vectype))
>      return NULL;
>
> @@ -1273,6 +1273,7 @@ vect_recog_widen_mult_pattern (stmt_vec_
>  static gimple *
>  vect_recog_pow_pattern (stmt_vec_info stmt_vinfo, tree *type_out)
>  {
> +  vec_info *vinfo = stmt_vinfo->vinfo;
>    gimple *last_stmt = stmt_vinfo->stmt;
>    tree base, exp;
>    gimple *stmt;
> @@ -1366,7 +1367,7 @@ vect_recog_pow_pattern (stmt_vec_info st
>        || (TREE_CODE (exp) == REAL_CST
>            && real_equal (&TREE_REAL_CST (exp), &dconst2)))
>      {
> -      if (!vect_supportable_direct_optab_p (TREE_TYPE (base), MULT_EXPR,
> +      if (!vect_supportable_direct_optab_p (vinfo, TREE_TYPE (base), MULT_EXPR,
>                                             TREE_TYPE (base), type_out))
>         return NULL;
>
> @@ -1472,8 +1473,8 @@ vect_recog_widen_sum_pattern (stmt_vec_i
>
>    vect_pattern_detected ("vect_recog_widen_sum_pattern", last_stmt);
>
> -  if (!vect_supportable_direct_optab_p (type, WIDEN_SUM_EXPR, unprom0.type,
> -                                       type_out))
> +  if (!vect_supportable_direct_optab_p (vinfo, type, WIDEN_SUM_EXPR,
> +                                       unprom0.type, type_out))
>      return NULL;
>
>    var = vect_recog_temp_ssa_var (type, NULL);
>
>
>
> Pass a vec_info to get_mask_type_for_scalar_type
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vectorizer.h (get_mask_type_for_scalar_type): Take a vec_info.
>         * tree-vect-stmts.c (get_mask_type_for_scalar_type): Likewise.
>         (vect_check_load_store_mask): Update call accordingly.
>         (vect_get_mask_type_for_stmt): Likewise.
>         * tree-vect-patterns.c (check_bool_pattern): Likewise.
>         (search_type_for_mask_1, vect_recog_mask_conversion_pattern): Likewise.
>         (vect_convert_mask_for_vectype): Likewise.
>
> Index: gcc/tree-vectorizer.h
> ===================================================================
> --- gcc/tree-vectorizer.h       2019-10-20 14:14:00.632786715 +0100
> +++ gcc/tree-vectorizer.h       2019-10-20 14:14:06.472745000 +0100
> @@ -1591,7 +1591,7 @@ extern bool vect_can_advance_ivs_p (loop
>  extern poly_uint64 current_vector_size;
>  extern tree get_vectype_for_scalar_type (tree);
>  extern tree get_vectype_for_scalar_type_and_size (tree, poly_uint64);
> -extern tree get_mask_type_for_scalar_type (tree);
> +extern tree get_mask_type_for_scalar_type (vec_info *, 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 *, enum vect_def_type *,
> Index: gcc/tree-vect-stmts.c
> ===================================================================
> --- gcc/tree-vect-stmts.c       2019-10-20 14:14:00.628786742 +0100
> +++ gcc/tree-vect-stmts.c       2019-10-20 14:14:06.472745000 +0100
> @@ -2558,6 +2558,7 @@ vect_check_load_store_mask (stmt_vec_inf
>                             vect_def_type *mask_dt_out,
>                             tree *mask_vectype_out)
>  {
> +  vec_info *vinfo = stmt_info->vinfo;
>    if (!VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (mask)))
>      {
>        if (dump_enabled_p ())
> @@ -2586,7 +2587,7 @@ vect_check_load_store_mask (stmt_vec_inf
>
>    tree vectype = STMT_VINFO_VECTYPE (stmt_info);
>    if (!mask_vectype)
> -    mask_vectype = get_mask_type_for_scalar_type (TREE_TYPE (vectype));
> +    mask_vectype = get_mask_type_for_scalar_type (vinfo, TREE_TYPE (vectype));
>
>    if (!mask_vectype || !VECTOR_BOOLEAN_TYPE_P (mask_vectype))
>      {
> @@ -11156,7 +11157,7 @@ get_vectype_for_scalar_type (tree scalar
>     of vectors of specified SCALAR_TYPE as supported by target.  */
>
>  tree
> -get_mask_type_for_scalar_type (tree scalar_type)
> +get_mask_type_for_scalar_type (vec_info *, tree scalar_type)
>  {
>    tree vectype = get_vectype_for_scalar_type (scalar_type);
>
> @@ -11986,6 +11987,7 @@ vect_get_vector_types_for_stmt (stmt_vec
>  opt_tree
>  vect_get_mask_type_for_stmt (stmt_vec_info stmt_info)
>  {
> +  vec_info *vinfo = stmt_info->vinfo;
>    gimple *stmt = stmt_info->stmt;
>    tree mask_type = NULL;
>    tree vectype, scalar_type;
> @@ -11995,7 +11997,7 @@ vect_get_mask_type_for_stmt (stmt_vec_in
>        && !VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (gimple_assign_rhs1 (stmt))))
>      {
>        scalar_type = TREE_TYPE (gimple_assign_rhs1 (stmt));
> -      mask_type = get_mask_type_for_scalar_type (scalar_type);
> +      mask_type = get_mask_type_for_scalar_type (vinfo, scalar_type);
>
>        if (!mask_type)
>         return opt_tree::failure_at (stmt,
> Index: gcc/tree-vect-patterns.c
> ===================================================================
> --- gcc/tree-vect-patterns.c    2019-10-20 14:14:03.588765602 +0100
> +++ gcc/tree-vect-patterns.c    2019-10-20 14:14:06.468745032 +0100
> @@ -3616,7 +3616,8 @@ check_bool_pattern (tree var, vec_info *
>           if (comp_vectype == NULL_TREE)
>             return false;
>
> -         tree mask_type = get_mask_type_for_scalar_type (TREE_TYPE (rhs1));
> +         tree mask_type = get_mask_type_for_scalar_type (vinfo,
> +                                                         TREE_TYPE (rhs1));
>           if (mask_type
>               && expand_vec_cmp_expr_p (comp_vectype, mask_type, rhs_code))
>             return false;
> @@ -3943,7 +3944,7 @@ search_type_for_mask_1 (tree var, vec_in
>               break;
>             }
>
> -         mask_type = get_mask_type_for_scalar_type (TREE_TYPE (rhs1));
> +         mask_type = get_mask_type_for_scalar_type (vinfo, TREE_TYPE (rhs1));
>           if (!mask_type
>               || !expand_vec_cmp_expr_p (comp_vectype, mask_type, rhs_code))
>             {
> @@ -4275,7 +4276,7 @@ vect_recog_mask_conversion_pattern (stmt
>        tree mask_arg_type = search_type_for_mask (mask_arg, vinfo);
>        if (!mask_arg_type)
>         return NULL;
> -      vectype2 = get_mask_type_for_scalar_type (mask_arg_type);
> +      vectype2 = get_mask_type_for_scalar_type (vinfo, mask_arg_type);
>
>        if (!vectype1 || !vectype2
>           || known_eq (TYPE_VECTOR_SUBPARTS (vectype1),
> @@ -4352,7 +4353,7 @@ vect_recog_mask_conversion_pattern (stmt
>        else
>         return NULL;
>
> -      vectype2 = get_mask_type_for_scalar_type (rhs1_type);
> +      vectype2 = get_mask_type_for_scalar_type (vinfo, rhs1_type);
>
>        if (!vectype1 || !vectype2)
>         return NULL;
> @@ -4442,14 +4443,14 @@ vect_recog_mask_conversion_pattern (stmt
>
>    if (TYPE_PRECISION (rhs1_type) < TYPE_PRECISION (rhs2_type))
>      {
> -      vectype1 = get_mask_type_for_scalar_type (rhs1_type);
> +      vectype1 = get_mask_type_for_scalar_type (vinfo, rhs1_type);
>        if (!vectype1)
>         return NULL;
>        rhs2 = build_mask_conversion (rhs2, vectype1, stmt_vinfo);
>      }
>    else
>      {
> -      vectype1 = get_mask_type_for_scalar_type (rhs2_type);
> +      vectype1 = get_mask_type_for_scalar_type (vinfo, rhs2_type);
>        if (!vectype1)
>         return NULL;
>        rhs1 = build_mask_conversion (rhs1, vectype1, stmt_vinfo);
> @@ -4520,7 +4521,7 @@ vect_convert_mask_for_vectype (tree mask
>    tree mask_type = search_type_for_mask (mask, vinfo);
>    if (mask_type)
>      {
> -      tree mask_vectype = get_mask_type_for_scalar_type (mask_type);
> +      tree mask_vectype = get_mask_type_for_scalar_type (vinfo, mask_type);
>        if (mask_vectype
>           && maybe_ne (TYPE_VECTOR_SUBPARTS (vectype),
>                        TYPE_VECTOR_SUBPARTS (mask_vectype)))
>
>
> Pass a vec_info to get_vectype_for_scalar_type
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vectorizer.h (get_vectype_for_scalar_type): Take a vec_info.
>         * tree-vect-stmts.c (get_vectype_for_scalar_type): Likewise.
>         (vect_prologue_cost_for_slp_op): Update call accordingly.
>         (vect_get_vec_def_for_operand, vect_get_gather_scatter_ops)
>         (vect_get_strided_load_store_ops, vectorizable_simd_clone_call)
>         (vect_supportable_shift, vect_is_simple_cond, vectorizable_comparison)
>         (get_mask_type_for_scalar_type): Likewise.
>         (vect_get_vector_types_for_stmt): Likewise.
>         * tree-vect-data-refs.c (vect_analyze_data_refs): Likewise.
>         * tree-vect-loop.c (vect_determine_vectorization_factor): Likewise.
>         (get_initial_def_for_reduction, build_vect_cond_expr): Likewise.
>         * tree-vect-patterns.c (vect_supportable_direct_optab_p): Likewise.
>         (vect_split_statement, vect_convert_input): Likewise.
>         (vect_recog_widen_op_pattern, vect_recog_pow_pattern): Likewise.
>         (vect_recog_over_widening_pattern, vect_recog_mulhs_pattern): Likewise.
>         (vect_recog_average_pattern, vect_recog_cast_forwprop_pattern)
>         (vect_recog_rotate_pattern, vect_recog_vector_vector_shift_pattern)
>         (vect_synth_mult_by_constant, vect_recog_mult_pattern): Likewise.
>         (vect_recog_divmod_pattern, vect_recog_mixed_size_cond_pattern)
>         (check_bool_pattern, adjust_bool_pattern_cast, adjust_bool_pattern)
>         (search_type_for_mask_1, vect_recog_bool_pattern): Likewise.
>         (vect_recog_mask_conversion_pattern): Likewise.
>         (vect_add_conversion_to_pattern): Likewise.
>         (vect_recog_gather_scatter_pattern): Likewise.
>         * tree-vect-slp.c (vect_build_slp_tree_2): Likewise.
>         (vect_analyze_slp_instance, vect_get_constant_vectors): Likewise.
>
> Index: gcc/tree-vectorizer.h
> ===================================================================
> --- gcc/tree-vectorizer.h       2019-10-20 14:14:06.472745000 +0100
> +++ gcc/tree-vectorizer.h       2019-10-20 14:14:09.672722145 +0100
> @@ -1589,7 +1589,7 @@ extern bool vect_can_advance_ivs_p (loop
>
>  /* In tree-vect-stmts.c.  */
>  extern poly_uint64 current_vector_size;
> -extern tree get_vectype_for_scalar_type (tree);
> +extern tree get_vectype_for_scalar_type (vec_info *, tree);
>  extern tree get_vectype_for_scalar_type_and_size (tree, poly_uint64);
>  extern tree get_mask_type_for_scalar_type (vec_info *, tree);
>  extern tree get_same_sized_vectype (tree, tree);
> Index: gcc/tree-vect-stmts.c
> ===================================================================
> --- gcc/tree-vect-stmts.c       2019-10-20 14:14:06.472745000 +0100
> +++ gcc/tree-vect-stmts.c       2019-10-20 14:14:09.672722145 +0100
> @@ -796,6 +796,7 @@ vect_prologue_cost_for_slp_op (slp_tree
>                                unsigned opno, enum vect_def_type dt,
>                                stmt_vector_for_cost *cost_vec)
>  {
> +  vec_info *vinfo = stmt_info->vinfo;
>    gimple *stmt = SLP_TREE_SCALAR_STMTS (node)[0]->stmt;
>    tree op = gimple_op (stmt, opno);
>    unsigned prologue_cost = 0;
> @@ -803,7 +804,7 @@ vect_prologue_cost_for_slp_op (slp_tree
>    /* Without looking at the actual initializer a vector of
>       constants can be implemented as load from the constant pool.
>       When all elements are the same we can use a splat.  */
> -  tree vectype = get_vectype_for_scalar_type (TREE_TYPE (op));
> +  tree vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (op));
>    unsigned group_size = SLP_TREE_SCALAR_STMTS (node).length ();
>    unsigned num_vects_to_check;
>    unsigned HOST_WIDE_INT const_nunits;
> @@ -1610,7 +1611,7 @@ vect_get_vec_def_for_operand (tree op, s
>                && VECTOR_BOOLEAN_TYPE_P (stmt_vectype))
>         vector_type = build_same_sized_truth_vector_type (stmt_vectype);
>        else
> -       vector_type = get_vectype_for_scalar_type (TREE_TYPE (op));
> +       vector_type = get_vectype_for_scalar_type (loop_vinfo, TREE_TYPE (op));
>
>        gcc_assert (vector_type);
>        return vect_init_vector (stmt_vinfo, op, vector_type, NULL);
> @@ -2975,6 +2976,7 @@ vect_get_gather_scatter_ops (class loop
>                              gather_scatter_info *gs_info,
>                              tree *dataref_ptr, tree *vec_offset)
>  {
> +  vec_info *vinfo = stmt_info->vinfo;
>    gimple_seq stmts = NULL;
>    *dataref_ptr = force_gimple_operand (gs_info->base, &stmts, true, NULL_TREE);
>    if (stmts != NULL)
> @@ -2985,7 +2987,7 @@ vect_get_gather_scatter_ops (class loop
>        gcc_assert (!new_bb);
>      }
>    tree offset_type = TREE_TYPE (gs_info->offset);
> -  tree offset_vectype = get_vectype_for_scalar_type (offset_type);
> +  tree offset_vectype = get_vectype_for_scalar_type (vinfo, offset_type);
>    *vec_offset = vect_get_vec_def_for_operand (gs_info->offset, stmt_info,
>                                               offset_vectype);
>  }
> @@ -3020,7 +3022,7 @@ vect_get_strided_load_store_ops (stmt_ve
>    /* The offset given in GS_INFO can have pointer type, so use the element
>       type of the vector instead.  */
>    tree offset_type = TREE_TYPE (gs_info->offset);
> -  tree offset_vectype = get_vectype_for_scalar_type (offset_type);
> +  tree offset_vectype = get_vectype_for_scalar_type (loop_vinfo, offset_type);
>    offset_type = TREE_TYPE (offset_vectype);
>
>    /* Calculate X = DR_STEP / SCALE and convert it to the appropriate type.  */
> @@ -4101,9 +4103,8 @@ vectorizable_simd_clone_call (stmt_vec_i
>          || arginfo[i].dt == vect_external_def)
>         && bestn->simdclone->args[i].arg_type == SIMD_CLONE_ARG_TYPE_VECTOR)
>        {
> -       arginfo[i].vectype
> -         = get_vectype_for_scalar_type (TREE_TYPE (gimple_call_arg (stmt,
> -                                                                    i)));
> +       tree arg_type = TREE_TYPE (gimple_call_arg (stmt, i));
> +       arginfo[i].vectype = get_vectype_for_scalar_type (vinfo, arg_type);
>         if (arginfo[i].vectype == NULL
>             || (simd_clone_subparts (arginfo[i].vectype)
>                 > bestn->simdclone->simdlen))
> @@ -5466,7 +5467,7 @@ vectorizable_assignment (stmt_vec_info s
>     either as shift by a scalar or by a vector.  */
>
>  bool
> -vect_supportable_shift (vec_info *, enum tree_code code, tree scalar_type)
> +vect_supportable_shift (vec_info *vinfo, enum tree_code code, tree scalar_type)
>  {
>
>    machine_mode vec_mode;
> @@ -5474,7 +5475,7 @@ vect_supportable_shift (vec_info *, enum
>    int icode;
>    tree vectype;
>
> -  vectype = get_vectype_for_scalar_type (scalar_type);
> +  vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
>    if (!vectype)
>      return false;
>
> @@ -9763,7 +9764,7 @@ vect_is_simple_cond (tree cond, vec_info
>         scalar_type = build_nonstandard_integer_type
>           (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (vectype))),
>            TYPE_UNSIGNED (scalar_type));
> -      *comp_vectype = get_vectype_for_scalar_type (scalar_type);
> +      *comp_vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
>      }
>
>    return true;
> @@ -10359,7 +10360,7 @@ vectorizable_comparison (stmt_vec_info s
>    /* Invariant comparison.  */
>    if (!vectype)
>      {
> -      vectype = get_vectype_for_scalar_type (TREE_TYPE (rhs1));
> +      vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (rhs1));
>        if (maybe_ne (TYPE_VECTOR_SUBPARTS (vectype), nunits))
>         return false;
>      }
> @@ -11140,7 +11141,7 @@ get_vectype_for_scalar_type_and_size (tr
>     by the target.  */
>
>  tree
> -get_vectype_for_scalar_type (tree scalar_type)
> +get_vectype_for_scalar_type (vec_info *, tree scalar_type)
>  {
>    tree vectype;
>    vectype = get_vectype_for_scalar_type_and_size (scalar_type,
> @@ -11157,9 +11158,9 @@ get_vectype_for_scalar_type (tree scalar
>     of vectors of specified SCALAR_TYPE as supported by target.  */
>
>  tree
> -get_mask_type_for_scalar_type (vec_info *, tree scalar_type)
> +get_mask_type_for_scalar_type (vec_info *vinfo, tree scalar_type)
>  {
> -  tree vectype = get_vectype_for_scalar_type (scalar_type);
> +  tree vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
>
>    if (!vectype)
>      return NULL;
> @@ -11853,6 +11854,7 @@ vect_get_vector_types_for_stmt (stmt_vec
>                                 tree *stmt_vectype_out,
>                                 tree *nunits_vectype_out)
>  {
> +  vec_info *vinfo = stmt_info->vinfo;
>    gimple *stmt = stmt_info->stmt;
>
>    *stmt_vectype_out = NULL_TREE;
> @@ -11919,7 +11921,7 @@ vect_get_vector_types_for_stmt (stmt_vec
>        if (dump_enabled_p ())
>         dump_printf_loc (MSG_NOTE, vect_location,
>                          "get vectype for scalar type:  %T\n", scalar_type);
> -      vectype = get_vectype_for_scalar_type (scalar_type);
> +      vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
>        if (!vectype)
>         return opt_result::failure_at (stmt,
>                                        "not vectorized:"
> @@ -11952,7 +11954,7 @@ vect_get_vector_types_for_stmt (stmt_vec
>        if (dump_enabled_p ())
>         dump_printf_loc (MSG_NOTE, vect_location,
>                          "get vectype for scalar type:  %T\n", scalar_type);
> -      nunits_vectype = get_vectype_for_scalar_type (scalar_type);
> +      nunits_vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
>      }
>    if (!nunits_vectype)
>      return opt_result::failure_at (stmt,
> Index: gcc/tree-vect-data-refs.c
> ===================================================================
> --- gcc/tree-vect-data-refs.c   2019-10-11 15:43:54.543490491 +0100
> +++ gcc/tree-vect-data-refs.c   2019-10-20 14:14:09.664722204 +0100
> @@ -4344,7 +4344,7 @@ vect_analyze_data_refs (vec_info *vinfo,
>        /* Set vectype for STMT.  */
>        scalar_type = TREE_TYPE (DR_REF (dr));
>        STMT_VINFO_VECTYPE (stmt_info)
> -       = get_vectype_for_scalar_type (scalar_type);
> +       = get_vectype_for_scalar_type (vinfo, scalar_type);
>        if (!STMT_VINFO_VECTYPE (stmt_info))
>          {
>            if (dump_enabled_p ())
> @@ -4392,7 +4392,8 @@ vect_analyze_data_refs (vec_info *vinfo,
>           if (!vect_check_gather_scatter (stmt_info,
>                                           as_a <loop_vec_info> (vinfo),
>                                           &gs_info)
> -             || !get_vectype_for_scalar_type (TREE_TYPE (gs_info.offset)))
> +             || !get_vectype_for_scalar_type (vinfo,
> +                                              TREE_TYPE (gs_info.offset)))
>             {
>               if (fatal)
>                 *fatal = false;
> Index: gcc/tree-vect-loop.c
> ===================================================================
> --- gcc/tree-vect-loop.c        2019-10-20 13:58:02.095634389 +0100
> +++ gcc/tree-vect-loop.c        2019-10-20 14:14:09.668722173 +0100
> @@ -327,7 +327,7 @@ vect_determine_vectorization_factor (loo
>                                  "get vectype for scalar type:  %T\n",
>                                  scalar_type);
>
> -             vectype = get_vectype_for_scalar_type (scalar_type);
> +             vectype = get_vectype_for_scalar_type (loop_vinfo, scalar_type);
>               if (!vectype)
>                 return opt_result::failure_at (phi,
>                                                "not vectorized: unsupported "
> @@ -3774,7 +3774,7 @@ get_initial_def_for_reduction (stmt_vec_
>    loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
>    class loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
>    tree scalar_type = TREE_TYPE (init_val);
> -  tree vectype = get_vectype_for_scalar_type (scalar_type);
> +  tree vectype = get_vectype_for_scalar_type (loop_vinfo, scalar_type);
>    tree def_for_init;
>    tree init_def;
>    REAL_VALUE_TYPE real_init_val = dconst0;
> @@ -5555,11 +5555,11 @@ build_vect_cond_expr (enum tree_code cod
>     corresponds to the type of arguments to the reduction stmt, and should *NOT*
>     be used to create the vectorized stmt.  The right vectype for the vectorized
>     stmt is obtained from the type of the result X:
> -        get_vectype_for_scalar_type (TREE_TYPE (X))
> +      get_vectype_for_scalar_type (vinfo, TREE_TYPE (X))
>
>     This means that, contrary to "regular" reductions (or "regular" stmts in
>     general), the following equation:
> -      STMT_VINFO_VECTYPE == get_vectype_for_scalar_type (TREE_TYPE (X))
> +      STMT_VINFO_VECTYPE == get_vectype_for_scalar_type (vinfo, TREE_TYPE (X))
>     does *NOT* necessarily hold for reduction patterns.  */
>
>  bool
> Index: gcc/tree-vect-patterns.c
> ===================================================================
> --- gcc/tree-vect-patterns.c    2019-10-20 14:14:06.468745032 +0100
> +++ gcc/tree-vect-patterns.c    2019-10-20 14:14:09.668722173 +0100
> @@ -187,15 +187,15 @@ vect_get_external_def_edge (vec_info *vi
>     is nonnull.  */
>
>  static bool
> -vect_supportable_direct_optab_p (vec_info *, tree otype, tree_code code,
> +vect_supportable_direct_optab_p (vec_info *vinfo, tree otype, tree_code code,
>                                  tree itype, tree *vecotype_out,
>                                  tree *vecitype_out = NULL)
>  {
> -  tree vecitype = get_vectype_for_scalar_type (itype);
> +  tree vecitype = get_vectype_for_scalar_type (vinfo, itype);
>    if (!vecitype)
>      return false;
>
> -  tree vecotype = get_vectype_for_scalar_type (otype);
> +  tree vecotype = get_vectype_for_scalar_type (vinfo, otype);
>    if (!vecotype)
>      return false;
>
> @@ -635,6 +635,7 @@ vect_recog_temp_ssa_var (tree type, gimp
>  vect_split_statement (stmt_vec_info stmt2_info, tree new_rhs,
>                       gimple *stmt1, tree vectype)
>  {
> +  vec_info *vinfo = stmt2_info->vinfo;
>    if (is_pattern_stmt_p (stmt2_info))
>      {
>        /* STMT2_INFO is part of a pattern.  Get the statement to which
> @@ -678,7 +679,7 @@ vect_split_statement (stmt_vec_info stmt
>          two-statement pattern now.  */
>        gcc_assert (!STMT_VINFO_RELATED_STMT (stmt2_info));
>        tree lhs_type = TREE_TYPE (gimple_get_lhs (stmt2_info->stmt));
> -      tree lhs_vectype = get_vectype_for_scalar_type (lhs_type);
> +      tree lhs_vectype = get_vectype_for_scalar_type (vinfo, lhs_type);
>        if (!lhs_vectype)
>         return false;
>
> @@ -715,6 +716,8 @@ vect_split_statement (stmt_vec_info stmt
>  vect_convert_input (stmt_vec_info stmt_info, tree type,
>                     vect_unpromoted_value *unprom, tree vectype)
>  {
> +  vec_info *vinfo = stmt_info->vinfo;
> +
>    /* Check for a no-op conversion.  */
>    if (types_compatible_p (type, TREE_TYPE (unprom->op)))
>      return unprom->op;
> @@ -752,7 +755,7 @@ vect_convert_input (stmt_vec_info stmt_i
>              unsigned promotion.  */
>           tree midtype = build_nonstandard_integer_type
>             (TYPE_PRECISION (type), TYPE_UNSIGNED (unprom->type));
> -         tree vec_midtype = get_vectype_for_scalar_type (midtype);
> +         tree vec_midtype = get_vectype_for_scalar_type (vinfo, midtype);
>           if (vec_midtype)
>             {
>               input = vect_recog_temp_ssa_var (midtype, NULL);
> @@ -1189,6 +1192,7 @@ vect_recog_widen_op_pattern (stmt_vec_in
>                              tree_code orig_code, tree_code wide_code,
>                              bool shift_p, const char *name)
>  {
> +  vec_info *vinfo = last_stmt_info->vinfo;
>    gimple *last_stmt = last_stmt_info->stmt;
>
>    vect_unpromoted_value unprom[2];
> @@ -1208,8 +1212,8 @@ vect_recog_widen_op_pattern (stmt_vec_in
>                                             TYPE_UNSIGNED (half_type));
>
>    /* Check target support  */
> -  tree vectype = get_vectype_for_scalar_type (half_type);
> -  tree vecitype = get_vectype_for_scalar_type (itype);
> +  tree vectype = get_vectype_for_scalar_type (vinfo, half_type);
> +  tree vecitype = get_vectype_for_scalar_type (vinfo, itype);
>    enum tree_code dummy_code;
>    int dummy_int;
>    auto_vec<tree> dummy_vec;
> @@ -1221,7 +1225,7 @@ vect_recog_widen_op_pattern (stmt_vec_in
>                                           &dummy_int, &dummy_vec))
>      return NULL;
>
> -  *type_out = get_vectype_for_scalar_type (type);
> +  *type_out = get_vectype_for_scalar_type (vinfo, type);
>    if (!*type_out)
>      return NULL;
>
> @@ -1342,7 +1346,7 @@ vect_recog_pow_pattern (stmt_vec_info st
>                   if (node->simd_clones == NULL)
>                     return NULL;
>                 }
> -             *type_out = get_vectype_for_scalar_type (TREE_TYPE (base));
> +             *type_out = get_vectype_for_scalar_type (vinfo, TREE_TYPE (base));
>               if (!*type_out)
>                 return NULL;
>               tree def = vect_recog_temp_ssa_var (TREE_TYPE (base), NULL);
> @@ -1380,7 +1384,7 @@ vect_recog_pow_pattern (stmt_vec_info st
>    if (TREE_CODE (exp) == REAL_CST
>        && real_equal (&TREE_REAL_CST (exp), &dconsthalf))
>      {
> -      *type_out = get_vectype_for_scalar_type (TREE_TYPE (base));
> +      *type_out = get_vectype_for_scalar_type (vinfo, TREE_TYPE (base));
>        if (*type_out
>           && direct_internal_fn_supported_p (IFN_SQRT, *type_out,
>                                              OPTIMIZE_FOR_SPEED))
> @@ -1665,7 +1669,7 @@ vect_recog_over_widening_pattern (stmt_v
>
>    vect_pattern_detected ("vect_recog_over_widening_pattern", last_stmt);
>
> -  *type_out = get_vectype_for_scalar_type (type);
> +  *type_out = get_vectype_for_scalar_type (vinfo, type);
>    if (!*type_out)
>      return NULL;
>
> @@ -1686,8 +1690,8 @@ vect_recog_over_widening_pattern (stmt_v
>       wants to rewrite anyway.  If targets have a minimum element size
>       for some optabs, we should pattern-match smaller ops to larger ops
>       where beneficial.  */
> -  tree new_vectype = get_vectype_for_scalar_type (new_type);
> -  tree op_vectype = get_vectype_for_scalar_type (op_type);
> +  tree new_vectype = get_vectype_for_scalar_type (vinfo, new_type);
> +  tree op_vectype = get_vectype_for_scalar_type (vinfo, op_type);
>    if (!new_vectype || !op_vectype)
>      return NULL;
>
> @@ -1864,7 +1868,7 @@ vect_recog_mulhs_pattern (stmt_vec_info
>        (target_precision, TYPE_UNSIGNED (new_type));
>
>    /* Check for target support.  */
> -  tree new_vectype = get_vectype_for_scalar_type (new_type);
> +  tree new_vectype = get_vectype_for_scalar_type (vinfo, new_type);
>    if (!new_vectype
>        || !direct_internal_fn_supported_p
>             (ifn, new_vectype, OPTIMIZE_FOR_SPEED))
> @@ -1872,7 +1876,7 @@ vect_recog_mulhs_pattern (stmt_vec_info
>
>    /* The IR requires a valid vector type for the cast result, even though
>       it's likely to be discarded.  */
> -  *type_out = get_vectype_for_scalar_type (lhs_type);
> +  *type_out = get_vectype_for_scalar_type (vinfo, lhs_type);
>    if (!*type_out)
>      return NULL;
>
> @@ -2014,7 +2018,7 @@ vect_recog_average_pattern (stmt_vec_inf
>                                                TYPE_UNSIGNED (new_type));
>
>    /* Check for target support.  */
> -  tree new_vectype = get_vectype_for_scalar_type (new_type);
> +  tree new_vectype = get_vectype_for_scalar_type (vinfo, new_type);
>    if (!new_vectype
>        || !direct_internal_fn_supported_p (ifn, new_vectype,
>                                           OPTIMIZE_FOR_SPEED))
> @@ -2022,7 +2026,7 @@ vect_recog_average_pattern (stmt_vec_inf
>
>    /* The IR requires a valid vector type for the cast result, even though
>       it's likely to be discarded.  */
> -  *type_out = get_vectype_for_scalar_type (type);
> +  *type_out = get_vectype_for_scalar_type (vinfo, type);
>    if (!*type_out)
>      return NULL;
>
> @@ -2108,7 +2112,7 @@ vect_recog_cast_forwprop_pattern (stmt_v
>       the unnecessary widening and narrowing.  */
>    vect_pattern_detected ("vect_recog_cast_forwprop_pattern", last_stmt);
>
> -  *type_out = get_vectype_for_scalar_type (lhs_type);
> +  *type_out = get_vectype_for_scalar_type (vinfo, lhs_type);
>    if (!*type_out)
>      return NULL;
>
> @@ -2219,7 +2223,7 @@ vect_recog_rotate_pattern (stmt_vec_info
>         }
>
>        type = TREE_TYPE (lhs);
> -      vectype = get_vectype_for_scalar_type (type);
> +      vectype = get_vectype_for_scalar_type (vinfo, type);
>        if (vectype == NULL_TREE)
>         return NULL;
>
> @@ -2285,7 +2289,7 @@ vect_recog_rotate_pattern (stmt_vec_info
>        && dt != vect_external_def)
>      return NULL;
>
> -  vectype = get_vectype_for_scalar_type (type);
> +  vectype = get_vectype_for_scalar_type (vinfo, type);
>    if (vectype == NULL_TREE)
>      return NULL;
>
> @@ -2404,7 +2408,7 @@ vect_recog_rotate_pattern (stmt_vec_info
>      }
>    else
>      {
> -      tree vecstype = get_vectype_for_scalar_type (stype);
> +      tree vecstype = get_vectype_for_scalar_type (vinfo, stype);
>
>        if (vecstype == NULL_TREE)
>         return NULL;
> @@ -2533,7 +2537,7 @@ vect_recog_vector_vector_shift_pattern (
>    if (!def_vinfo)
>      return NULL;
>
> -  *type_out = get_vectype_for_scalar_type (TREE_TYPE (oprnd0));
> +  *type_out = get_vectype_for_scalar_type (vinfo, TREE_TYPE (oprnd0));
>    if (*type_out == NULL_TREE)
>      return NULL;
>
> @@ -2556,7 +2560,8 @@ vect_recog_vector_vector_shift_pattern (
>                                        TYPE_PRECISION (TREE_TYPE (oprnd1)));
>               def = vect_recog_temp_ssa_var (TREE_TYPE (rhs1), NULL);
>               def_stmt = gimple_build_assign (def, BIT_AND_EXPR, rhs1, mask);
> -             tree vecstype = get_vectype_for_scalar_type (TREE_TYPE (rhs1));
> +             tree vecstype = get_vectype_for_scalar_type (vinfo,
> +                                                          TREE_TYPE (rhs1));
>               append_pattern_def_seq (stmt_vinfo, def_stmt, vecstype);
>             }
>         }
> @@ -2751,7 +2756,7 @@ vect_synth_mult_by_constant (tree op, tr
>    if (!possible)
>      return NULL;
>
> -  tree vectype = get_vectype_for_scalar_type (multtype);
> +  tree vectype = get_vectype_for_scalar_type (vinfo, multtype);
>
>    if (!vectype
>        || !target_supports_mult_synth_alg (&alg, variant,
> @@ -2897,6 +2902,7 @@ vect_synth_mult_by_constant (tree op, tr
>  static gimple *
>  vect_recog_mult_pattern (stmt_vec_info stmt_vinfo, tree *type_out)
>  {
> +  vec_info *vinfo = stmt_vinfo->vinfo;
>    gimple *last_stmt = stmt_vinfo->stmt;
>    tree oprnd0, oprnd1, vectype, itype;
>    gimple *pattern_stmt;
> @@ -2917,7 +2923,7 @@ vect_recog_mult_pattern (stmt_vec_info s
>        || !type_has_mode_precision_p (itype))
>      return NULL;
>
> -  vectype = get_vectype_for_scalar_type (itype);
> +  vectype = get_vectype_for_scalar_type (vinfo, itype);
>    if (vectype == NULL_TREE)
>      return NULL;
>
> @@ -2985,6 +2991,7 @@ vect_recog_mult_pattern (stmt_vec_info s
>  static gimple *
>  vect_recog_divmod_pattern (stmt_vec_info stmt_vinfo, tree *type_out)
>  {
> +  vec_info *vinfo = stmt_vinfo->vinfo;
>    gimple *last_stmt = stmt_vinfo->stmt;
>    tree oprnd0, oprnd1, vectype, itype, cond;
>    gimple *pattern_stmt, *def_stmt;
> @@ -3017,7 +3024,7 @@ vect_recog_divmod_pattern (stmt_vec_info
>      return NULL;
>
>    scalar_int_mode itype_mode = SCALAR_INT_TYPE_MODE (itype);
> -  vectype = get_vectype_for_scalar_type (itype);
> +  vectype = get_vectype_for_scalar_type (vinfo, itype);
>    if (vectype == NULL_TREE)
>      return NULL;
>
> @@ -3115,7 +3122,7 @@ vect_recog_divmod_pattern (stmt_vec_info
>             {
>               tree utype
>                 = build_nonstandard_integer_type (prec, 1);
> -             tree vecutype = get_vectype_for_scalar_type (utype);
> +             tree vecutype = get_vectype_for_scalar_type (vinfo, utype);
>               tree shift
>                 = build_int_cst (utype, GET_MODE_BITSIZE (itype_mode)
>                                         - tree_log2 (oprnd1));
> @@ -3433,6 +3440,7 @@ vect_recog_divmod_pattern (stmt_vec_info
>  static gimple *
>  vect_recog_mixed_size_cond_pattern (stmt_vec_info stmt_vinfo, tree *type_out)
>  {
> +  vec_info *vinfo = stmt_vinfo->vinfo;
>    gimple *last_stmt = stmt_vinfo->stmt;
>    tree cond_expr, then_clause, else_clause;
>    tree type, vectype, comp_vectype, itype = NULL_TREE, vecitype;
> @@ -3455,7 +3463,7 @@ vect_recog_mixed_size_cond_pattern (stmt
>      return NULL;
>
>    comp_scalar_type = TREE_TYPE (TREE_OPERAND (cond_expr, 0));
> -  comp_vectype = get_vectype_for_scalar_type (comp_scalar_type);
> +  comp_vectype = get_vectype_for_scalar_type (vinfo, comp_scalar_type);
>    if (comp_vectype == NULL_TREE)
>      return NULL;
>
> @@ -3503,7 +3511,7 @@ vect_recog_mixed_size_cond_pattern (stmt
>    if (GET_MODE_BITSIZE (type_mode) == cmp_mode_size)
>      return NULL;
>
> -  vectype = get_vectype_for_scalar_type (type);
> +  vectype = get_vectype_for_scalar_type (vinfo, type);
>    if (vectype == NULL_TREE)
>      return NULL;
>
> @@ -3518,7 +3526,7 @@ vect_recog_mixed_size_cond_pattern (stmt
>        || GET_MODE_BITSIZE (SCALAR_TYPE_MODE (itype)) != cmp_mode_size)
>      return NULL;
>
> -  vecitype = get_vectype_for_scalar_type (itype);
> +  vecitype = get_vectype_for_scalar_type (vinfo, itype);
>    if (vecitype == NULL_TREE)
>      return NULL;
>
> @@ -3612,7 +3620,7 @@ check_bool_pattern (tree var, vec_info *
>           if (stmt_could_throw_p (cfun, def_stmt))
>             return false;
>
> -         comp_vectype = get_vectype_for_scalar_type (TREE_TYPE (rhs1));
> +         comp_vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (rhs1));
>           if (comp_vectype == NULL_TREE)
>             return false;
>
> @@ -3627,7 +3635,7 @@ check_bool_pattern (tree var, vec_info *
>               scalar_mode mode = SCALAR_TYPE_MODE (TREE_TYPE (rhs1));
>               tree itype
>                 = build_nonstandard_integer_type (GET_MODE_BITSIZE (mode), 1);
> -             vecitype = get_vectype_for_scalar_type (itype);
> +             vecitype = get_vectype_for_scalar_type (vinfo, itype);
>               if (vecitype == NULL_TREE)
>                 return false;
>             }
> @@ -3656,10 +3664,11 @@ check_bool_pattern (tree var, vec_info *
>  static tree
>  adjust_bool_pattern_cast (tree type, tree var, stmt_vec_info stmt_info)
>  {
> +  vec_info *vinfo = stmt_info->vinfo;
>    gimple *cast_stmt = gimple_build_assign (vect_recog_temp_ssa_var (type, NULL),
>                                            NOP_EXPR, var);
>    append_pattern_def_seq (stmt_info, cast_stmt,
> -                         get_vectype_for_scalar_type (type));
> +                         get_vectype_for_scalar_type (vinfo, type));
>    return gimple_assign_lhs (cast_stmt);
>  }
>
> @@ -3673,6 +3682,7 @@ adjust_bool_pattern_cast (tree type, tre
>  adjust_bool_pattern (tree var, tree out_type,
>                      stmt_vec_info stmt_info, hash_map <tree, tree> &defs)
>  {
> +  vec_info *vinfo = stmt_info->vinfo;
>    gimple *stmt = SSA_NAME_DEF_STMT (var);
>    enum tree_code rhs_code, def_rhs_code;
>    tree itype, cond_expr, rhs1, rhs2, irhs1, irhs2;
> @@ -3834,7 +3844,7 @@ adjust_bool_pattern (tree var, tree out_
>
>    gimple_set_location (pattern_stmt, loc);
>    append_pattern_def_seq (stmt_info, pattern_stmt,
> -                         get_vectype_for_scalar_type (itype));
> +                         get_vectype_for_scalar_type (vinfo, itype));
>    defs.put (var, gimple_assign_lhs (pattern_stmt));
>  }
>
> @@ -3937,7 +3947,7 @@ search_type_for_mask_1 (tree var, vec_in
>               break;
>             }
>
> -         comp_vectype = get_vectype_for_scalar_type (TREE_TYPE (rhs1));
> +         comp_vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (rhs1));
>           if (comp_vectype == NULL_TREE)
>             {
>               res = NULL_TREE;
> @@ -4052,7 +4062,7 @@ vect_recog_bool_pattern (stmt_vec_info s
>        if (! INTEGRAL_TYPE_P (TREE_TYPE (lhs))
>           || TYPE_PRECISION (TREE_TYPE (lhs)) == 1)
>         return NULL;
> -      vectype = get_vectype_for_scalar_type (TREE_TYPE (lhs));
> +      vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs));
>        if (vectype == NULL_TREE)
>         return NULL;
>
> @@ -4089,7 +4099,7 @@ vect_recog_bool_pattern (stmt_vec_info s
>
>           if (!useless_type_conversion_p (type, TREE_TYPE (lhs)))
>             {
> -             tree new_vectype = get_vectype_for_scalar_type (type);
> +             tree new_vectype = get_vectype_for_scalar_type (vinfo, type);
>               append_pattern_def_seq (stmt_vinfo, pattern_stmt, new_vectype);
>
>               lhs = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL);
> @@ -4105,7 +4115,7 @@ vect_recog_bool_pattern (stmt_vec_info s
>    else if (rhs_code == COND_EXPR
>            && TREE_CODE (var) == SSA_NAME)
>      {
> -      vectype = get_vectype_for_scalar_type (TREE_TYPE (lhs));
> +      vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs));
>        if (vectype == NULL_TREE)
>         return NULL;
>
> @@ -4119,7 +4129,7 @@ vect_recog_bool_pattern (stmt_vec_info s
>        tree type
>         = build_nonstandard_integer_type (prec,
>                                           TYPE_UNSIGNED (TREE_TYPE (var)));
> -      if (get_vectype_for_scalar_type (type) == NULL_TREE)
> +      if (get_vectype_for_scalar_type (vinfo, type) == NULL_TREE)
>         return NULL;
>
>        if (!check_bool_pattern (var, vinfo, bool_stmts))
> @@ -4163,7 +4173,7 @@ vect_recog_bool_pattern (stmt_vec_info s
>
>           cst0 = build_int_cst (type, 0);
>           cst1 = build_int_cst (type, 1);
> -         new_vectype = get_vectype_for_scalar_type (type);
> +         new_vectype = get_vectype_for_scalar_type (vinfo, type);
>
>           rhs = vect_recog_temp_ssa_var (type, NULL);
>           pattern_stmt = gimple_build_assign (rhs, COND_EXPR, var, cst1, cst0);
> @@ -4264,12 +4274,12 @@ vect_recog_mask_conversion_pattern (stmt
>         {
>           int rhs_index = internal_fn_stored_value_index (ifn);
>           tree rhs = gimple_call_arg (last_stmt, rhs_index);
> -         vectype1 = get_vectype_for_scalar_type (TREE_TYPE (rhs));
> +         vectype1 = get_vectype_for_scalar_type (vinfo, TREE_TYPE (rhs));
>         }
>        else
>         {
>           lhs = gimple_call_lhs (last_stmt);
> -         vectype1 = get_vectype_for_scalar_type (TREE_TYPE (lhs));
> +         vectype1 = get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs));
>         }
>
>        tree mask_arg = gimple_call_arg (last_stmt, mask_argno);
> @@ -4322,7 +4332,7 @@ vect_recog_mask_conversion_pattern (stmt
>    /* Check for cond expression requiring mask conversion.  */
>    if (rhs_code == COND_EXPR)
>      {
> -      vectype1 = get_vectype_for_scalar_type (TREE_TYPE (lhs));
> +      vectype1 = get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs));
>
>        if (TREE_CODE (rhs1) == SSA_NAME)
>         {
> @@ -4388,7 +4398,8 @@ vect_recog_mask_conversion_pattern (stmt
>               tree wide_scalar_type = build_nonstandard_integer_type
>                 (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (vectype1))),
>                  TYPE_UNSIGNED (rhs1_type));
> -             tree vectype3 = get_vectype_for_scalar_type (wide_scalar_type);
> +             tree vectype3 = get_vectype_for_scalar_type (vinfo,
> +                                                          wide_scalar_type);
>               if (expand_vec_cond_expr_p (vectype1, vectype3, TREE_CODE (rhs1)))
>                 return NULL;
>             }
> @@ -4544,10 +4555,11 @@ vect_add_conversion_to_pattern (tree typ
>    if (useless_type_conversion_p (type, TREE_TYPE (value)))
>      return value;
>
> +  vec_info *vinfo = stmt_info->vinfo;
>    tree new_value = vect_recog_temp_ssa_var (type, NULL);
>    gassign *conversion = gimple_build_assign (new_value, CONVERT_EXPR, value);
>    append_pattern_def_seq (stmt_info, conversion,
> -                         get_vectype_for_scalar_type (type));
> +                         get_vectype_for_scalar_type (vinfo, type));
>    return new_value;
>  }
>
> @@ -4583,7 +4595,8 @@ vect_recog_gather_scatter_pattern (stmt_
>      return NULL;
>
>    /* Convert the mask to the right form.  */
> -  tree gs_vectype = get_vectype_for_scalar_type (gs_info.element_type);
> +  tree gs_vectype = get_vectype_for_scalar_type (loop_vinfo,
> +                                                gs_info.element_type);
>    if (mask)
>      mask = vect_convert_mask_for_vectype (mask, gs_vectype, stmt_info,
>                                           loop_vinfo);
> Index: gcc/tree-vect-slp.c
> ===================================================================
> --- gcc/tree-vect-slp.c 2019-10-20 13:59:25.923035567 +0100
> +++ gcc/tree-vect-slp.c 2019-10-20 14:14:09.668722173 +0100
> @@ -1127,7 +1127,7 @@ vect_build_slp_tree_2 (vec_info *vinfo,
>    if (gphi *stmt = dyn_cast <gphi *> (stmt_info->stmt))
>      {
>        tree scalar_type = TREE_TYPE (PHI_RESULT (stmt));
> -      tree vectype = get_vectype_for_scalar_type (scalar_type);
> +      tree vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
>        if (!vect_record_max_nunits (stmt_info, group_size, vectype, max_nunits))
>         return NULL;
>
> @@ -1926,7 +1926,7 @@ vect_analyze_slp_instance (vec_info *vin
>    if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
>      {
>        scalar_type = TREE_TYPE (DR_REF (dr));
> -      vectype = get_vectype_for_scalar_type (scalar_type);
> +      vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
>        group_size = DR_GROUP_SIZE (stmt_info);
>      }
>    else if (!dr && REDUC_GROUP_FIRST_ELEMENT (stmt_info))
> @@ -3287,6 +3287,7 @@ vect_get_constant_vectors (tree op, slp_
>  {
>    vec<stmt_vec_info> stmts = SLP_TREE_SCALAR_STMTS (slp_node);
>    stmt_vec_info stmt_vinfo = stmts[0];
> +  vec_info *vinfo = stmt_vinfo->vinfo;
>    gimple *stmt = stmt_vinfo->stmt;
>    unsigned HOST_WIDE_INT nunits;
>    tree vec_cst;
> @@ -3310,7 +3311,7 @@ vect_get_constant_vectors (tree op, slp_
>      vector_type
>        = build_same_sized_truth_vector_type (STMT_VINFO_VECTYPE (stmt_vinfo));
>    else
> -    vector_type = get_vectype_for_scalar_type (TREE_TYPE (op));
> +    vector_type = get_vectype_for_scalar_type (vinfo, TREE_TYPE (op));
>
>    if (STMT_VINFO_DATA_REF (stmt_vinfo))
>      {
>
>
> Pass a vec_info to duplicate_and_interleave
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vectorizer.h (duplicate_and_interleave): Take a vec_info.
>         * tree-vect-slp.c (duplicate_and_interleave): Likewise.
>         (vect_get_constant_vectors): Update call accordingly.
>         * tree-vect-loop.c (get_initial_defs_for_reduction): Likewise.
>
> Index: gcc/tree-vectorizer.h
> ===================================================================
> --- gcc/tree-vectorizer.h       2019-10-20 14:14:09.672722145 +0100
> +++ gcc/tree-vectorizer.h       2019-10-20 14:14:13.256696547 +0100
> @@ -1754,8 +1754,8 @@ extern bool is_simple_and_all_uses_invar
>  extern bool can_duplicate_and_interleave_p (unsigned int, machine_mode,
>                                             unsigned int * = NULL,
>                                             tree * = NULL, tree * = NULL);
> -extern void duplicate_and_interleave (gimple_seq *, tree, vec<tree>,
> -                                     unsigned int, vec<tree> &);
> +extern void duplicate_and_interleave (vec_info *, gimple_seq *, tree,
> +                                     vec<tree>, unsigned int, vec<tree> &);
>  extern int vect_get_place_in_interleaving_chain (stmt_vec_info, stmt_vec_info);
>
>  /* In tree-vect-patterns.c.  */
> Index: gcc/tree-vect-slp.c
> ===================================================================
> --- gcc/tree-vect-slp.c 2019-10-20 14:14:09.668722173 +0100
> +++ gcc/tree-vect-slp.c 2019-10-20 14:14:13.256696547 +0100
> @@ -3183,8 +3183,9 @@ vect_mask_constant_operand_p (stmt_vec_i
>     to cut down on the number of interleaves.  */
>
>  void
> -duplicate_and_interleave (gimple_seq *seq, tree vector_type, vec<tree> elts,
> -                         unsigned int nresults, vec<tree> &results)
> +duplicate_and_interleave (vec_info *, gimple_seq *seq, tree vector_type,
> +                         vec<tree> elts, unsigned int nresults,
> +                         vec<tree> &results)
>  {
>    unsigned int nelts = elts.length ();
>    tree element_type = TREE_TYPE (vector_type);
> @@ -3473,8 +3474,8 @@ vect_get_constant_vectors (tree op, slp_
>               else
>                 {
>                   if (vec_oprnds->is_empty ())
> -                   duplicate_and_interleave (&ctor_seq, vector_type, elts,
> -                                             number_of_vectors,
> +                   duplicate_and_interleave (vinfo, &ctor_seq, vector_type,
> +                                             elts, number_of_vectors,
>                                               permute_results);
>                   vec_cst = permute_results[number_of_vectors - j - 1];
>                 }
> Index: gcc/tree-vect-loop.c
> ===================================================================
> --- gcc/tree-vect-loop.c        2019-10-20 14:14:09.668722173 +0100
> +++ gcc/tree-vect-loop.c        2019-10-20 14:14:13.252696575 +0100
> @@ -3878,6 +3878,7 @@ get_initial_defs_for_reduction (slp_tree
>  {
>    vec<stmt_vec_info> stmts = SLP_TREE_SCALAR_STMTS (slp_node);
>    stmt_vec_info stmt_vinfo = stmts[0];
> +  vec_info *vinfo = stmt_vinfo->vinfo;
>    unsigned HOST_WIDE_INT nunits;
>    unsigned j, number_of_places_left_in_vector;
>    tree vector_type;
> @@ -3970,7 +3971,7 @@ get_initial_defs_for_reduction (slp_tree
>             {
>               /* First time round, duplicate ELTS to fill the
>                  required number of vectors.  */
> -             duplicate_and_interleave (&ctor_seq, vector_type, elts,
> +             duplicate_and_interleave (vinfo, &ctor_seq, vector_type, elts,
>                                         number_of_vectors, *vec_oprnds);
>               break;
>             }
>
>
> Pass a vec_info to can_duplicate_and_interleave_p
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vectorizer.h (can_duplicate_and_interleave_p): Take a vec_info.
>         * tree-vect-slp.c (can_duplicate_and_interleave_p): Likewise.
>         (duplicate_and_interleave): Update call accordingly.
>         * tree-vect-loop.c (vectorizable_reduction): Likewise.
>
> Index: gcc/tree-vectorizer.h
> ===================================================================
> --- gcc/tree-vectorizer.h       2019-10-20 14:14:13.256696547 +0100
> +++ gcc/tree-vectorizer.h       2019-10-20 14:14:16.688672033 +0100
> @@ -1751,7 +1751,8 @@ extern void vect_get_slp_defs (vec<tree>
>  extern bool vect_slp_bb (basic_block);
>  extern stmt_vec_info vect_find_last_scalar_stmt_in_slp (slp_tree);
>  extern bool is_simple_and_all_uses_invariant (stmt_vec_info, loop_vec_info);
> -extern bool can_duplicate_and_interleave_p (unsigned int, machine_mode,
> +extern bool can_duplicate_and_interleave_p (vec_info *, unsigned int,
> +                                           machine_mode,
>                                             unsigned int * = NULL,
>                                             tree * = NULL, tree * = NULL);
>  extern void duplicate_and_interleave (vec_info *, gimple_seq *, tree,
> Index: gcc/tree-vect-slp.c
> ===================================================================
> --- gcc/tree-vect-slp.c 2019-10-20 14:14:13.256696547 +0100
> +++ gcc/tree-vect-slp.c 2019-10-20 14:14:16.688672033 +0100
> @@ -233,7 +233,8 @@ vect_get_place_in_interleaving_chain (st
>     (if nonnull).  */
>
>  bool
> -can_duplicate_and_interleave_p (unsigned int count, machine_mode elt_mode,
> +can_duplicate_and_interleave_p (vec_info *, unsigned int count,
> +                               machine_mode elt_mode,
>                                 unsigned int *nvectors_out,
>                                 tree *vector_type_out,
>                                 tree *permutes)
> @@ -432,7 +433,7 @@ vect_get_and_check_slp_defs (vec_info *v
>                || dt == vect_external_def)
>               && !current_vector_size.is_constant ()
>               && (TREE_CODE (type) == BOOLEAN_TYPE
> -                 || !can_duplicate_and_interleave_p (stmts.length (),
> +                 || !can_duplicate_and_interleave_p (vinfo, stmts.length (),
>                                                       TYPE_MODE (type))))
>             {
>               if (dump_enabled_p ())
> @@ -3183,7 +3184,7 @@ vect_mask_constant_operand_p (stmt_vec_i
>     to cut down on the number of interleaves.  */
>
>  void
> -duplicate_and_interleave (vec_info *, gimple_seq *seq, tree vector_type,
> +duplicate_and_interleave (vec_info *vinfo, gimple_seq *seq, tree vector_type,
>                           vec<tree> elts, unsigned int nresults,
>                           vec<tree> &results)
>  {
> @@ -3194,7 +3195,7 @@ duplicate_and_interleave (vec_info *, gi
>    unsigned int nvectors = 1;
>    tree new_vector_type;
>    tree permutes[2];
> -  if (!can_duplicate_and_interleave_p (nelts, TYPE_MODE (element_type),
> +  if (!can_duplicate_and_interleave_p (vinfo, nelts, TYPE_MODE (element_type),
>                                        &nvectors, &new_vector_type,
>                                        permutes))
>      gcc_unreachable ();
> Index: gcc/tree-vect-loop.c
> ===================================================================
> --- gcc/tree-vect-loop.c        2019-10-20 14:14:13.252696575 +0100
> +++ gcc/tree-vect-loop.c        2019-10-20 14:14:16.684672061 +0100
> @@ -6145,7 +6145,8 @@ vectorizable_reduction (stmt_vec_info st
>        unsigned int group_size = SLP_INSTANCE_GROUP_SIZE (slp_node_instance);
>        scalar_mode elt_mode = SCALAR_TYPE_MODE (TREE_TYPE (vectype_out));
>        if (!neutral_op
> -         && !can_duplicate_and_interleave_p (group_size, elt_mode))
> +         && !can_duplicate_and_interleave_p (loop_vinfo, group_size,
> +                                             elt_mode))
>         {
>           if (dump_enabled_p ())
>             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>
>
> Pass a vec_info to simple_integer_narrowing
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vect-stmts.c (simple_integer_narrowing): Take a vec_info.
>         (vectorizable_call): Update call accordingly.
>
> Index: gcc/tree-vect-stmts.c
> ===================================================================
> --- gcc/tree-vect-stmts.c       2019-10-20 14:14:09.672722145 +0100
> +++ gcc/tree-vect-stmts.c       2019-10-20 14:14:19.748650179 +0100
> @@ -3175,7 +3175,7 @@ vectorizable_bswap (stmt_vec_info stmt_i
>     *CONVERT_CODE.  */
>
>  static bool
> -simple_integer_narrowing (tree vectype_out, tree vectype_in,
> +simple_integer_narrowing (vec_info *, tree vectype_out, tree vectype_in,
>                           tree_code *convert_code)
>  {
>    if (!INTEGRAL_TYPE_P (TREE_TYPE (vectype_out))
> @@ -3369,7 +3369,7 @@ vectorizable_call (stmt_vec_info stmt_in
>    if (cfn != CFN_LAST
>        && (modifier == NONE
>           || (modifier == NARROW
> -             && simple_integer_narrowing (vectype_out, vectype_in,
> +             && simple_integer_narrowing (vinfo, vectype_out, vectype_in,
>                                            &convert_code))))
>      ifn = vectorizable_internal_function (cfn, callee, vectype_out,
>                                           vectype_in);
>
>
> Pass a vec_info to supportable_narrowing_operation
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vectorizer.h (supportable_narrowing_operation): Take a vec_info.
>         * tree-vect-stmts.c (supportable_narrowing_operation): Likewise.
>         (simple_integer_narrowing): Update call accordingly.
>         (vectorizable_conversion): Likewise.
>
> Index: gcc/tree-vectorizer.h
> ===================================================================
> --- gcc/tree-vectorizer.h       2019-10-20 14:14:16.688672033 +0100
> +++ gcc/tree-vectorizer.h       2019-10-20 14:14:23.176625692 +0100
> @@ -1603,8 +1603,8 @@ extern bool supportable_widening_operati
>                                             tree, tree, enum tree_code *,
>                                             enum tree_code *, int *,
>                                             vec<tree> *);
> -extern bool supportable_narrowing_operation (enum tree_code, tree, tree,
> -                                            enum tree_code *,
> +extern bool supportable_narrowing_operation (vec_info *, enum tree_code, tree,
> +                                            tree, enum tree_code *,
>                                              int *, vec<tree> *);
>  extern unsigned record_stmt_cost (stmt_vector_for_cost *, int,
>                                   enum vect_cost_for_stmt, stmt_vec_info,
> Index: gcc/tree-vect-stmts.c
> ===================================================================
> --- gcc/tree-vect-stmts.c       2019-10-20 14:14:19.748650179 +0100
> +++ gcc/tree-vect-stmts.c       2019-10-20 14:14:23.176625692 +0100
> @@ -3175,7 +3175,7 @@ vectorizable_bswap (stmt_vec_info stmt_i
>     *CONVERT_CODE.  */
>
>  static bool
> -simple_integer_narrowing (vec_info *, tree vectype_out, tree vectype_in,
> +simple_integer_narrowing (vec_info *vinfo, tree vectype_out, tree vectype_in,
>                           tree_code *convert_code)
>  {
>    if (!INTEGRAL_TYPE_P (TREE_TYPE (vectype_out))
> @@ -3185,8 +3185,8 @@ simple_integer_narrowing (vec_info *, tr
>    tree_code code;
>    int multi_step_cvt = 0;
>    auto_vec <tree, 8> interm_types;
> -  if (!supportable_narrowing_operation (NOP_EXPR, vectype_out, vectype_in,
> -                                       &code, &multi_step_cvt,
> +  if (!supportable_narrowing_operation (vinfo, NOP_EXPR, vectype_out,
> +                                       vectype_in, &code, &multi_step_cvt,
>                                         &interm_types)
>        || multi_step_cvt)
>      return false;
> @@ -4957,8 +4957,8 @@ vectorizable_conversion (stmt_vec_info s
>
>      case NARROW:
>        gcc_assert (op_type == unary_op);
> -      if (supportable_narrowing_operation (code, vectype_out, vectype_in,
> -                                          &code1, &multi_step_cvt,
> +      if (supportable_narrowing_operation (vinfo, code, vectype_out,
> +                                          vectype_in, &code1, &multi_step_cvt,
>                                            &interm_types))
>         break;
>
> @@ -4974,8 +4974,8 @@ vectorizable_conversion (stmt_vec_info s
>        if (!supportable_convert_operation (code, cvt_type, vectype_in,
>                                           &decl1, &codecvt1))
>         goto unsupported;
> -      if (supportable_narrowing_operation (NOP_EXPR, vectype_out, cvt_type,
> -                                          &code1, &multi_step_cvt,
> +      if (supportable_narrowing_operation (vinfo, NOP_EXPR, vectype_out,
> +                                          cvt_type, &code1, &multi_step_cvt,
>                                            &interm_types))
>         break;
>        goto unsupported;
> @@ -11649,7 +11649,7 @@ supportable_widening_operation (enum tre
>     narrowing operation (short in the above example).   */
>
>  bool
> -supportable_narrowing_operation (enum tree_code code,
> +supportable_narrowing_operation (vec_info *, enum tree_code code,
>                                  tree vectype_out, tree vectype_in,
>                                  enum tree_code *code1, int *multi_step_cvt,
>                                   vec<tree> *interm_types)
>
>
> Pass a loop_vec_info to vect_maybe_permute_loop_masks
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vect-loop-manip.c (vect_maybe_permute_loop_masks): Take
>         a loop_vec_info.
>         (vect_set_loop_condition_masked): Update call accordingly.
>
> Index: gcc/tree-vect-loop-manip.c
> ===================================================================
> --- gcc/tree-vect-loop-manip.c  2019-10-17 14:22:54.919313309 +0100
> +++ gcc/tree-vect-loop-manip.c  2019-10-20 14:14:26.736600265 +0100
> @@ -317,7 +317,8 @@ interleave_supported_p (vec_perm_indices
>     latter.  Return true on success, adding any new statements to SEQ.  */
>
>  static bool
> -vect_maybe_permute_loop_masks (gimple_seq *seq, rgroup_masks *dest_rgm,
> +vect_maybe_permute_loop_masks (loop_vec_info, gimple_seq *seq,
> +                              rgroup_masks *dest_rgm,
>                                rgroup_masks *src_rgm)
>  {
>    tree src_masktype = src_rgm->mask_type;
> @@ -689,7 +690,8 @@ vect_set_loop_condition_masked (class lo
>           {
>             rgroup_masks *half_rgm = &(*masks)[nmasks / 2 - 1];
>             if (!half_rgm->masks.is_empty ()
> -               && vect_maybe_permute_loop_masks (&header_seq, rgm, half_rgm))
> +               && vect_maybe_permute_loop_masks (loop_vinfo, &header_seq,
> +                                                 rgm, half_rgm))
>               continue;
>           }
>
>
> Pass a vec_info to vect_halve_mask_nunits
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vectorizer.h (vect_halve_mask_nunits): Take a vec_info.
>         * tree-vect-loop.c (vect_halve_mask_nunits): Likewise.
>         * tree-vect-loop-manip.c (vect_maybe_permute_loop_masks): Update
>         call accordingly.
>         * tree-vect-stmts.c (supportable_widening_operation): Likewise.
>
> Index: gcc/tree-vectorizer.h
> ===================================================================
> --- gcc/tree-vectorizer.h       2019-10-20 14:14:23.176625692 +0100
> +++ gcc/tree-vectorizer.h       2019-10-20 14:14:30.500573381 +0100
> @@ -1705,7 +1705,7 @@ extern opt_loop_vec_info vect_analyze_lo
>  extern tree vect_build_loop_niters (loop_vec_info, bool * = NULL);
>  extern void vect_gen_vector_loop_niters (loop_vec_info, tree, tree *,
>                                          tree *, bool);
> -extern tree vect_halve_mask_nunits (tree);
> +extern tree vect_halve_mask_nunits (vec_info *, tree);
>  extern tree vect_double_mask_nunits (tree);
>  extern void vect_record_loop_mask (loop_vec_info, vec_loop_masks *,
>                                    unsigned int, tree, tree);
> Index: gcc/tree-vect-loop.c
> ===================================================================
> --- gcc/tree-vect-loop.c        2019-10-20 14:14:16.684672061 +0100
> +++ gcc/tree-vect-loop.c        2019-10-20 14:14:30.496573409 +0100
> @@ -7745,7 +7745,7 @@ loop_niters_no_overflow (loop_vec_info l
>  /* Return a mask type with half the number of elements as TYPE.  */
>
>  tree
> -vect_halve_mask_nunits (tree type)
> +vect_halve_mask_nunits (vec_info *, tree type)
>  {
>    poly_uint64 nunits = exact_div (TYPE_VECTOR_SUBPARTS (type), 2);
>    return build_truth_vector_type (nunits, current_vector_size);
> Index: gcc/tree-vect-loop-manip.c
> ===================================================================
> --- gcc/tree-vect-loop-manip.c  2019-10-20 14:14:26.736600265 +0100
> +++ gcc/tree-vect-loop-manip.c  2019-10-20 14:14:30.496573409 +0100
> @@ -317,7 +317,7 @@ interleave_supported_p (vec_perm_indices
>     latter.  Return true on success, adding any new statements to SEQ.  */
>
>  static bool
> -vect_maybe_permute_loop_masks (loop_vec_info, gimple_seq *seq,
> +vect_maybe_permute_loop_masks (loop_vec_info loop_vinfo, gimple_seq *seq,
>                                rgroup_masks *dest_rgm,
>                                rgroup_masks *src_rgm)
>  {
> @@ -330,7 +330,7 @@ vect_maybe_permute_loop_masks (loop_vec_
>      {
>        /* Unpacking the source masks gives at least as many mask bits as
>          we need.  We can then VIEW_CONVERT any excess bits away.  */
> -      tree unpack_masktype = vect_halve_mask_nunits (src_masktype);
> +      tree unpack_masktype = vect_halve_mask_nunits (loop_vinfo, src_masktype);
>        for (unsigned int i = 0; i < dest_rgm->masks.length (); ++i)
>         {
>           tree src = src_rgm->masks[i / 2];
> Index: gcc/tree-vect-stmts.c
> ===================================================================
> --- gcc/tree-vect-stmts.c       2019-10-20 14:14:23.176625692 +0100
> +++ gcc/tree-vect-stmts.c       2019-10-20 14:14:30.500573381 +0100
> @@ -11385,6 +11385,7 @@ supportable_widening_operation (enum tre
>                                  int *multi_step_cvt,
>                                  vec<tree> *interm_types)
>  {
> +  vec_info *vinfo = stmt_info->vinfo;
>    loop_vec_info loop_info = STMT_VINFO_LOOP_VINFO (stmt_info);
>    class loop *vect_loop = NULL;
>    machine_mode vec_mode;
> @@ -11570,7 +11571,7 @@ supportable_widening_operation (enum tre
>        intermediate_mode = insn_data[icode1].operand[0].mode;
>        if (VECTOR_BOOLEAN_TYPE_P (prev_type))
>         {
> -         intermediate_type = vect_halve_mask_nunits (prev_type);
> +         intermediate_type = vect_halve_mask_nunits (vinfo, prev_type);
>           if (intermediate_mode != TYPE_MODE (intermediate_type))
>             return false;
>         }
>
>
> Pass a vec_info to vect_double_mask_nunits
>
> 2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>
>
> gcc/
>         * tree-vectorizer.h (vect_double_mask_nunits): Take a vec_info.
>         * tree-vect-loop.c (vect_double_mask_nunits): Likewise.
>         * tree-vect-stmts.c (supportable_narrowing_operation):  Update call
>         accordingly.
>
> Index: gcc/tree-vectorizer.h
> ===================================================================
> --- gcc/tree-vectorizer.h       2019-10-20 14:14:30.500573381 +0100
> +++ gcc/tree-vectorizer.h       2019-10-20 14:14:33.692550581 +0100
> @@ -1706,7 +1706,7 @@ extern tree vect_build_loop_niters (loop
>  extern void vect_gen_vector_loop_niters (loop_vec_info, tree, tree *,
>                                          tree *, bool);
>  extern tree vect_halve_mask_nunits (vec_info *, tree);
> -extern tree vect_double_mask_nunits (tree);
> +extern tree vect_double_mask_nunits (vec_info *, tree);
>  extern void vect_record_loop_mask (loop_vec_info, vec_loop_masks *,
>                                    unsigned int, tree, tree);
>  extern tree vect_get_loop_mask (gimple_stmt_iterator *, vec_loop_masks *,
> Index: gcc/tree-vect-loop.c
> ===================================================================
> --- gcc/tree-vect-loop.c        2019-10-20 14:14:30.496573409 +0100
> +++ gcc/tree-vect-loop.c        2019-10-20 14:14:33.692550581 +0100
> @@ -7754,7 +7754,7 @@ vect_halve_mask_nunits (vec_info *, tree
>  /* Return a mask type with twice as many elements as TYPE.  */
>
>  tree
> -vect_double_mask_nunits (tree type)
> +vect_double_mask_nunits (vec_info *, tree type)
>  {
>    poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (type) * 2;
>    return build_truth_vector_type (nunits, current_vector_size);
> Index: gcc/tree-vect-stmts.c
> ===================================================================
> --- gcc/tree-vect-stmts.c       2019-10-20 14:14:30.500573381 +0100
> +++ gcc/tree-vect-stmts.c       2019-10-20 14:14:33.692550581 +0100
> @@ -11650,7 +11650,7 @@ supportable_widening_operation (enum tre
>     narrowing operation (short in the above example).   */
>
>  bool
> -supportable_narrowing_operation (vec_info *, enum tree_code code,
> +supportable_narrowing_operation (vec_info *vinfo, enum tree_code code,
>                                  tree vectype_out, tree vectype_in,
>                                  enum tree_code *code1, int *multi_step_cvt,
>                                   vec<tree> *interm_types)
> @@ -11759,7 +11759,7 @@ supportable_narrowing_operation (vec_inf
>        intermediate_mode = insn_data[icode1].operand[0].mode;
>        if (VECTOR_BOOLEAN_TYPE_P (prev_type))
>         {
> -         intermediate_type = vect_double_mask_nunits (prev_type);
> +         intermediate_type = vect_double_mask_nunits (vinfo, prev_type);
>           if (intermediate_mode != TYPE_MODE (intermediate_type))
>             return false;
>         }

Patch
diff mbox series

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2019-10-20 13:58:02.095634389 +0100
+++ gcc/tree-vectorizer.h	2019-10-20 14:14:00.632786715 +0100
@@ -1634,7 +1634,7 @@  extern void vect_get_load_cost (stmt_vec
 				stmt_vector_for_cost *, bool);
 extern void vect_get_store_cost (stmt_vec_info, int,
 				 unsigned int *, stmt_vector_for_cost *);
-extern bool vect_supportable_shift (enum tree_code, tree);
+extern bool vect_supportable_shift (vec_info *, enum tree_code, tree);
 extern tree vect_gen_perm_mask_any (tree, const vec_perm_indices &);
 extern tree vect_gen_perm_mask_checked (tree, const vec_perm_indices &);
 extern void optimize_mask_stores (class loop*);
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2019-10-20 13:58:02.111634275 +0100
+++ gcc/tree-vect-stmts.c	2019-10-20 14:14:00.628786742 +0100
@@ -5465,7 +5465,7 @@  vectorizable_assignment (stmt_vec_info s
    either as shift by a scalar or by a vector.  */
 
 bool
-vect_supportable_shift (enum tree_code code, tree scalar_type)
+vect_supportable_shift (vec_info *, enum tree_code code, tree scalar_type)
 {
 
   machine_mode vec_mode;
Index: gcc/tree-vect-patterns.c
===================================================================
--- gcc/tree-vect-patterns.c	2019-10-17 14:22:55.519309037 +0100
+++ gcc/tree-vect-patterns.c	2019-10-20 14:14:00.628786742 +0100
@@ -2720,6 +2720,7 @@  apply_binop_and_append_stmt (tree_code c
 vect_synth_mult_by_constant (tree op, tree val,
 			     stmt_vec_info stmt_vinfo)
 {
+  vec_info *vinfo = stmt_vinfo->vinfo;
   tree itype = TREE_TYPE (op);
   machine_mode mode = TYPE_MODE (itype);
   struct algorithm alg;
@@ -2738,7 +2739,7 @@  vect_synth_mult_by_constant (tree op, tr
 
   /* Targets that don't support vector shifts but support vector additions
      can synthesize shifts that way.  */
-  bool synth_shift_p = !vect_supportable_shift (LSHIFT_EXPR, multtype);
+  bool synth_shift_p = !vect_supportable_shift (vinfo, LSHIFT_EXPR, multtype);
 
   HOST_WIDE_INT hwval = tree_to_shwi (val);
   /* Use MAX_COST here as we don't want to limit the sequence on rtx costs.


Pass a vec_info to vect_supportable_direct_optab_p

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vect-patterns.c (vect_supportable_direct_optab_p): Take
	a vec_info.
	(vect_recog_dot_prod_pattern): Update call accordingly.
	(vect_recog_sad_pattern, vect_recog_pow_pattern): Likewise.
	(vect_recog_widen_sum_pattern): Likewise.

Index: gcc/tree-vect-patterns.c
===================================================================
--- gcc/tree-vect-patterns.c	2019-10-20 14:14:00.628786742 +0100
+++ gcc/tree-vect-patterns.c	2019-10-20 14:14:03.588765602 +0100
@@ -187,7 +187,7 @@  vect_get_external_def_edge (vec_info *vi
    is nonnull.  */
 
 static bool
-vect_supportable_direct_optab_p (tree otype, tree_code code,
+vect_supportable_direct_optab_p (vec_info *, tree otype, tree_code code,
 				 tree itype, tree *vecotype_out,
 				 tree *vecitype_out = NULL)
 {
@@ -985,7 +985,7 @@  vect_recog_dot_prod_pattern (stmt_vec_in
   vect_pattern_detected ("vect_recog_dot_prod_pattern", last_stmt);
 
   tree half_vectype;
-  if (!vect_supportable_direct_optab_p (type, DOT_PROD_EXPR, half_type,
+  if (!vect_supportable_direct_optab_p (vinfo, type, DOT_PROD_EXPR, half_type,
 					type_out, &half_vectype))
     return NULL;
 
@@ -1143,7 +1143,7 @@  vect_recog_sad_pattern (stmt_vec_info st
   vect_pattern_detected ("vect_recog_sad_pattern", last_stmt);
 
   tree half_vectype;
-  if (!vect_supportable_direct_optab_p (sum_type, SAD_EXPR, half_type,
+  if (!vect_supportable_direct_optab_p (vinfo, sum_type, SAD_EXPR, half_type,
 					type_out, &half_vectype))
     return NULL;
 
@@ -1273,6 +1273,7 @@  vect_recog_widen_mult_pattern (stmt_vec_
 static gimple *
 vect_recog_pow_pattern (stmt_vec_info stmt_vinfo, tree *type_out)
 {
+  vec_info *vinfo = stmt_vinfo->vinfo;
   gimple *last_stmt = stmt_vinfo->stmt;
   tree base, exp;
   gimple *stmt;
@@ -1366,7 +1367,7 @@  vect_recog_pow_pattern (stmt_vec_info st
       || (TREE_CODE (exp) == REAL_CST
           && real_equal (&TREE_REAL_CST (exp), &dconst2)))
     {
-      if (!vect_supportable_direct_optab_p (TREE_TYPE (base), MULT_EXPR,
+      if (!vect_supportable_direct_optab_p (vinfo, TREE_TYPE (base), MULT_EXPR,
 					    TREE_TYPE (base), type_out))
 	return NULL;
 
@@ -1472,8 +1473,8 @@  vect_recog_widen_sum_pattern (stmt_vec_i
 
   vect_pattern_detected ("vect_recog_widen_sum_pattern", last_stmt);
 
-  if (!vect_supportable_direct_optab_p (type, WIDEN_SUM_EXPR, unprom0.type,
-					type_out))
+  if (!vect_supportable_direct_optab_p (vinfo, type, WIDEN_SUM_EXPR,
+					unprom0.type, type_out))
     return NULL;
 
   var = vect_recog_temp_ssa_var (type, NULL);



Pass a vec_info to get_mask_type_for_scalar_type

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (get_mask_type_for_scalar_type): Take a vec_info.
	* tree-vect-stmts.c (get_mask_type_for_scalar_type): Likewise.
	(vect_check_load_store_mask): Update call accordingly.
	(vect_get_mask_type_for_stmt): Likewise.
	* tree-vect-patterns.c (check_bool_pattern): Likewise.
	(search_type_for_mask_1, vect_recog_mask_conversion_pattern): Likewise.
	(vect_convert_mask_for_vectype): Likewise.

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2019-10-20 14:14:00.632786715 +0100
+++ gcc/tree-vectorizer.h	2019-10-20 14:14:06.472745000 +0100
@@ -1591,7 +1591,7 @@  extern bool vect_can_advance_ivs_p (loop
 extern poly_uint64 current_vector_size;
 extern tree get_vectype_for_scalar_type (tree);
 extern tree get_vectype_for_scalar_type_and_size (tree, poly_uint64);
-extern tree get_mask_type_for_scalar_type (tree);
+extern tree get_mask_type_for_scalar_type (vec_info *, 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 *, enum vect_def_type *,
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2019-10-20 14:14:00.628786742 +0100
+++ gcc/tree-vect-stmts.c	2019-10-20 14:14:06.472745000 +0100
@@ -2558,6 +2558,7 @@  vect_check_load_store_mask (stmt_vec_inf
 			    vect_def_type *mask_dt_out,
 			    tree *mask_vectype_out)
 {
+  vec_info *vinfo = stmt_info->vinfo;
   if (!VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (mask)))
     {
       if (dump_enabled_p ())
@@ -2586,7 +2587,7 @@  vect_check_load_store_mask (stmt_vec_inf
 
   tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   if (!mask_vectype)
-    mask_vectype = get_mask_type_for_scalar_type (TREE_TYPE (vectype));
+    mask_vectype = get_mask_type_for_scalar_type (vinfo, TREE_TYPE (vectype));
 
   if (!mask_vectype || !VECTOR_BOOLEAN_TYPE_P (mask_vectype))
     {
@@ -11156,7 +11157,7 @@  get_vectype_for_scalar_type (tree scalar
    of vectors of specified SCALAR_TYPE as supported by target.  */
 
 tree
-get_mask_type_for_scalar_type (tree scalar_type)
+get_mask_type_for_scalar_type (vec_info *, tree scalar_type)
 {
   tree vectype = get_vectype_for_scalar_type (scalar_type);
 
@@ -11986,6 +11987,7 @@  vect_get_vector_types_for_stmt (stmt_vec
 opt_tree
 vect_get_mask_type_for_stmt (stmt_vec_info stmt_info)
 {
+  vec_info *vinfo = stmt_info->vinfo;
   gimple *stmt = stmt_info->stmt;
   tree mask_type = NULL;
   tree vectype, scalar_type;
@@ -11995,7 +11997,7 @@  vect_get_mask_type_for_stmt (stmt_vec_in
       && !VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (gimple_assign_rhs1 (stmt))))
     {
       scalar_type = TREE_TYPE (gimple_assign_rhs1 (stmt));
-      mask_type = get_mask_type_for_scalar_type (scalar_type);
+      mask_type = get_mask_type_for_scalar_type (vinfo, scalar_type);
 
       if (!mask_type)
 	return opt_tree::failure_at (stmt,
Index: gcc/tree-vect-patterns.c
===================================================================
--- gcc/tree-vect-patterns.c	2019-10-20 14:14:03.588765602 +0100
+++ gcc/tree-vect-patterns.c	2019-10-20 14:14:06.468745032 +0100
@@ -3616,7 +3616,8 @@  check_bool_pattern (tree var, vec_info *
 	  if (comp_vectype == NULL_TREE)
 	    return false;
 
-	  tree mask_type = get_mask_type_for_scalar_type (TREE_TYPE (rhs1));
+	  tree mask_type = get_mask_type_for_scalar_type (vinfo,
+							  TREE_TYPE (rhs1));
 	  if (mask_type
 	      && expand_vec_cmp_expr_p (comp_vectype, mask_type, rhs_code))
 	    return false;
@@ -3943,7 +3944,7 @@  search_type_for_mask_1 (tree var, vec_in
 	      break;
 	    }
 
-	  mask_type = get_mask_type_for_scalar_type (TREE_TYPE (rhs1));
+	  mask_type = get_mask_type_for_scalar_type (vinfo, TREE_TYPE (rhs1));
 	  if (!mask_type
 	      || !expand_vec_cmp_expr_p (comp_vectype, mask_type, rhs_code))
 	    {
@@ -4275,7 +4276,7 @@  vect_recog_mask_conversion_pattern (stmt
       tree mask_arg_type = search_type_for_mask (mask_arg, vinfo);
       if (!mask_arg_type)
 	return NULL;
-      vectype2 = get_mask_type_for_scalar_type (mask_arg_type);
+      vectype2 = get_mask_type_for_scalar_type (vinfo, mask_arg_type);
 
       if (!vectype1 || !vectype2
 	  || known_eq (TYPE_VECTOR_SUBPARTS (vectype1),
@@ -4352,7 +4353,7 @@  vect_recog_mask_conversion_pattern (stmt
       else
 	return NULL;
 
-      vectype2 = get_mask_type_for_scalar_type (rhs1_type);
+      vectype2 = get_mask_type_for_scalar_type (vinfo, rhs1_type);
 
       if (!vectype1 || !vectype2)
 	return NULL;
@@ -4442,14 +4443,14 @@  vect_recog_mask_conversion_pattern (stmt
 
   if (TYPE_PRECISION (rhs1_type) < TYPE_PRECISION (rhs2_type))
     {
-      vectype1 = get_mask_type_for_scalar_type (rhs1_type);
+      vectype1 = get_mask_type_for_scalar_type (vinfo, rhs1_type);
       if (!vectype1)
 	return NULL;
       rhs2 = build_mask_conversion (rhs2, vectype1, stmt_vinfo);
     }
   else
     {
-      vectype1 = get_mask_type_for_scalar_type (rhs2_type);
+      vectype1 = get_mask_type_for_scalar_type (vinfo, rhs2_type);
       if (!vectype1)
 	return NULL;
       rhs1 = build_mask_conversion (rhs1, vectype1, stmt_vinfo);
@@ -4520,7 +4521,7 @@  vect_convert_mask_for_vectype (tree mask
   tree mask_type = search_type_for_mask (mask, vinfo);
   if (mask_type)
     {
-      tree mask_vectype = get_mask_type_for_scalar_type (mask_type);
+      tree mask_vectype = get_mask_type_for_scalar_type (vinfo, mask_type);
       if (mask_vectype
 	  && maybe_ne (TYPE_VECTOR_SUBPARTS (vectype),
 		       TYPE_VECTOR_SUBPARTS (mask_vectype)))


Pass a vec_info to get_vectype_for_scalar_type

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (get_vectype_for_scalar_type): Take a vec_info.
	* tree-vect-stmts.c (get_vectype_for_scalar_type): Likewise.
	(vect_prologue_cost_for_slp_op): Update call accordingly.
	(vect_get_vec_def_for_operand, vect_get_gather_scatter_ops)
	(vect_get_strided_load_store_ops, vectorizable_simd_clone_call)
	(vect_supportable_shift, vect_is_simple_cond, vectorizable_comparison)
	(get_mask_type_for_scalar_type): Likewise.
	(vect_get_vector_types_for_stmt): Likewise.
	* tree-vect-data-refs.c (vect_analyze_data_refs): Likewise.
	* tree-vect-loop.c (vect_determine_vectorization_factor): Likewise.
	(get_initial_def_for_reduction, build_vect_cond_expr): Likewise.
	* tree-vect-patterns.c (vect_supportable_direct_optab_p): Likewise.
	(vect_split_statement, vect_convert_input): Likewise.
	(vect_recog_widen_op_pattern, vect_recog_pow_pattern): Likewise.
	(vect_recog_over_widening_pattern, vect_recog_mulhs_pattern): Likewise.
	(vect_recog_average_pattern, vect_recog_cast_forwprop_pattern)
	(vect_recog_rotate_pattern, vect_recog_vector_vector_shift_pattern)
	(vect_synth_mult_by_constant, vect_recog_mult_pattern): Likewise.
	(vect_recog_divmod_pattern, vect_recog_mixed_size_cond_pattern)
	(check_bool_pattern, adjust_bool_pattern_cast, adjust_bool_pattern)
	(search_type_for_mask_1, vect_recog_bool_pattern): Likewise.
	(vect_recog_mask_conversion_pattern): Likewise.
	(vect_add_conversion_to_pattern): Likewise.
	(vect_recog_gather_scatter_pattern): Likewise.
	* tree-vect-slp.c (vect_build_slp_tree_2): Likewise.
	(vect_analyze_slp_instance, vect_get_constant_vectors): Likewise.

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2019-10-20 14:14:06.472745000 +0100
+++ gcc/tree-vectorizer.h	2019-10-20 14:14:09.672722145 +0100
@@ -1589,7 +1589,7 @@  extern bool vect_can_advance_ivs_p (loop
 
 /* In tree-vect-stmts.c.  */
 extern poly_uint64 current_vector_size;
-extern tree get_vectype_for_scalar_type (tree);
+extern tree get_vectype_for_scalar_type (vec_info *, tree);
 extern tree get_vectype_for_scalar_type_and_size (tree, poly_uint64);
 extern tree get_mask_type_for_scalar_type (vec_info *, tree);
 extern tree get_same_sized_vectype (tree, tree);
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2019-10-20 14:14:06.472745000 +0100
+++ gcc/tree-vect-stmts.c	2019-10-20 14:14:09.672722145 +0100
@@ -796,6 +796,7 @@  vect_prologue_cost_for_slp_op (slp_tree
 			       unsigned opno, enum vect_def_type dt,
 			       stmt_vector_for_cost *cost_vec)
 {
+  vec_info *vinfo = stmt_info->vinfo;
   gimple *stmt = SLP_TREE_SCALAR_STMTS (node)[0]->stmt;
   tree op = gimple_op (stmt, opno);
   unsigned prologue_cost = 0;
@@ -803,7 +804,7 @@  vect_prologue_cost_for_slp_op (slp_tree
   /* Without looking at the actual initializer a vector of
      constants can be implemented as load from the constant pool.
      When all elements are the same we can use a splat.  */
-  tree vectype = get_vectype_for_scalar_type (TREE_TYPE (op));
+  tree vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (op));
   unsigned group_size = SLP_TREE_SCALAR_STMTS (node).length ();
   unsigned num_vects_to_check;
   unsigned HOST_WIDE_INT const_nunits;
@@ -1610,7 +1611,7 @@  vect_get_vec_def_for_operand (tree op, s
 	       && VECTOR_BOOLEAN_TYPE_P (stmt_vectype))
 	vector_type = build_same_sized_truth_vector_type (stmt_vectype);
       else
-	vector_type = get_vectype_for_scalar_type (TREE_TYPE (op));
+	vector_type = get_vectype_for_scalar_type (loop_vinfo, TREE_TYPE (op));
 
       gcc_assert (vector_type);
       return vect_init_vector (stmt_vinfo, op, vector_type, NULL);
@@ -2975,6 +2976,7 @@  vect_get_gather_scatter_ops (class loop
 			     gather_scatter_info *gs_info,
 			     tree *dataref_ptr, tree *vec_offset)
 {
+  vec_info *vinfo = stmt_info->vinfo;
   gimple_seq stmts = NULL;
   *dataref_ptr = force_gimple_operand (gs_info->base, &stmts, true, NULL_TREE);
   if (stmts != NULL)
@@ -2985,7 +2987,7 @@  vect_get_gather_scatter_ops (class loop
       gcc_assert (!new_bb);
     }
   tree offset_type = TREE_TYPE (gs_info->offset);
-  tree offset_vectype = get_vectype_for_scalar_type (offset_type);
+  tree offset_vectype = get_vectype_for_scalar_type (vinfo, offset_type);
   *vec_offset = vect_get_vec_def_for_operand (gs_info->offset, stmt_info,
 					      offset_vectype);
 }
@@ -3020,7 +3022,7 @@  vect_get_strided_load_store_ops (stmt_ve
   /* The offset given in GS_INFO can have pointer type, so use the element
      type of the vector instead.  */
   tree offset_type = TREE_TYPE (gs_info->offset);
-  tree offset_vectype = get_vectype_for_scalar_type (offset_type);
+  tree offset_vectype = get_vectype_for_scalar_type (loop_vinfo, offset_type);
   offset_type = TREE_TYPE (offset_vectype);
 
   /* Calculate X = DR_STEP / SCALE and convert it to the appropriate type.  */
@@ -4101,9 +4103,8 @@  vectorizable_simd_clone_call (stmt_vec_i
 	 || arginfo[i].dt == vect_external_def)
 	&& bestn->simdclone->args[i].arg_type == SIMD_CLONE_ARG_TYPE_VECTOR)
       {
-	arginfo[i].vectype
-	  = get_vectype_for_scalar_type (TREE_TYPE (gimple_call_arg (stmt,
-								     i)));
+	tree arg_type = TREE_TYPE (gimple_call_arg (stmt, i));
+	arginfo[i].vectype = get_vectype_for_scalar_type (vinfo, arg_type);
 	if (arginfo[i].vectype == NULL
 	    || (simd_clone_subparts (arginfo[i].vectype)
 		> bestn->simdclone->simdlen))
@@ -5466,7 +5467,7 @@  vectorizable_assignment (stmt_vec_info s
    either as shift by a scalar or by a vector.  */
 
 bool
-vect_supportable_shift (vec_info *, enum tree_code code, tree scalar_type)
+vect_supportable_shift (vec_info *vinfo, enum tree_code code, tree scalar_type)
 {
 
   machine_mode vec_mode;
@@ -5474,7 +5475,7 @@  vect_supportable_shift (vec_info *, enum
   int icode;
   tree vectype;
 
-  vectype = get_vectype_for_scalar_type (scalar_type);
+  vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
   if (!vectype)
     return false;
 
@@ -9763,7 +9764,7 @@  vect_is_simple_cond (tree cond, vec_info
 	scalar_type = build_nonstandard_integer_type
 	  (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (vectype))),
 	   TYPE_UNSIGNED (scalar_type));
-      *comp_vectype = get_vectype_for_scalar_type (scalar_type);
+      *comp_vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
     }
 
   return true;
@@ -10359,7 +10360,7 @@  vectorizable_comparison (stmt_vec_info s
   /* Invariant comparison.  */
   if (!vectype)
     {
-      vectype = get_vectype_for_scalar_type (TREE_TYPE (rhs1));
+      vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (rhs1));
       if (maybe_ne (TYPE_VECTOR_SUBPARTS (vectype), nunits))
 	return false;
     }
@@ -11140,7 +11141,7 @@  get_vectype_for_scalar_type_and_size (tr
    by the target.  */
 
 tree
-get_vectype_for_scalar_type (tree scalar_type)
+get_vectype_for_scalar_type (vec_info *, tree scalar_type)
 {
   tree vectype;
   vectype = get_vectype_for_scalar_type_and_size (scalar_type,
@@ -11157,9 +11158,9 @@  get_vectype_for_scalar_type (tree scalar
    of vectors of specified SCALAR_TYPE as supported by target.  */
 
 tree
-get_mask_type_for_scalar_type (vec_info *, tree scalar_type)
+get_mask_type_for_scalar_type (vec_info *vinfo, tree scalar_type)
 {
-  tree vectype = get_vectype_for_scalar_type (scalar_type);
+  tree vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
 
   if (!vectype)
     return NULL;
@@ -11853,6 +11854,7 @@  vect_get_vector_types_for_stmt (stmt_vec
 				tree *stmt_vectype_out,
 				tree *nunits_vectype_out)
 {
+  vec_info *vinfo = stmt_info->vinfo;
   gimple *stmt = stmt_info->stmt;
 
   *stmt_vectype_out = NULL_TREE;
@@ -11919,7 +11921,7 @@  vect_get_vector_types_for_stmt (stmt_vec
       if (dump_enabled_p ())
 	dump_printf_loc (MSG_NOTE, vect_location,
 			 "get vectype for scalar type:  %T\n", scalar_type);
-      vectype = get_vectype_for_scalar_type (scalar_type);
+      vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
       if (!vectype)
 	return opt_result::failure_at (stmt,
 				       "not vectorized:"
@@ -11952,7 +11954,7 @@  vect_get_vector_types_for_stmt (stmt_vec
       if (dump_enabled_p ())
 	dump_printf_loc (MSG_NOTE, vect_location,
 			 "get vectype for scalar type:  %T\n", scalar_type);
-      nunits_vectype = get_vectype_for_scalar_type (scalar_type);
+      nunits_vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
     }
   if (!nunits_vectype)
     return opt_result::failure_at (stmt,
Index: gcc/tree-vect-data-refs.c
===================================================================
--- gcc/tree-vect-data-refs.c	2019-10-11 15:43:54.543490491 +0100
+++ gcc/tree-vect-data-refs.c	2019-10-20 14:14:09.664722204 +0100
@@ -4344,7 +4344,7 @@  vect_analyze_data_refs (vec_info *vinfo,
       /* Set vectype for STMT.  */
       scalar_type = TREE_TYPE (DR_REF (dr));
       STMT_VINFO_VECTYPE (stmt_info)
-	= get_vectype_for_scalar_type (scalar_type);
+	= get_vectype_for_scalar_type (vinfo, scalar_type);
       if (!STMT_VINFO_VECTYPE (stmt_info))
         {
           if (dump_enabled_p ())
@@ -4392,7 +4392,8 @@  vect_analyze_data_refs (vec_info *vinfo,
 	  if (!vect_check_gather_scatter (stmt_info,
 					  as_a <loop_vec_info> (vinfo),
 					  &gs_info)
-	      || !get_vectype_for_scalar_type (TREE_TYPE (gs_info.offset)))
+	      || !get_vectype_for_scalar_type (vinfo,
+					       TREE_TYPE (gs_info.offset)))
 	    {
 	      if (fatal)
 		*fatal = false;
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2019-10-20 13:58:02.095634389 +0100
+++ gcc/tree-vect-loop.c	2019-10-20 14:14:09.668722173 +0100
@@ -327,7 +327,7 @@  vect_determine_vectorization_factor (loo
 				 "get vectype for scalar type:  %T\n",
 				 scalar_type);
 
-	      vectype = get_vectype_for_scalar_type (scalar_type);
+	      vectype = get_vectype_for_scalar_type (loop_vinfo, scalar_type);
 	      if (!vectype)
 		return opt_result::failure_at (phi,
 					       "not vectorized: unsupported "
@@ -3774,7 +3774,7 @@  get_initial_def_for_reduction (stmt_vec_
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
   class loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
   tree scalar_type = TREE_TYPE (init_val);
-  tree vectype = get_vectype_for_scalar_type (scalar_type);
+  tree vectype = get_vectype_for_scalar_type (loop_vinfo, scalar_type);
   tree def_for_init;
   tree init_def;
   REAL_VALUE_TYPE real_init_val = dconst0;
@@ -5555,11 +5555,11 @@  build_vect_cond_expr (enum tree_code cod
    corresponds to the type of arguments to the reduction stmt, and should *NOT*
    be used to create the vectorized stmt.  The right vectype for the vectorized
    stmt is obtained from the type of the result X:
-        get_vectype_for_scalar_type (TREE_TYPE (X))
+      get_vectype_for_scalar_type (vinfo, TREE_TYPE (X))
 
    This means that, contrary to "regular" reductions (or "regular" stmts in
    general), the following equation:
-      STMT_VINFO_VECTYPE == get_vectype_for_scalar_type (TREE_TYPE (X))
+      STMT_VINFO_VECTYPE == get_vectype_for_scalar_type (vinfo, TREE_TYPE (X))
    does *NOT* necessarily hold for reduction patterns.  */
 
 bool
Index: gcc/tree-vect-patterns.c
===================================================================
--- gcc/tree-vect-patterns.c	2019-10-20 14:14:06.468745032 +0100
+++ gcc/tree-vect-patterns.c	2019-10-20 14:14:09.668722173 +0100
@@ -187,15 +187,15 @@  vect_get_external_def_edge (vec_info *vi
    is nonnull.  */
 
 static bool
-vect_supportable_direct_optab_p (vec_info *, tree otype, tree_code code,
+vect_supportable_direct_optab_p (vec_info *vinfo, tree otype, tree_code code,
 				 tree itype, tree *vecotype_out,
 				 tree *vecitype_out = NULL)
 {
-  tree vecitype = get_vectype_for_scalar_type (itype);
+  tree vecitype = get_vectype_for_scalar_type (vinfo, itype);
   if (!vecitype)
     return false;
 
-  tree vecotype = get_vectype_for_scalar_type (otype);
+  tree vecotype = get_vectype_for_scalar_type (vinfo, otype);
   if (!vecotype)
     return false;
 
@@ -635,6 +635,7 @@  vect_recog_temp_ssa_var (tree type, gimp
 vect_split_statement (stmt_vec_info stmt2_info, tree new_rhs,
 		      gimple *stmt1, tree vectype)
 {
+  vec_info *vinfo = stmt2_info->vinfo;
   if (is_pattern_stmt_p (stmt2_info))
     {
       /* STMT2_INFO is part of a pattern.  Get the statement to which
@@ -678,7 +679,7 @@  vect_split_statement (stmt_vec_info stmt
 	 two-statement pattern now.  */
       gcc_assert (!STMT_VINFO_RELATED_STMT (stmt2_info));
       tree lhs_type = TREE_TYPE (gimple_get_lhs (stmt2_info->stmt));
-      tree lhs_vectype = get_vectype_for_scalar_type (lhs_type);
+      tree lhs_vectype = get_vectype_for_scalar_type (vinfo, lhs_type);
       if (!lhs_vectype)
 	return false;
 
@@ -715,6 +716,8 @@  vect_split_statement (stmt_vec_info stmt
 vect_convert_input (stmt_vec_info stmt_info, tree type,
 		    vect_unpromoted_value *unprom, tree vectype)
 {
+  vec_info *vinfo = stmt_info->vinfo;
+
   /* Check for a no-op conversion.  */
   if (types_compatible_p (type, TREE_TYPE (unprom->op)))
     return unprom->op;
@@ -752,7 +755,7 @@  vect_convert_input (stmt_vec_info stmt_i
 	     unsigned promotion.  */
 	  tree midtype = build_nonstandard_integer_type
 	    (TYPE_PRECISION (type), TYPE_UNSIGNED (unprom->type));
-	  tree vec_midtype = get_vectype_for_scalar_type (midtype);
+	  tree vec_midtype = get_vectype_for_scalar_type (vinfo, midtype);
 	  if (vec_midtype)
 	    {
 	      input = vect_recog_temp_ssa_var (midtype, NULL);
@@ -1189,6 +1192,7 @@  vect_recog_widen_op_pattern (stmt_vec_in
 			     tree_code orig_code, tree_code wide_code,
 			     bool shift_p, const char *name)
 {
+  vec_info *vinfo = last_stmt_info->vinfo;
   gimple *last_stmt = last_stmt_info->stmt;
 
   vect_unpromoted_value unprom[2];
@@ -1208,8 +1212,8 @@  vect_recog_widen_op_pattern (stmt_vec_in
 					    TYPE_UNSIGNED (half_type));
 
   /* Check target support  */
-  tree vectype = get_vectype_for_scalar_type (half_type);
-  tree vecitype = get_vectype_for_scalar_type (itype);
+  tree vectype = get_vectype_for_scalar_type (vinfo, half_type);
+  tree vecitype = get_vectype_for_scalar_type (vinfo, itype);
   enum tree_code dummy_code;
   int dummy_int;
   auto_vec<tree> dummy_vec;
@@ -1221,7 +1225,7 @@  vect_recog_widen_op_pattern (stmt_vec_in
 					  &dummy_int, &dummy_vec))
     return NULL;
 
-  *type_out = get_vectype_for_scalar_type (type);
+  *type_out = get_vectype_for_scalar_type (vinfo, type);
   if (!*type_out)
     return NULL;
 
@@ -1342,7 +1346,7 @@  vect_recog_pow_pattern (stmt_vec_info st
 		  if (node->simd_clones == NULL)
 		    return NULL;
 		}
-	      *type_out = get_vectype_for_scalar_type (TREE_TYPE (base));
+	      *type_out = get_vectype_for_scalar_type (vinfo, TREE_TYPE (base));
 	      if (!*type_out)
 		return NULL;
 	      tree def = vect_recog_temp_ssa_var (TREE_TYPE (base), NULL);
@@ -1380,7 +1384,7 @@  vect_recog_pow_pattern (stmt_vec_info st
   if (TREE_CODE (exp) == REAL_CST
       && real_equal (&TREE_REAL_CST (exp), &dconsthalf))
     {
-      *type_out = get_vectype_for_scalar_type (TREE_TYPE (base));
+      *type_out = get_vectype_for_scalar_type (vinfo, TREE_TYPE (base));
       if (*type_out
 	  && direct_internal_fn_supported_p (IFN_SQRT, *type_out,
 					     OPTIMIZE_FOR_SPEED))
@@ -1665,7 +1669,7 @@  vect_recog_over_widening_pattern (stmt_v
 
   vect_pattern_detected ("vect_recog_over_widening_pattern", last_stmt);
 
-  *type_out = get_vectype_for_scalar_type (type);
+  *type_out = get_vectype_for_scalar_type (vinfo, type);
   if (!*type_out)
     return NULL;
 
@@ -1686,8 +1690,8 @@  vect_recog_over_widening_pattern (stmt_v
      wants to rewrite anyway.  If targets have a minimum element size
      for some optabs, we should pattern-match smaller ops to larger ops
      where beneficial.  */
-  tree new_vectype = get_vectype_for_scalar_type (new_type);
-  tree op_vectype = get_vectype_for_scalar_type (op_type);
+  tree new_vectype = get_vectype_for_scalar_type (vinfo, new_type);
+  tree op_vectype = get_vectype_for_scalar_type (vinfo, op_type);
   if (!new_vectype || !op_vectype)
     return NULL;
 
@@ -1864,7 +1868,7 @@  vect_recog_mulhs_pattern (stmt_vec_info
       (target_precision, TYPE_UNSIGNED (new_type));
 
   /* Check for target support.  */
-  tree new_vectype = get_vectype_for_scalar_type (new_type);
+  tree new_vectype = get_vectype_for_scalar_type (vinfo, new_type);
   if (!new_vectype
       || !direct_internal_fn_supported_p
 	    (ifn, new_vectype, OPTIMIZE_FOR_SPEED))
@@ -1872,7 +1876,7 @@  vect_recog_mulhs_pattern (stmt_vec_info
 
   /* The IR requires a valid vector type for the cast result, even though
      it's likely to be discarded.  */
-  *type_out = get_vectype_for_scalar_type (lhs_type);
+  *type_out = get_vectype_for_scalar_type (vinfo, lhs_type);
   if (!*type_out)
     return NULL;
 
@@ -2014,7 +2018,7 @@  vect_recog_average_pattern (stmt_vec_inf
 					       TYPE_UNSIGNED (new_type));
 
   /* Check for target support.  */
-  tree new_vectype = get_vectype_for_scalar_type (new_type);
+  tree new_vectype = get_vectype_for_scalar_type (vinfo, new_type);
   if (!new_vectype
       || !direct_internal_fn_supported_p (ifn, new_vectype,
 					  OPTIMIZE_FOR_SPEED))
@@ -2022,7 +2026,7 @@  vect_recog_average_pattern (stmt_vec_inf
 
   /* The IR requires a valid vector type for the cast result, even though
      it's likely to be discarded.  */
-  *type_out = get_vectype_for_scalar_type (type);
+  *type_out = get_vectype_for_scalar_type (vinfo, type);
   if (!*type_out)
     return NULL;
 
@@ -2108,7 +2112,7 @@  vect_recog_cast_forwprop_pattern (stmt_v
      the unnecessary widening and narrowing.  */
   vect_pattern_detected ("vect_recog_cast_forwprop_pattern", last_stmt);
 
-  *type_out = get_vectype_for_scalar_type (lhs_type);
+  *type_out = get_vectype_for_scalar_type (vinfo, lhs_type);
   if (!*type_out)
     return NULL;
 
@@ -2219,7 +2223,7 @@  vect_recog_rotate_pattern (stmt_vec_info
 	}
 
       type = TREE_TYPE (lhs);
-      vectype = get_vectype_for_scalar_type (type);
+      vectype = get_vectype_for_scalar_type (vinfo, type);
       if (vectype == NULL_TREE)
 	return NULL;
 
@@ -2285,7 +2289,7 @@  vect_recog_rotate_pattern (stmt_vec_info
       && dt != vect_external_def)
     return NULL;
 
-  vectype = get_vectype_for_scalar_type (type);
+  vectype = get_vectype_for_scalar_type (vinfo, type);
   if (vectype == NULL_TREE)
     return NULL;
 
@@ -2404,7 +2408,7 @@  vect_recog_rotate_pattern (stmt_vec_info
     }
   else
     {
-      tree vecstype = get_vectype_for_scalar_type (stype);
+      tree vecstype = get_vectype_for_scalar_type (vinfo, stype);
 
       if (vecstype == NULL_TREE)
 	return NULL;
@@ -2533,7 +2537,7 @@  vect_recog_vector_vector_shift_pattern (
   if (!def_vinfo)
     return NULL;
 
-  *type_out = get_vectype_for_scalar_type (TREE_TYPE (oprnd0));
+  *type_out = get_vectype_for_scalar_type (vinfo, TREE_TYPE (oprnd0));
   if (*type_out == NULL_TREE)
     return NULL;
 
@@ -2556,7 +2560,8 @@  vect_recog_vector_vector_shift_pattern (
 				       TYPE_PRECISION (TREE_TYPE (oprnd1)));
 	      def = vect_recog_temp_ssa_var (TREE_TYPE (rhs1), NULL);
 	      def_stmt = gimple_build_assign (def, BIT_AND_EXPR, rhs1, mask);
-	      tree vecstype = get_vectype_for_scalar_type (TREE_TYPE (rhs1));
+	      tree vecstype = get_vectype_for_scalar_type (vinfo,
+							   TREE_TYPE (rhs1));
 	      append_pattern_def_seq (stmt_vinfo, def_stmt, vecstype);
 	    }
 	}
@@ -2751,7 +2756,7 @@  vect_synth_mult_by_constant (tree op, tr
   if (!possible)
     return NULL;
 
-  tree vectype = get_vectype_for_scalar_type (multtype);
+  tree vectype = get_vectype_for_scalar_type (vinfo, multtype);
 
   if (!vectype
       || !target_supports_mult_synth_alg (&alg, variant,
@@ -2897,6 +2902,7 @@  vect_synth_mult_by_constant (tree op, tr
 static gimple *
 vect_recog_mult_pattern (stmt_vec_info stmt_vinfo, tree *type_out)
 {
+  vec_info *vinfo = stmt_vinfo->vinfo;
   gimple *last_stmt = stmt_vinfo->stmt;
   tree oprnd0, oprnd1, vectype, itype;
   gimple *pattern_stmt;
@@ -2917,7 +2923,7 @@  vect_recog_mult_pattern (stmt_vec_info s
       || !type_has_mode_precision_p (itype))
     return NULL;
 
-  vectype = get_vectype_for_scalar_type (itype);
+  vectype = get_vectype_for_scalar_type (vinfo, itype);
   if (vectype == NULL_TREE)
     return NULL;
 
@@ -2985,6 +2991,7 @@  vect_recog_mult_pattern (stmt_vec_info s
 static gimple *
 vect_recog_divmod_pattern (stmt_vec_info stmt_vinfo, tree *type_out)
 {
+  vec_info *vinfo = stmt_vinfo->vinfo;
   gimple *last_stmt = stmt_vinfo->stmt;
   tree oprnd0, oprnd1, vectype, itype, cond;
   gimple *pattern_stmt, *def_stmt;
@@ -3017,7 +3024,7 @@  vect_recog_divmod_pattern (stmt_vec_info
     return NULL;
 
   scalar_int_mode itype_mode = SCALAR_INT_TYPE_MODE (itype);
-  vectype = get_vectype_for_scalar_type (itype);
+  vectype = get_vectype_for_scalar_type (vinfo, itype);
   if (vectype == NULL_TREE)
     return NULL;
 
@@ -3115,7 +3122,7 @@  vect_recog_divmod_pattern (stmt_vec_info
 	    {
 	      tree utype
 		= build_nonstandard_integer_type (prec, 1);
-	      tree vecutype = get_vectype_for_scalar_type (utype);
+	      tree vecutype = get_vectype_for_scalar_type (vinfo, utype);
 	      tree shift
 		= build_int_cst (utype, GET_MODE_BITSIZE (itype_mode)
 					- tree_log2 (oprnd1));
@@ -3433,6 +3440,7 @@  vect_recog_divmod_pattern (stmt_vec_info
 static gimple *
 vect_recog_mixed_size_cond_pattern (stmt_vec_info stmt_vinfo, tree *type_out)
 {
+  vec_info *vinfo = stmt_vinfo->vinfo;
   gimple *last_stmt = stmt_vinfo->stmt;
   tree cond_expr, then_clause, else_clause;
   tree type, vectype, comp_vectype, itype = NULL_TREE, vecitype;
@@ -3455,7 +3463,7 @@  vect_recog_mixed_size_cond_pattern (stmt
     return NULL;
 
   comp_scalar_type = TREE_TYPE (TREE_OPERAND (cond_expr, 0));
-  comp_vectype = get_vectype_for_scalar_type (comp_scalar_type);
+  comp_vectype = get_vectype_for_scalar_type (vinfo, comp_scalar_type);
   if (comp_vectype == NULL_TREE)
     return NULL;
 
@@ -3503,7 +3511,7 @@  vect_recog_mixed_size_cond_pattern (stmt
   if (GET_MODE_BITSIZE (type_mode) == cmp_mode_size)
     return NULL;
 
-  vectype = get_vectype_for_scalar_type (type);
+  vectype = get_vectype_for_scalar_type (vinfo, type);
   if (vectype == NULL_TREE)
     return NULL;
 
@@ -3518,7 +3526,7 @@  vect_recog_mixed_size_cond_pattern (stmt
       || GET_MODE_BITSIZE (SCALAR_TYPE_MODE (itype)) != cmp_mode_size)
     return NULL;
 
-  vecitype = get_vectype_for_scalar_type (itype);
+  vecitype = get_vectype_for_scalar_type (vinfo, itype);
   if (vecitype == NULL_TREE)
     return NULL;
 
@@ -3612,7 +3620,7 @@  check_bool_pattern (tree var, vec_info *
 	  if (stmt_could_throw_p (cfun, def_stmt))
 	    return false;
 
-	  comp_vectype = get_vectype_for_scalar_type (TREE_TYPE (rhs1));
+	  comp_vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (rhs1));
 	  if (comp_vectype == NULL_TREE)
 	    return false;
 
@@ -3627,7 +3635,7 @@  check_bool_pattern (tree var, vec_info *
 	      scalar_mode mode = SCALAR_TYPE_MODE (TREE_TYPE (rhs1));
 	      tree itype
 		= build_nonstandard_integer_type (GET_MODE_BITSIZE (mode), 1);
-	      vecitype = get_vectype_for_scalar_type (itype);
+	      vecitype = get_vectype_for_scalar_type (vinfo, itype);
 	      if (vecitype == NULL_TREE)
 		return false;
 	    }
@@ -3656,10 +3664,11 @@  check_bool_pattern (tree var, vec_info *
 static tree
 adjust_bool_pattern_cast (tree type, tree var, stmt_vec_info stmt_info)
 {
+  vec_info *vinfo = stmt_info->vinfo;
   gimple *cast_stmt = gimple_build_assign (vect_recog_temp_ssa_var (type, NULL),
 					   NOP_EXPR, var);
   append_pattern_def_seq (stmt_info, cast_stmt,
-			  get_vectype_for_scalar_type (type));
+			  get_vectype_for_scalar_type (vinfo, type));
   return gimple_assign_lhs (cast_stmt);
 }
 
@@ -3673,6 +3682,7 @@  adjust_bool_pattern_cast (tree type, tre
 adjust_bool_pattern (tree var, tree out_type,
 		     stmt_vec_info stmt_info, hash_map <tree, tree> &defs)
 {
+  vec_info *vinfo = stmt_info->vinfo;
   gimple *stmt = SSA_NAME_DEF_STMT (var);
   enum tree_code rhs_code, def_rhs_code;
   tree itype, cond_expr, rhs1, rhs2, irhs1, irhs2;
@@ -3834,7 +3844,7 @@  adjust_bool_pattern (tree var, tree out_
 
   gimple_set_location (pattern_stmt, loc);
   append_pattern_def_seq (stmt_info, pattern_stmt,
-			  get_vectype_for_scalar_type (itype));
+			  get_vectype_for_scalar_type (vinfo, itype));
   defs.put (var, gimple_assign_lhs (pattern_stmt));
 }
 
@@ -3937,7 +3947,7 @@  search_type_for_mask_1 (tree var, vec_in
 	      break;
 	    }
 
-	  comp_vectype = get_vectype_for_scalar_type (TREE_TYPE (rhs1));
+	  comp_vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (rhs1));
 	  if (comp_vectype == NULL_TREE)
 	    {
 	      res = NULL_TREE;
@@ -4052,7 +4062,7 @@  vect_recog_bool_pattern (stmt_vec_info s
       if (! INTEGRAL_TYPE_P (TREE_TYPE (lhs))
 	  || TYPE_PRECISION (TREE_TYPE (lhs)) == 1)
 	return NULL;
-      vectype = get_vectype_for_scalar_type (TREE_TYPE (lhs));
+      vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs));
       if (vectype == NULL_TREE)
 	return NULL;
 
@@ -4089,7 +4099,7 @@  vect_recog_bool_pattern (stmt_vec_info s
 
 	  if (!useless_type_conversion_p (type, TREE_TYPE (lhs)))
 	    {
-	      tree new_vectype = get_vectype_for_scalar_type (type);
+	      tree new_vectype = get_vectype_for_scalar_type (vinfo, type);
 	      append_pattern_def_seq (stmt_vinfo, pattern_stmt, new_vectype);
 
 	      lhs = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL);
@@ -4105,7 +4115,7 @@  vect_recog_bool_pattern (stmt_vec_info s
   else if (rhs_code == COND_EXPR
 	   && TREE_CODE (var) == SSA_NAME)
     {
-      vectype = get_vectype_for_scalar_type (TREE_TYPE (lhs));
+      vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs));
       if (vectype == NULL_TREE)
 	return NULL;
 
@@ -4119,7 +4129,7 @@  vect_recog_bool_pattern (stmt_vec_info s
       tree type
 	= build_nonstandard_integer_type (prec,
 					  TYPE_UNSIGNED (TREE_TYPE (var)));
-      if (get_vectype_for_scalar_type (type) == NULL_TREE)
+      if (get_vectype_for_scalar_type (vinfo, type) == NULL_TREE)
 	return NULL;
 
       if (!check_bool_pattern (var, vinfo, bool_stmts))
@@ -4163,7 +4173,7 @@  vect_recog_bool_pattern (stmt_vec_info s
 
 	  cst0 = build_int_cst (type, 0);
 	  cst1 = build_int_cst (type, 1);
-	  new_vectype = get_vectype_for_scalar_type (type);
+	  new_vectype = get_vectype_for_scalar_type (vinfo, type);
 
 	  rhs = vect_recog_temp_ssa_var (type, NULL);
 	  pattern_stmt = gimple_build_assign (rhs, COND_EXPR, var, cst1, cst0);
@@ -4264,12 +4274,12 @@  vect_recog_mask_conversion_pattern (stmt
 	{
 	  int rhs_index = internal_fn_stored_value_index (ifn);
 	  tree rhs = gimple_call_arg (last_stmt, rhs_index);
-	  vectype1 = get_vectype_for_scalar_type (TREE_TYPE (rhs));
+	  vectype1 = get_vectype_for_scalar_type (vinfo, TREE_TYPE (rhs));
 	}
       else
 	{
 	  lhs = gimple_call_lhs (last_stmt);
-	  vectype1 = get_vectype_for_scalar_type (TREE_TYPE (lhs));
+	  vectype1 = get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs));
 	}
 
       tree mask_arg = gimple_call_arg (last_stmt, mask_argno);
@@ -4322,7 +4332,7 @@  vect_recog_mask_conversion_pattern (stmt
   /* Check for cond expression requiring mask conversion.  */
   if (rhs_code == COND_EXPR)
     {
-      vectype1 = get_vectype_for_scalar_type (TREE_TYPE (lhs));
+      vectype1 = get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs));
 
       if (TREE_CODE (rhs1) == SSA_NAME)
 	{
@@ -4388,7 +4398,8 @@  vect_recog_mask_conversion_pattern (stmt
 	      tree wide_scalar_type = build_nonstandard_integer_type
 		(tree_to_uhwi (TYPE_SIZE (TREE_TYPE (vectype1))),
 		 TYPE_UNSIGNED (rhs1_type));
-	      tree vectype3 = get_vectype_for_scalar_type (wide_scalar_type);
+	      tree vectype3 = get_vectype_for_scalar_type (vinfo,
+							   wide_scalar_type);
 	      if (expand_vec_cond_expr_p (vectype1, vectype3, TREE_CODE (rhs1)))
 		return NULL;
 	    }
@@ -4544,10 +4555,11 @@  vect_add_conversion_to_pattern (tree typ
   if (useless_type_conversion_p (type, TREE_TYPE (value)))
     return value;
 
+  vec_info *vinfo = stmt_info->vinfo;
   tree new_value = vect_recog_temp_ssa_var (type, NULL);
   gassign *conversion = gimple_build_assign (new_value, CONVERT_EXPR, value);
   append_pattern_def_seq (stmt_info, conversion,
-			  get_vectype_for_scalar_type (type));
+			  get_vectype_for_scalar_type (vinfo, type));
   return new_value;
 }
 
@@ -4583,7 +4595,8 @@  vect_recog_gather_scatter_pattern (stmt_
     return NULL;
 
   /* Convert the mask to the right form.  */
-  tree gs_vectype = get_vectype_for_scalar_type (gs_info.element_type);
+  tree gs_vectype = get_vectype_for_scalar_type (loop_vinfo,
+						 gs_info.element_type);
   if (mask)
     mask = vect_convert_mask_for_vectype (mask, gs_vectype, stmt_info,
 					  loop_vinfo);
Index: gcc/tree-vect-slp.c
===================================================================
--- gcc/tree-vect-slp.c	2019-10-20 13:59:25.923035567 +0100
+++ gcc/tree-vect-slp.c	2019-10-20 14:14:09.668722173 +0100
@@ -1127,7 +1127,7 @@  vect_build_slp_tree_2 (vec_info *vinfo,
   if (gphi *stmt = dyn_cast <gphi *> (stmt_info->stmt))
     {
       tree scalar_type = TREE_TYPE (PHI_RESULT (stmt));
-      tree vectype = get_vectype_for_scalar_type (scalar_type);
+      tree vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
       if (!vect_record_max_nunits (stmt_info, group_size, vectype, max_nunits))
 	return NULL;
 
@@ -1926,7 +1926,7 @@  vect_analyze_slp_instance (vec_info *vin
   if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
     {
       scalar_type = TREE_TYPE (DR_REF (dr));
-      vectype = get_vectype_for_scalar_type (scalar_type);
+      vectype = get_vectype_for_scalar_type (vinfo, scalar_type);
       group_size = DR_GROUP_SIZE (stmt_info);
     }
   else if (!dr && REDUC_GROUP_FIRST_ELEMENT (stmt_info))
@@ -3287,6 +3287,7 @@  vect_get_constant_vectors (tree op, slp_
 {
   vec<stmt_vec_info> stmts = SLP_TREE_SCALAR_STMTS (slp_node);
   stmt_vec_info stmt_vinfo = stmts[0];
+  vec_info *vinfo = stmt_vinfo->vinfo;
   gimple *stmt = stmt_vinfo->stmt;
   unsigned HOST_WIDE_INT nunits;
   tree vec_cst;
@@ -3310,7 +3311,7 @@  vect_get_constant_vectors (tree op, slp_
     vector_type
       = build_same_sized_truth_vector_type (STMT_VINFO_VECTYPE (stmt_vinfo));
   else
-    vector_type = get_vectype_for_scalar_type (TREE_TYPE (op));
+    vector_type = get_vectype_for_scalar_type (vinfo, TREE_TYPE (op));
 
   if (STMT_VINFO_DATA_REF (stmt_vinfo))
     {


Pass a vec_info to duplicate_and_interleave

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (duplicate_and_interleave): Take a vec_info.
	* tree-vect-slp.c (duplicate_and_interleave): Likewise.
	(vect_get_constant_vectors): Update call accordingly.
	* tree-vect-loop.c (get_initial_defs_for_reduction): Likewise.

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2019-10-20 14:14:09.672722145 +0100
+++ gcc/tree-vectorizer.h	2019-10-20 14:14:13.256696547 +0100
@@ -1754,8 +1754,8 @@  extern bool is_simple_and_all_uses_invar
 extern bool can_duplicate_and_interleave_p (unsigned int, machine_mode,
 					    unsigned int * = NULL,
 					    tree * = NULL, tree * = NULL);
-extern void duplicate_and_interleave (gimple_seq *, tree, vec<tree>,
-				      unsigned int, vec<tree> &);
+extern void duplicate_and_interleave (vec_info *, gimple_seq *, tree,
+				      vec<tree>, unsigned int, vec<tree> &);
 extern int vect_get_place_in_interleaving_chain (stmt_vec_info, stmt_vec_info);
 
 /* In tree-vect-patterns.c.  */
Index: gcc/tree-vect-slp.c
===================================================================
--- gcc/tree-vect-slp.c	2019-10-20 14:14:09.668722173 +0100
+++ gcc/tree-vect-slp.c	2019-10-20 14:14:13.256696547 +0100
@@ -3183,8 +3183,9 @@  vect_mask_constant_operand_p (stmt_vec_i
    to cut down on the number of interleaves.  */
 
 void
-duplicate_and_interleave (gimple_seq *seq, tree vector_type, vec<tree> elts,
-			  unsigned int nresults, vec<tree> &results)
+duplicate_and_interleave (vec_info *, gimple_seq *seq, tree vector_type,
+			  vec<tree> elts, unsigned int nresults,
+			  vec<tree> &results)
 {
   unsigned int nelts = elts.length ();
   tree element_type = TREE_TYPE (vector_type);
@@ -3473,8 +3474,8 @@  vect_get_constant_vectors (tree op, slp_
 	      else
 		{
 		  if (vec_oprnds->is_empty ())
-		    duplicate_and_interleave (&ctor_seq, vector_type, elts,
-					      number_of_vectors,
+		    duplicate_and_interleave (vinfo, &ctor_seq, vector_type,
+					      elts, number_of_vectors,
 					      permute_results);
 		  vec_cst = permute_results[number_of_vectors - j - 1];
 		}
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2019-10-20 14:14:09.668722173 +0100
+++ gcc/tree-vect-loop.c	2019-10-20 14:14:13.252696575 +0100
@@ -3878,6 +3878,7 @@  get_initial_defs_for_reduction (slp_tree
 {
   vec<stmt_vec_info> stmts = SLP_TREE_SCALAR_STMTS (slp_node);
   stmt_vec_info stmt_vinfo = stmts[0];
+  vec_info *vinfo = stmt_vinfo->vinfo;
   unsigned HOST_WIDE_INT nunits;
   unsigned j, number_of_places_left_in_vector;
   tree vector_type;
@@ -3970,7 +3971,7 @@  get_initial_defs_for_reduction (slp_tree
 	    {
 	      /* First time round, duplicate ELTS to fill the
 		 required number of vectors.  */
-	      duplicate_and_interleave (&ctor_seq, vector_type, elts,
+	      duplicate_and_interleave (vinfo, &ctor_seq, vector_type, elts,
 					number_of_vectors, *vec_oprnds);
 	      break;
 	    }


Pass a vec_info to can_duplicate_and_interleave_p

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (can_duplicate_and_interleave_p): Take a vec_info.
	* tree-vect-slp.c (can_duplicate_and_interleave_p): Likewise.
	(duplicate_and_interleave): Update call accordingly.
	* tree-vect-loop.c (vectorizable_reduction): Likewise.

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2019-10-20 14:14:13.256696547 +0100
+++ gcc/tree-vectorizer.h	2019-10-20 14:14:16.688672033 +0100
@@ -1751,7 +1751,8 @@  extern void vect_get_slp_defs (vec<tree>
 extern bool vect_slp_bb (basic_block);
 extern stmt_vec_info vect_find_last_scalar_stmt_in_slp (slp_tree);
 extern bool is_simple_and_all_uses_invariant (stmt_vec_info, loop_vec_info);
-extern bool can_duplicate_and_interleave_p (unsigned int, machine_mode,
+extern bool can_duplicate_and_interleave_p (vec_info *, unsigned int,
+					    machine_mode,
 					    unsigned int * = NULL,
 					    tree * = NULL, tree * = NULL);
 extern void duplicate_and_interleave (vec_info *, gimple_seq *, tree,
Index: gcc/tree-vect-slp.c
===================================================================
--- gcc/tree-vect-slp.c	2019-10-20 14:14:13.256696547 +0100
+++ gcc/tree-vect-slp.c	2019-10-20 14:14:16.688672033 +0100
@@ -233,7 +233,8 @@  vect_get_place_in_interleaving_chain (st
    (if nonnull).  */
 
 bool
-can_duplicate_and_interleave_p (unsigned int count, machine_mode elt_mode,
+can_duplicate_and_interleave_p (vec_info *, unsigned int count,
+				machine_mode elt_mode,
 				unsigned int *nvectors_out,
 				tree *vector_type_out,
 				tree *permutes)
@@ -432,7 +433,7 @@  vect_get_and_check_slp_defs (vec_info *v
 	       || dt == vect_external_def)
 	      && !current_vector_size.is_constant ()
 	      && (TREE_CODE (type) == BOOLEAN_TYPE
-		  || !can_duplicate_and_interleave_p (stmts.length (),
+		  || !can_duplicate_and_interleave_p (vinfo, stmts.length (),
 						      TYPE_MODE (type))))
 	    {
 	      if (dump_enabled_p ())
@@ -3183,7 +3184,7 @@  vect_mask_constant_operand_p (stmt_vec_i
    to cut down on the number of interleaves.  */
 
 void
-duplicate_and_interleave (vec_info *, gimple_seq *seq, tree vector_type,
+duplicate_and_interleave (vec_info *vinfo, gimple_seq *seq, tree vector_type,
 			  vec<tree> elts, unsigned int nresults,
 			  vec<tree> &results)
 {
@@ -3194,7 +3195,7 @@  duplicate_and_interleave (vec_info *, gi
   unsigned int nvectors = 1;
   tree new_vector_type;
   tree permutes[2];
-  if (!can_duplicate_and_interleave_p (nelts, TYPE_MODE (element_type),
+  if (!can_duplicate_and_interleave_p (vinfo, nelts, TYPE_MODE (element_type),
 				       &nvectors, &new_vector_type,
 				       permutes))
     gcc_unreachable ();
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2019-10-20 14:14:13.252696575 +0100
+++ gcc/tree-vect-loop.c	2019-10-20 14:14:16.684672061 +0100
@@ -6145,7 +6145,8 @@  vectorizable_reduction (stmt_vec_info st
       unsigned int group_size = SLP_INSTANCE_GROUP_SIZE (slp_node_instance);
       scalar_mode elt_mode = SCALAR_TYPE_MODE (TREE_TYPE (vectype_out));
       if (!neutral_op
-	  && !can_duplicate_and_interleave_p (group_size, elt_mode))
+	  && !can_duplicate_and_interleave_p (loop_vinfo, group_size,
+					      elt_mode))
 	{
 	  if (dump_enabled_p ())
 	    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,


Pass a vec_info to simple_integer_narrowing

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vect-stmts.c (simple_integer_narrowing): Take a vec_info.
	(vectorizable_call): Update call accordingly.

Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2019-10-20 14:14:09.672722145 +0100
+++ gcc/tree-vect-stmts.c	2019-10-20 14:14:19.748650179 +0100
@@ -3175,7 +3175,7 @@  vectorizable_bswap (stmt_vec_info stmt_i
    *CONVERT_CODE.  */
 
 static bool
-simple_integer_narrowing (tree vectype_out, tree vectype_in,
+simple_integer_narrowing (vec_info *, tree vectype_out, tree vectype_in,
 			  tree_code *convert_code)
 {
   if (!INTEGRAL_TYPE_P (TREE_TYPE (vectype_out))
@@ -3369,7 +3369,7 @@  vectorizable_call (stmt_vec_info stmt_in
   if (cfn != CFN_LAST
       && (modifier == NONE
 	  || (modifier == NARROW
-	      && simple_integer_narrowing (vectype_out, vectype_in,
+	      && simple_integer_narrowing (vinfo, vectype_out, vectype_in,
 					   &convert_code))))
     ifn = vectorizable_internal_function (cfn, callee, vectype_out,
 					  vectype_in);


Pass a vec_info to supportable_narrowing_operation

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (supportable_narrowing_operation): Take a vec_info.
	* tree-vect-stmts.c (supportable_narrowing_operation): Likewise.
	(simple_integer_narrowing): Update call accordingly.
	(vectorizable_conversion): Likewise.

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2019-10-20 14:14:16.688672033 +0100
+++ gcc/tree-vectorizer.h	2019-10-20 14:14:23.176625692 +0100
@@ -1603,8 +1603,8 @@  extern bool supportable_widening_operati
 					    tree, tree, enum tree_code *,
 					    enum tree_code *, int *,
 					    vec<tree> *);
-extern bool supportable_narrowing_operation (enum tree_code, tree, tree,
-					     enum tree_code *,
+extern bool supportable_narrowing_operation (vec_info *, enum tree_code, tree,
+					     tree, enum tree_code *,
 					     int *, vec<tree> *);
 extern unsigned record_stmt_cost (stmt_vector_for_cost *, int,
 				  enum vect_cost_for_stmt, stmt_vec_info,
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2019-10-20 14:14:19.748650179 +0100
+++ gcc/tree-vect-stmts.c	2019-10-20 14:14:23.176625692 +0100
@@ -3175,7 +3175,7 @@  vectorizable_bswap (stmt_vec_info stmt_i
    *CONVERT_CODE.  */
 
 static bool
-simple_integer_narrowing (vec_info *, tree vectype_out, tree vectype_in,
+simple_integer_narrowing (vec_info *vinfo, tree vectype_out, tree vectype_in,
 			  tree_code *convert_code)
 {
   if (!INTEGRAL_TYPE_P (TREE_TYPE (vectype_out))
@@ -3185,8 +3185,8 @@  simple_integer_narrowing (vec_info *, tr
   tree_code code;
   int multi_step_cvt = 0;
   auto_vec <tree, 8> interm_types;
-  if (!supportable_narrowing_operation (NOP_EXPR, vectype_out, vectype_in,
-					&code, &multi_step_cvt,
+  if (!supportable_narrowing_operation (vinfo, NOP_EXPR, vectype_out,
+					vectype_in, &code, &multi_step_cvt,
 					&interm_types)
       || multi_step_cvt)
     return false;
@@ -4957,8 +4957,8 @@  vectorizable_conversion (stmt_vec_info s
 
     case NARROW:
       gcc_assert (op_type == unary_op);
-      if (supportable_narrowing_operation (code, vectype_out, vectype_in,
-					   &code1, &multi_step_cvt,
+      if (supportable_narrowing_operation (vinfo, code, vectype_out,
+					   vectype_in, &code1, &multi_step_cvt,
 					   &interm_types))
 	break;
 
@@ -4974,8 +4974,8 @@  vectorizable_conversion (stmt_vec_info s
       if (!supportable_convert_operation (code, cvt_type, vectype_in,
 					  &decl1, &codecvt1))
 	goto unsupported;
-      if (supportable_narrowing_operation (NOP_EXPR, vectype_out, cvt_type,
-					   &code1, &multi_step_cvt,
+      if (supportable_narrowing_operation (vinfo, NOP_EXPR, vectype_out,
+					   cvt_type, &code1, &multi_step_cvt,
 					   &interm_types))
 	break;
       goto unsupported;
@@ -11649,7 +11649,7 @@  supportable_widening_operation (enum tre
    narrowing operation (short in the above example).   */
 
 bool
-supportable_narrowing_operation (enum tree_code code,
+supportable_narrowing_operation (vec_info *, enum tree_code code,
 				 tree vectype_out, tree vectype_in,
 				 enum tree_code *code1, int *multi_step_cvt,
                                  vec<tree> *interm_types)


Pass a loop_vec_info to vect_maybe_permute_loop_masks

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vect-loop-manip.c (vect_maybe_permute_loop_masks): Take
	a loop_vec_info.
	(vect_set_loop_condition_masked): Update call accordingly.

Index: gcc/tree-vect-loop-manip.c
===================================================================
--- gcc/tree-vect-loop-manip.c	2019-10-17 14:22:54.919313309 +0100
+++ gcc/tree-vect-loop-manip.c	2019-10-20 14:14:26.736600265 +0100
@@ -317,7 +317,8 @@  interleave_supported_p (vec_perm_indices
    latter.  Return true on success, adding any new statements to SEQ.  */
 
 static bool
-vect_maybe_permute_loop_masks (gimple_seq *seq, rgroup_masks *dest_rgm,
+vect_maybe_permute_loop_masks (loop_vec_info, gimple_seq *seq,
+			       rgroup_masks *dest_rgm,
 			       rgroup_masks *src_rgm)
 {
   tree src_masktype = src_rgm->mask_type;
@@ -689,7 +690,8 @@  vect_set_loop_condition_masked (class lo
 	  {
 	    rgroup_masks *half_rgm = &(*masks)[nmasks / 2 - 1];
 	    if (!half_rgm->masks.is_empty ()
-		&& vect_maybe_permute_loop_masks (&header_seq, rgm, half_rgm))
+		&& vect_maybe_permute_loop_masks (loop_vinfo, &header_seq,
+						  rgm, half_rgm))
 	      continue;
 	  }
 

Pass a vec_info to vect_halve_mask_nunits

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (vect_halve_mask_nunits): Take a vec_info.
	* tree-vect-loop.c (vect_halve_mask_nunits): Likewise.
	* tree-vect-loop-manip.c (vect_maybe_permute_loop_masks): Update
	call accordingly.
	* tree-vect-stmts.c (supportable_widening_operation): Likewise.

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2019-10-20 14:14:23.176625692 +0100
+++ gcc/tree-vectorizer.h	2019-10-20 14:14:30.500573381 +0100
@@ -1705,7 +1705,7 @@  extern opt_loop_vec_info vect_analyze_lo
 extern tree vect_build_loop_niters (loop_vec_info, bool * = NULL);
 extern void vect_gen_vector_loop_niters (loop_vec_info, tree, tree *,
 					 tree *, bool);
-extern tree vect_halve_mask_nunits (tree);
+extern tree vect_halve_mask_nunits (vec_info *, tree);
 extern tree vect_double_mask_nunits (tree);
 extern void vect_record_loop_mask (loop_vec_info, vec_loop_masks *,
 				   unsigned int, tree, tree);
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2019-10-20 14:14:16.684672061 +0100
+++ gcc/tree-vect-loop.c	2019-10-20 14:14:30.496573409 +0100
@@ -7745,7 +7745,7 @@  loop_niters_no_overflow (loop_vec_info l
 /* Return a mask type with half the number of elements as TYPE.  */
 
 tree
-vect_halve_mask_nunits (tree type)
+vect_halve_mask_nunits (vec_info *, tree type)
 {
   poly_uint64 nunits = exact_div (TYPE_VECTOR_SUBPARTS (type), 2);
   return build_truth_vector_type (nunits, current_vector_size);
Index: gcc/tree-vect-loop-manip.c
===================================================================
--- gcc/tree-vect-loop-manip.c	2019-10-20 14:14:26.736600265 +0100
+++ gcc/tree-vect-loop-manip.c	2019-10-20 14:14:30.496573409 +0100
@@ -317,7 +317,7 @@  interleave_supported_p (vec_perm_indices
    latter.  Return true on success, adding any new statements to SEQ.  */
 
 static bool
-vect_maybe_permute_loop_masks (loop_vec_info, gimple_seq *seq,
+vect_maybe_permute_loop_masks (loop_vec_info loop_vinfo, gimple_seq *seq,
 			       rgroup_masks *dest_rgm,
 			       rgroup_masks *src_rgm)
 {
@@ -330,7 +330,7 @@  vect_maybe_permute_loop_masks (loop_vec_
     {
       /* Unpacking the source masks gives at least as many mask bits as
 	 we need.  We can then VIEW_CONVERT any excess bits away.  */
-      tree unpack_masktype = vect_halve_mask_nunits (src_masktype);
+      tree unpack_masktype = vect_halve_mask_nunits (loop_vinfo, src_masktype);
       for (unsigned int i = 0; i < dest_rgm->masks.length (); ++i)
 	{
 	  tree src = src_rgm->masks[i / 2];
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2019-10-20 14:14:23.176625692 +0100
+++ gcc/tree-vect-stmts.c	2019-10-20 14:14:30.500573381 +0100
@@ -11385,6 +11385,7 @@  supportable_widening_operation (enum tre
                                 int *multi_step_cvt,
                                 vec<tree> *interm_types)
 {
+  vec_info *vinfo = stmt_info->vinfo;
   loop_vec_info loop_info = STMT_VINFO_LOOP_VINFO (stmt_info);
   class loop *vect_loop = NULL;
   machine_mode vec_mode;
@@ -11570,7 +11571,7 @@  supportable_widening_operation (enum tre
       intermediate_mode = insn_data[icode1].operand[0].mode;
       if (VECTOR_BOOLEAN_TYPE_P (prev_type))
 	{
-	  intermediate_type = vect_halve_mask_nunits (prev_type);
+	  intermediate_type = vect_halve_mask_nunits (vinfo, prev_type);
 	  if (intermediate_mode != TYPE_MODE (intermediate_type))
 	    return false;
 	}


Pass a vec_info to vect_double_mask_nunits

2019-10-20  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (vect_double_mask_nunits): Take a vec_info.
	* tree-vect-loop.c (vect_double_mask_nunits): Likewise.
	* tree-vect-stmts.c (supportable_narrowing_operation):  Update call
	accordingly.

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2019-10-20 14:14:30.500573381 +0100
+++ gcc/tree-vectorizer.h	2019-10-20 14:14:33.692550581 +0100
@@ -1706,7 +1706,7 @@  extern tree vect_build_loop_niters (loop
 extern void vect_gen_vector_loop_niters (loop_vec_info, tree, tree *,
 					 tree *, bool);
 extern tree vect_halve_mask_nunits (vec_info *, tree);
-extern tree vect_double_mask_nunits (tree);
+extern tree vect_double_mask_nunits (vec_info *, tree);
 extern void vect_record_loop_mask (loop_vec_info, vec_loop_masks *,
 				   unsigned int, tree, tree);
 extern tree vect_get_loop_mask (gimple_stmt_iterator *, vec_loop_masks *,
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2019-10-20 14:14:30.496573409 +0100
+++ gcc/tree-vect-loop.c	2019-10-20 14:14:33.692550581 +0100
@@ -7754,7 +7754,7 @@  vect_halve_mask_nunits (vec_info *, tree
 /* Return a mask type with twice as many elements as TYPE.  */
 
 tree
-vect_double_mask_nunits (tree type)
+vect_double_mask_nunits (vec_info *, tree type)
 {
   poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (type) * 2;
   return build_truth_vector_type (nunits, current_vector_size);
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2019-10-20 14:14:30.500573381 +0100
+++ gcc/tree-vect-stmts.c	2019-10-20 14:14:33.692550581 +0100
@@ -11650,7 +11650,7 @@  supportable_widening_operation (enum tre
    narrowing operation (short in the above example).   */
 
 bool
-supportable_narrowing_operation (vec_info *, enum tree_code code,
+supportable_narrowing_operation (vec_info *vinfo, enum tree_code code,
 				 tree vectype_out, tree vectype_in,
 				 enum tree_code *code1, int *multi_step_cvt,
                                  vec<tree> *interm_types)
@@ -11759,7 +11759,7 @@  supportable_narrowing_operation (vec_inf
       intermediate_mode = insn_data[icode1].operand[0].mode;
       if (VECTOR_BOOLEAN_TYPE_P (prev_type))
 	{
-	  intermediate_type = vect_double_mask_nunits (prev_type);
+	  intermediate_type = vect_double_mask_nunits (vinfo, prev_type);
 	  if (intermediate_mode != TYPE_MODE (intermediate_type))
 	    return false;
 	}