Add build_truth_vector_type_for_mode
Richard Biener
richard.guenther@gmail.com
Fri Oct 25 08:26:00 GMT 2019
On Wed, Oct 23, 2019 at 1:10 PM Richard Sandiford
<richard.sandiford@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.sandiford@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);
More information about the Gcc-patches
mailing list