This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: Remove build_{same_sized_,}truth_vector_type
- From: Richard Biener <richard dot guenther at gmail dot com>
- To: Richard Sandiford <richard dot sandiford at arm dot com>
- Cc: GCC Patches <gcc-patches at gcc dot gnu dot org>
- Date: Fri, 25 Oct 2019 10:26:05 +0200
- Subject: Re: Remove build_{same_sized_,}truth_vector_type
- References: <mpteez3emv1.fsf@arm.com>
On Wed, Oct 23, 2019 at 1:13 PM Richard Sandiford
<richard.sandiford@arm.com> wrote:
>
> build_same_sized_truth_vector_type was confusingly named, since for
> SVE and AVX512 the returned vector isn't the same byte size (although
> it does have the same number of elements). What it really returns
> is the "truth" vector type for a given data vector type.
>
> The more general truth_type_for provides the same thing when passed
> a vector and IMO has a more descriptive name, so this patch replaces
> all uses of build_same_sized_truth_vector_type with that. It does
> the same for a call to build_truth_vector_type, leaving truth_type_for
> itself as the only remaining caller.
>
> It's then more natural to pass build_truth_vector_type the original
> vector type rather than its size and nunits, especially since the
> given size isn't the size of the returned vector. This in turn allows
> a future patch to simplify the interface of get_mask_mode. Doing this
> also fixes a bug in which truth_type_for would pass a size of zero for
> BLKmode vector types.
>
> 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): Delete.
> (build_same_sized_truth_vector_type): Likewise.
> * tree.c (build_truth_vector_type): Rename to...
> (build_truth_vector_type_for): ...this. Make static and take
> a vector type as argument.
> (truth_type_for): Update accordingly.
> (build_same_sized_truth_vector_type): Delete.
> * tree-vect-generic.c (expand_vector_divmod): Use truth_type_for
> instead of build_same_sized_truth_vector_type.
> * tree-vect-loop.c (vect_create_epilog_for_reduction): Likewise.
> (vect_record_loop_mask, vect_get_loop_mask): Likewise.
> * tree-vect-patterns.c (build_mask_conversion): Likeise.
> * tree-vect-slp.c (vect_get_constant_vectors): Likewise.
> * tree-vect-stmts.c (vect_get_vec_def_for_operand): Likewise.
> (vect_build_gather_load_calls, vectorizable_call): Likewise.
> (scan_store_can_perm_p, vectorizable_scan_store): Likewise.
> (vectorizable_store, vectorizable_condition): Likewise.
> (get_mask_type_for_scalar_type, get_same_sized_vectype): Likewise.
> (vect_get_mask_type_for_stmt): Use truth_type_for instead of
> build_truth_vector_type.
> * config/rs6000/rs6000-call.c (fold_build_vec_cmp): Use truth_type_for
> instead of build_same_sized_truth_vector_type.
>
> gcc/c/
> * c-typeck.c (build_conditional_expr): Use truth_type_for instead
> of build_same_sized_truth_vector_type.
> (build_vec_cmp): Likewise.
>
> gcc/cp/
> * call.c (build_conditional_expr_1): Use truth_type_for instead
> of build_same_sized_truth_vector_type.
> * typeck.c (build_vec_cmp): Likewise.
>
> gcc/d/
> * d-codegen.cc (build_boolop): Use truth_type_for instead of
> build_same_sized_truth_vector_type.
>
> Index: gcc/tree.h
> ===================================================================
> --- gcc/tree.h 2019-10-23 12:07:54.505663970 +0100
> +++ gcc/tree.h 2019-10-23 12:10:58.116366179 +0100
> @@ -4438,8 +4438,6 @@ 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);
> extern tree build_index_type (tree);
> extern tree build_array_type (tree, tree, bool = false);
> Index: gcc/tree.c
> ===================================================================
> --- gcc/tree.c 2019-10-23 12:07:54.501663998 +0100
> +++ gcc/tree.c 2019-10-23 12:10:58.116366179 +0100
> @@ -11127,11 +11127,16 @@ build_truth_vector_type_for_mode (poly_u
> return make_vector_type (bool_type, nunits, mask_mode);
> }
>
> -/* Build truth vector with specified length and number of units. */
> +/* Build a vector type that holds one boolean result for each element of
> + vector type VECTYPE. The public interface for this operation is
> + truth_type_for. */
>
> -tree
> -build_truth_vector_type (poly_uint64 nunits, poly_uint64 vector_size)
> +static tree
> +build_truth_vector_type_for (tree vectype)
> {
> + poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (vectype);
> + poly_uint64 vector_size = tree_to_poly_uint64 (TYPE_SIZE_UNIT (vectype));
> +
> machine_mode mask_mode;
> if (targetm.vectorize.get_mask_mode (nunits,
> vector_size).exists (&mask_mode))
> @@ -11144,22 +11149,6 @@ build_truth_vector_type (poly_uint64 nun
> return make_vector_type (bool_type, nunits, BLKmode);
> }
>
> -/* Returns a vector type corresponding to a comparison of VECTYPE. */
> -
> -tree
> -build_same_sized_truth_vector_type (tree vectype)
> -{
> - if (VECTOR_BOOLEAN_TYPE_P (vectype))
> - return vectype;
> -
> - poly_uint64 size = GET_MODE_SIZE (TYPE_MODE (vectype));
> -
> - if (known_eq (size, 0U))
> - size = tree_to_uhwi (TYPE_SIZE_UNIT (vectype));
> -
> - return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype), size);
> -}
> -
> /* Like build_vector_type, but builds a variant type with TYPE_VECTOR_OPAQUE
> set. */
>
> @@ -12032,8 +12021,7 @@ truth_type_for (tree type)
> {
> if (VECTOR_BOOLEAN_TYPE_P (type))
> return type;
> - return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (type),
> - GET_MODE_SIZE (TYPE_MODE (type)));
> + return build_truth_vector_type_for (type);
> }
> else
> return boolean_type_node;
> Index: gcc/tree-vect-generic.c
> ===================================================================
> --- gcc/tree-vect-generic.c 2019-07-18 09:22:13.893767915 +0100
> +++ gcc/tree-vect-generic.c 2019-10-23 12:10:58.108366235 +0100
> @@ -694,7 +694,7 @@ expand_vector_divmod (gimple_stmt_iterat
> tree zero, cst, cond, mask_type;
> gimple *stmt;
>
> - mask_type = build_same_sized_truth_vector_type (type);
> + mask_type = truth_type_for (type);
> zero = build_zero_cst (type);
> cond = build2 (LT_EXPR, mask_type, op0, zero);
> tree_vector_builder vec (type, nunits, 1);
> Index: gcc/tree-vect-loop.c
> ===================================================================
> --- gcc/tree-vect-loop.c 2019-10-23 12:07:54.497664026 +0100
> +++ gcc/tree-vect-loop.c 2019-10-23 12:10:58.112366207 +0100
> @@ -4446,8 +4446,7 @@ vect_create_epilog_for_reduction (stmt_v
> tree index_vec_type = TREE_TYPE (induction_index);
> gcc_checking_assert (TYPE_UNSIGNED (index_vec_type));
> tree index_scalar_type = TREE_TYPE (index_vec_type);
> - tree index_vec_cmp_type = build_same_sized_truth_vector_type
> - (index_vec_type);
> + tree index_vec_cmp_type = truth_type_for (index_vec_type);
>
> /* Get an unsigned integer version of the type of the data vector. */
> int scalar_precision
> @@ -4692,7 +4691,7 @@ vect_create_epilog_for_reduction (stmt_v
> tree index = build_index_vector (vectype, 0, 1);
> tree index_type = TREE_TYPE (index);
> tree index_elt_type = TREE_TYPE (index_type);
> - tree mask_type = build_same_sized_truth_vector_type (index_type);
> + tree mask_type = truth_type_for (index_type);
>
> /* Create a vector that, for each element, identifies which of
> the REDUC_GROUP_SIZE results should use it. */
> @@ -7794,7 +7793,7 @@ vect_record_loop_mask (loop_vec_info loo
> if (rgm->max_nscalars_per_iter < nscalars_per_iter)
> {
> rgm->max_nscalars_per_iter = nscalars_per_iter;
> - rgm->mask_type = build_same_sized_truth_vector_type (vectype);
> + rgm->mask_type = truth_type_for (vectype);
> }
> }
>
> @@ -7839,7 +7838,7 @@ vect_get_loop_mask (gimple_stmt_iterator
> gcc_assert (multiple_p (TYPE_VECTOR_SUBPARTS (mask_type),
> TYPE_VECTOR_SUBPARTS (vectype)));
> gimple_seq seq = NULL;
> - mask_type = build_same_sized_truth_vector_type (vectype);
> + mask_type = truth_type_for (vectype);
> mask = gimple_build (&seq, VIEW_CONVERT_EXPR, mask_type, mask);
> if (seq)
> gsi_insert_seq_before (gsi, seq, GSI_SAME_STMT);
> Index: gcc/tree-vect-patterns.c
> ===================================================================
> --- gcc/tree-vect-patterns.c 2019-10-21 07:40:50.342192677 +0100
> +++ gcc/tree-vect-patterns.c 2019-10-23 12:10:58.112366207 +0100
> @@ -4214,7 +4214,7 @@ build_mask_conversion (tree mask, tree v
> gimple *stmt;
> tree masktype, tmp;
>
> - masktype = build_same_sized_truth_vector_type (vectype);
> + masktype = truth_type_for (vectype);
> tmp = vect_recog_temp_ssa_var (TREE_TYPE (masktype), NULL);
> stmt = gimple_build_assign (tmp, CONVERT_EXPR, mask);
> append_pattern_def_seq (stmt_vinfo, stmt, masktype);
> Index: gcc/tree-vect-slp.c
> ===================================================================
> --- gcc/tree-vect-slp.c 2019-10-23 11:29:59.000000000 +0100
> +++ gcc/tree-vect-slp.c 2019-10-23 12:10:58.112366207 +0100
> @@ -3383,8 +3383,7 @@ vect_get_constant_vectors (slp_tree op_n
> tree stmt_vectype = STMT_VINFO_VECTYPE (stmt_vinfo);
> if (VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (op))
> && vect_mask_constant_operand_p (stmt_vinfo))
> - vector_type
> - = build_same_sized_truth_vector_type (stmt_vectype);
> + vector_type = truth_type_for (stmt_vectype);
> else
> vector_type = get_vectype_for_scalar_type (vinfo, TREE_TYPE (op));
>
> Index: gcc/tree-vect-stmts.c
> ===================================================================
> --- gcc/tree-vect-stmts.c 2019-10-23 12:07:54.497664026 +0100
> +++ gcc/tree-vect-stmts.c 2019-10-23 12:10:58.116366179 +0100
> @@ -1609,7 +1609,7 @@ vect_get_vec_def_for_operand (tree op, s
> vector_type = vectype;
> else if (VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (op))
> && VECTOR_BOOLEAN_TYPE_P (stmt_vectype))
> - vector_type = build_same_sized_truth_vector_type (stmt_vectype);
> + vector_type = truth_type_for (stmt_vectype);
> else
> vector_type = get_vectype_for_scalar_type (loop_vinfo, TREE_TYPE (op));
>
> @@ -2743,7 +2743,7 @@ vect_build_gather_load_calls (stmt_vec_i
> || TREE_CODE (masktype) == INTEGER_TYPE
> || types_compatible_p (srctype, masktype)));
> if (mask && TREE_CODE (masktype) == INTEGER_TYPE)
> - masktype = build_same_sized_truth_vector_type (srctype);
> + masktype = truth_type_for (srctype);
>
> tree mask_halftype = masktype;
> tree perm_mask = NULL_TREE;
> @@ -2789,8 +2789,7 @@ vect_build_gather_load_calls (stmt_vec_i
> mask_perm_mask = vect_gen_perm_mask_checked (masktype, indices);
> }
> else if (mask)
> - mask_halftype
> - = build_same_sized_truth_vector_type (gs_info->offset_vectype);
> + mask_halftype = truth_type_for (gs_info->offset_vectype);
> }
> else
> gcc_unreachable ();
> @@ -3537,8 +3536,7 @@ vectorizable_call (stmt_vec_info stmt_in
> if (mask_opno >= 0 && !vectypes[mask_opno])
> {
> gcc_assert (modifier != WIDEN);
> - vectypes[mask_opno]
> - = build_same_sized_truth_vector_type (vectype_in);
> + vectypes[mask_opno] = truth_type_for (vectype_in);
> }
>
> for (i = 0; i < nargs; i++)
> @@ -6506,7 +6504,7 @@ scan_store_can_perm_p (tree vectype, tre
> && TREE_CODE (init) != REAL_CST)
> || !initializer_zerop (init))
> {
> - tree masktype = build_same_sized_truth_vector_type (vectype);
> + tree masktype = truth_type_for (vectype);
> if (!expand_vec_cond_expr_p (vectype, masktype, VECTOR_CST))
> return -1;
> whole_vector_shift_kind = scan_store_kind_lshift_cond;
> @@ -7031,7 +7029,7 @@ vectorizable_scan_store (stmt_vec_info s
> zero_vec = build_zero_cst (vectype);
> if (masktype == NULL_TREE
> && use_whole_vector[i] == scan_store_kind_lshift_cond)
> - masktype = build_same_sized_truth_vector_type (vectype);
> + masktype = truth_type_for (vectype);
> perms[i] = vect_gen_perm_mask_any (vectype, indices);
> }
> else
> @@ -7472,8 +7470,7 @@ vectorizable_store (stmt_vec_info stmt_i
> ncopies *= 2;
>
> if (mask)
> - mask_halfvectype
> - = build_same_sized_truth_vector_type (gs_info.offset_vectype);
> + mask_halfvectype = truth_type_for (gs_info.offset_vectype);
> }
> else
> gcc_unreachable ();
> @@ -9896,7 +9893,7 @@ vectorizable_condition (stmt_vec_info st
> return false;
>
> masked = !COMPARISON_CLASS_P (cond_expr);
> - vec_cmp_type = build_same_sized_truth_vector_type (comp_vectype);
> + vec_cmp_type = truth_type_for (comp_vectype);
>
> if (vec_cmp_type == NULL_TREE)
> return false;
> @@ -11156,8 +11153,7 @@ get_mask_type_for_scalar_type (vec_info
> if (!vectype)
> return NULL;
>
> - return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype),
> - vinfo->vector_size);
> + return truth_type_for (vectype);
> }
>
> /* Function get_same_sized_vectype
> @@ -11169,7 +11165,7 @@ get_mask_type_for_scalar_type (vec_info
> get_same_sized_vectype (tree scalar_type, tree vector_type)
> {
> if (VECT_SCALAR_BOOLEAN_TYPE_P (scalar_type))
> - return build_same_sized_truth_vector_type (vector_type);
> + return truth_type_for (vector_type);
>
> return get_vectype_for_scalar_type_and_size
> (scalar_type, GET_MODE_SIZE (TYPE_MODE (vector_type)));
> @@ -12032,7 +12028,7 @@ vect_get_mask_type_for_stmt (stmt_vec_in
> && !VECTOR_BOOLEAN_TYPE_P (mask_type)
> && gimple_code (stmt) == GIMPLE_ASSIGN
> && TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
> - mask_type = build_same_sized_truth_vector_type (mask_type);
> + mask_type = truth_type_for (mask_type);
> }
>
> /* No mask_type should mean loop invariant predicate.
> Index: gcc/config/rs6000/rs6000-call.c
> ===================================================================
> --- gcc/config/rs6000/rs6000-call.c 2019-08-20 09:53:42.126157860 +0100
> +++ gcc/config/rs6000/rs6000-call.c 2019-10-23 12:10:58.104366263 +0100
> @@ -5195,7 +5195,7 @@ rs6000_builtin_valid_without_lhs (enum r
> fold_build_vec_cmp (tree_code code, tree type,
> tree arg0, tree arg1)
> {
> - tree cmp_type = build_same_sized_truth_vector_type (type);
> + tree cmp_type = truth_type_for (type);
> tree zero_vec = build_zero_cst (type);
> tree minus_one_vec = build_minus_one_cst (type);
> tree cmp = fold_build2 (code, cmp_type, arg0, arg1);
> Index: gcc/c/c-typeck.c
> ===================================================================
> --- gcc/c/c-typeck.c 2019-09-30 15:48:43.494491226 +0100
> +++ gcc/c/c-typeck.c 2019-10-23 12:10:58.100366291 +0100
> @@ -5430,7 +5430,7 @@ build_conditional_expr (location_t colon
> tree elem_type = TREE_TYPE (vectype);
> tree zero = build_int_cst (elem_type, 0);
> tree zero_vec = build_vector_from_val (vectype, zero);
> - tree cmp_type = build_same_sized_truth_vector_type (vectype);
> + tree cmp_type = truth_type_for (vectype);
> ifexp = build2 (NE_EXPR, cmp_type, ifexp, zero_vec);
> }
>
> @@ -11336,7 +11336,7 @@ build_vec_cmp (tree_code code, tree type
> {
> tree zero_vec = build_zero_cst (type);
> tree minus_one_vec = build_minus_one_cst (type);
> - tree cmp_type = build_same_sized_truth_vector_type (type);
> + tree cmp_type = truth_type_for (type);
> tree cmp = build2 (code, cmp_type, arg0, arg1);
> return build3 (VEC_COND_EXPR, type, cmp, minus_one_vec, zero_vec);
> }
> Index: gcc/cp/call.c
> ===================================================================
> --- gcc/cp/call.c 2019-10-11 15:43:51.763510065 +0100
> +++ gcc/cp/call.c 2019-10-23 12:10:58.104366263 +0100
> @@ -5175,7 +5175,7 @@ build_conditional_expr_1 (const op_locat
>
> if (!COMPARISON_CLASS_P (arg1))
> {
> - tree cmp_type = build_same_sized_truth_vector_type (arg1_type);
> + tree cmp_type = truth_type_for (arg1_type);
> arg1 = build2 (NE_EXPR, cmp_type, arg1, build_zero_cst (arg1_type));
> }
> return build3_loc (loc, VEC_COND_EXPR, arg2_type, arg1, arg2, arg3);
> Index: gcc/cp/typeck.c
> ===================================================================
> --- gcc/cp/typeck.c 2019-10-22 08:46:57.071358012 +0100
> +++ gcc/cp/typeck.c 2019-10-23 12:10:58.108366235 +0100
> @@ -4338,7 +4338,7 @@ build_vec_cmp (tree_code code, tree type
> {
> tree zero_vec = build_zero_cst (type);
> tree minus_one_vec = build_minus_one_cst (type);
> - tree cmp_type = build_same_sized_truth_vector_type(type);
> + tree cmp_type = truth_type_for (type);
> tree cmp = build2 (code, cmp_type, arg0, arg1);
> return build3 (VEC_COND_EXPR, type, cmp, minus_one_vec, zero_vec);
> }
> Index: gcc/d/d-codegen.cc
> ===================================================================
> --- gcc/d/d-codegen.cc 2019-08-13 10:38:28.931945195 +0100
> +++ gcc/d/d-codegen.cc 2019-10-23 12:10:58.108366235 +0100
> @@ -1399,7 +1399,7 @@ build_boolop (tree_code code, tree arg0,
> /* Build a vector comparison.
> VEC_COND_EXPR <e1 op e2, { -1, -1, -1, -1 }, { 0, 0, 0, 0 }>; */
> tree type = TREE_TYPE (arg0);
> - tree cmptype = build_same_sized_truth_vector_type (type);
> + tree cmptype = truth_type_for (type);
> tree cmp = fold_build2_loc (input_location, code, cmptype, arg0, arg1);
>
> return fold_build3_loc (input_location, VEC_COND_EXPR, type, cmp,