On Wed, Oct 23, 2019 at 1:10 PM Richard Sandiford <richard.sandif...@arm.com> wrote: > > Callers of vect_halve_mask_nunits and vect_double_mask_nunits > already know what mode the resulting vector type should have, > so we might as well create the vector type directly with that mode, > just like build_vector_type_for_mode lets us build normal vectors > with a known mode. This avoids the current awkwardness of having > to recompute the mode starting from vec_info::vector_size, which > hard-codes the assumption that all vectors have to be the same size. > > A later patch gets rid of build_truth_vector_type and > build_same_sized_truth_vector_type, so the net effect of the > series is to reduce the number of type functions by one. > > Tested individually on aarch64-linux-gnu and as a series on > x86_64-linux-gnu. OK to install?
OK. Thanks, Richard. > Richard > > > 2019-10-23 Richard Sandiford <richard.sandif...@arm.com> > > gcc/ > * tree.h (build_truth_vector_type_for_mode): Declare. > * tree.c (build_truth_vector_type_for_mode): New function, > split out from... > (build_truth_vector_type): ...here. > (build_opaque_vector_type): Fix head comment. > * tree-vectorizer.h (supportable_narrowing_operation): Remove > vec_info parameter. > (vect_halve_mask_nunits): Replace vec_info parameter with the > mode of the new vector. > (vect_double_mask_nunits): Likewise. > * tree-vect-loop.c (vect_halve_mask_nunits): Likewise. > (vect_double_mask_nunits): Likewise. > * tree-vect-loop-manip.c: Include insn-config.h, rtl.h and recog.h. > (vect_maybe_permute_loop_masks): Remove vinfo parameter. Update call > to vect_halve_mask_nunits, getting the required mode from the unpack > patterns. > (vect_set_loop_condition_masked): Update call accordingly. > * tree-vect-stmts.c (supportable_narrowing_operation): Remove vec_info > parameter and update call to vect_double_mask_nunits. > (vectorizable_conversion): Update call accordingly. > (simple_integer_narrowing): Likewise. Remove vec_info parameter. > (vectorizable_call): Update call accordingly. > (supportable_widening_operation): Update call to > vect_halve_mask_nunits. > > Index: gcc/tree.h > =================================================================== > --- gcc/tree.h 2019-09-21 13:56:07.519944842 +0100 > +++ gcc/tree.h 2019-10-23 12:07:54.505663970 +0100 > @@ -4437,6 +4437,7 @@ extern tree build_reference_type_for_mod > extern tree build_reference_type (tree); > extern tree build_vector_type_for_mode (tree, machine_mode); > extern tree build_vector_type (tree, poly_int64); > +extern tree build_truth_vector_type_for_mode (poly_uint64, machine_mode); > extern tree build_truth_vector_type (poly_uint64, poly_uint64); > extern tree build_same_sized_truth_vector_type (tree vectype); > extern tree build_opaque_vector_type (tree, poly_int64); > Index: gcc/tree.c > =================================================================== > --- gcc/tree.c 2019-10-20 13:58:01.679637360 +0100 > +++ gcc/tree.c 2019-10-23 12:07:54.501663998 +0100 > @@ -11113,25 +11113,35 @@ build_vector_type (tree innertype, poly_ > return make_vector_type (innertype, nunits, VOIDmode); > } > > +/* Build a truth vector with NUNITS units, giving it mode MASK_MODE. */ > + > +tree > +build_truth_vector_type_for_mode (poly_uint64 nunits, machine_mode mask_mode) > +{ > + gcc_assert (mask_mode != BLKmode); > + > + poly_uint64 vsize = GET_MODE_BITSIZE (mask_mode); > + unsigned HOST_WIDE_INT esize = vector_element_size (vsize, nunits); > + tree bool_type = build_nonstandard_boolean_type (esize); > + > + return make_vector_type (bool_type, nunits, mask_mode); > +} > + > /* Build truth vector with specified length and number of units. */ > > tree > build_truth_vector_type (poly_uint64 nunits, poly_uint64 vector_size) > { > - machine_mode mask_mode > - = targetm.vectorize.get_mask_mode (nunits, vector_size).else_blk (); > - > - poly_uint64 vsize; > - if (mask_mode == BLKmode) > - vsize = vector_size * BITS_PER_UNIT; > - else > - vsize = GET_MODE_BITSIZE (mask_mode); > + machine_mode mask_mode; > + if (targetm.vectorize.get_mask_mode (nunits, > + vector_size).exists (&mask_mode)) > + return build_truth_vector_type_for_mode (nunits, mask_mode); > > + poly_uint64 vsize = vector_size * BITS_PER_UNIT; > unsigned HOST_WIDE_INT esize = vector_element_size (vsize, nunits); > - > tree bool_type = build_nonstandard_boolean_type (esize); > > - return make_vector_type (bool_type, nunits, mask_mode); > + return make_vector_type (bool_type, nunits, BLKmode); > } > > /* Returns a vector type corresponding to a comparison of VECTYPE. */ > @@ -11150,7 +11160,8 @@ build_same_sized_truth_vector_type (tree > return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype), size); > } > > -/* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */ > +/* Like build_vector_type, but builds a variant type with TYPE_VECTOR_OPAQUE > + set. */ > > tree > build_opaque_vector_type (tree innertype, poly_int64 nunits) > Index: gcc/tree-vectorizer.h > =================================================================== > --- gcc/tree-vectorizer.h 2019-10-22 08:46:56.395362885 +0100 > +++ gcc/tree-vectorizer.h 2019-10-23 12:07:54.501663998 +0100 > @@ -1609,9 +1609,9 @@ extern bool supportable_widening_operati > tree, tree, enum tree_code *, > enum tree_code *, int *, > vec<tree> *); > -extern bool supportable_narrowing_operation (vec_info *, enum tree_code, > tree, > - tree, enum tree_code *, > - int *, vec<tree> *); > +extern bool supportable_narrowing_operation (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, > int, enum vect_cost_model_location); > @@ -1711,8 +1711,8 @@ 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 (vec_info *, tree); > -extern tree vect_double_mask_nunits (vec_info *, tree); > +extern tree vect_halve_mask_nunits (tree, machine_mode); > +extern tree vect_double_mask_nunits (tree, machine_mode); > 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-23 11:29:46.721892339 +0100 > +++ gcc/tree-vect-loop.c 2019-10-23 12:07:54.497664026 +0100 > @@ -7746,22 +7746,24 @@ loop_niters_no_overflow (loop_vec_info l > return false; > } > > -/* Return a mask type with half the number of elements as TYPE. */ > +/* Return a mask type with half the number of elements as OLD_TYPE, > + given that it should have mode NEW_MODE. */ > > tree > -vect_halve_mask_nunits (vec_info *vinfo, tree type) > +vect_halve_mask_nunits (tree old_type, machine_mode new_mode) > { > - poly_uint64 nunits = exact_div (TYPE_VECTOR_SUBPARTS (type), 2); > - return build_truth_vector_type (nunits, vinfo->vector_size); > + poly_uint64 nunits = exact_div (TYPE_VECTOR_SUBPARTS (old_type), 2); > + return build_truth_vector_type_for_mode (nunits, new_mode); > } > > -/* Return a mask type with twice as many elements as TYPE. */ > +/* Return a mask type with twice as many elements as OLD_TYPE, > + given that it should have mode NEW_MODE. */ > > tree > -vect_double_mask_nunits (vec_info *vinfo, tree type) > +vect_double_mask_nunits (tree old_type, machine_mode new_mode) > { > - poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (type) * 2; > - return build_truth_vector_type (nunits, vinfo->vector_size); > + poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (old_type) * 2; > + return build_truth_vector_type_for_mode (nunits, new_mode); > } > > /* Record that a fully-masked version of LOOP_VINFO would need MASKS to > Index: gcc/tree-vect-loop-manip.c > =================================================================== > --- gcc/tree-vect-loop-manip.c 2019-10-21 07:41:22.533961407 +0100 > +++ gcc/tree-vect-loop-manip.c 2019-10-23 12:07:54.493664054 +0100 > @@ -47,6 +47,9 @@ Software Foundation; either version 3, o > #include "stor-layout.h" > #include "optabs-query.h" > #include "vec-perm-indices.h" > +#include "insn-config.h" > +#include "rtl.h" > +#include "recog.h" > > /************************************************************************* > Simple Loop Peeling Utilities > @@ -317,20 +320,24 @@ 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 loop_vinfo, gimple_seq *seq, > - rgroup_masks *dest_rgm, > +vect_maybe_permute_loop_masks (gimple_seq *seq, rgroup_masks *dest_rgm, > rgroup_masks *src_rgm) > { > tree src_masktype = src_rgm->mask_type; > tree dest_masktype = dest_rgm->mask_type; > machine_mode src_mode = TYPE_MODE (src_masktype); > + insn_code icode1, icode2; > if (dest_rgm->max_nscalars_per_iter <= src_rgm->max_nscalars_per_iter > - && optab_handler (vec_unpacku_hi_optab, src_mode) != CODE_FOR_nothing > - && optab_handler (vec_unpacku_lo_optab, src_mode) != CODE_FOR_nothing) > + && (icode1 = optab_handler (vec_unpacku_hi_optab, > + src_mode)) != CODE_FOR_nothing > + && (icode2 = optab_handler (vec_unpacku_lo_optab, > + src_mode)) != CODE_FOR_nothing) > { > /* 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 (loop_vinfo, > src_masktype); > + machine_mode dest_mode = insn_data[icode1].operand[0].mode; > + gcc_assert (dest_mode == insn_data[icode2].operand[0].mode); > + tree unpack_masktype = vect_halve_mask_nunits (src_masktype, > dest_mode); > for (unsigned int i = 0; i < dest_rgm->masks.length (); ++i) > { > tree src = src_rgm->masks[i / 2]; > @@ -690,8 +697,7 @@ 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 (loop_vinfo, &header_seq, > - rgm, half_rgm)) > + && vect_maybe_permute_loop_masks (&header_seq, rgm, half_rgm)) > continue; > } > > Index: gcc/tree-vect-stmts.c > =================================================================== > --- gcc/tree-vect-stmts.c 2019-10-23 11:33:01.572510226 +0100 > +++ gcc/tree-vect-stmts.c 2019-10-23 12:07:54.497664026 +0100 > @@ -3166,7 +3166,7 @@ vectorizable_bswap (stmt_vec_info stmt_i > *CONVERT_CODE. */ > > static bool > -simple_integer_narrowing (vec_info *vinfo, tree vectype_out, tree vectype_in, > +simple_integer_narrowing (tree vectype_out, tree vectype_in, > tree_code *convert_code) > { > if (!INTEGRAL_TYPE_P (TREE_TYPE (vectype_out)) > @@ -3176,9 +3176,8 @@ simple_integer_narrowing (vec_info *vinf > tree_code code; > int multi_step_cvt = 0; > auto_vec <tree, 8> interm_types; > - if (!supportable_narrowing_operation (vinfo, NOP_EXPR, vectype_out, > - vectype_in, &code, &multi_step_cvt, > - &interm_types) > + if (!supportable_narrowing_operation (NOP_EXPR, vectype_out, vectype_in, > + &code, &multi_step_cvt, &interm_types) > || multi_step_cvt) > return false; > > @@ -3360,7 +3359,7 @@ vectorizable_call (stmt_vec_info stmt_in > if (cfn != CFN_LAST > && (modifier == NONE > || (modifier == NARROW > - && simple_integer_narrowing (vinfo, vectype_out, vectype_in, > + && simple_integer_narrowing (vectype_out, vectype_in, > &convert_code)))) > ifn = vectorizable_internal_function (cfn, callee, vectype_out, > vectype_in); > @@ -4944,8 +4943,8 @@ vectorizable_conversion (stmt_vec_info s > > case NARROW: > gcc_assert (op_type == unary_op); > - if (supportable_narrowing_operation (vinfo, code, vectype_out, > - vectype_in, &code1, > &multi_step_cvt, > + if (supportable_narrowing_operation (code, vectype_out, vectype_in, > + &code1, &multi_step_cvt, > &interm_types)) > break; > > @@ -4961,8 +4960,8 @@ vectorizable_conversion (stmt_vec_info s > if (!supportable_convert_operation (code, cvt_type, vectype_in, > &decl1, &codecvt1)) > goto unsupported; > - if (supportable_narrowing_operation (vinfo, NOP_EXPR, vectype_out, > - cvt_type, &code1, &multi_step_cvt, > + if (supportable_narrowing_operation (NOP_EXPR, vectype_out, cvt_type, > + &code1, &multi_step_cvt, > &interm_types)) > break; > goto unsupported; > @@ -11377,7 +11376,6 @@ 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; > @@ -11562,11 +11560,8 @@ 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 (vinfo, prev_type); > - if (intermediate_mode != TYPE_MODE (intermediate_type)) > - return false; > - } > + intermediate_type > + = vect_halve_mask_nunits (prev_type, intermediate_mode); > else > intermediate_type > = lang_hooks.types.type_for_mode (intermediate_mode, > @@ -11642,7 +11637,7 @@ supportable_widening_operation (enum tre > narrowing operation (short in the above example). */ > > bool > -supportable_narrowing_operation (vec_info *vinfo, enum tree_code code, > +supportable_narrowing_operation (enum tree_code code, > tree vectype_out, tree vectype_in, > enum tree_code *code1, int *multi_step_cvt, > vec<tree> *interm_types) > @@ -11750,11 +11745,8 @@ 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 (vinfo, prev_type); > - if (intermediate_mode != TYPE_MODE (intermediate_type)) > - return false; > - } > + intermediate_type > + = vect_double_mask_nunits (prev_type, intermediate_mode); > else > intermediate_type > = lang_hooks.types.type_for_mode (intermediate_mode, uns);