On Wed, Dec 6, 2017 at 4:25 PM, Richard Sandiford
<richard.sandif...@linaro.org> wrote:
> This patch changes gimple_build_vector so that it takes a
> tree_vector_builder instead of a size and a vector of trees.
>
> Tested on aarch64-linux-gnu, x86_64-linux-gnu and powerpc64le-linux-gnu.
> Also spot-checked on sparc64-linux-gnu. OK to install?
Ok.
Richard.
> Thanks,
> Richard
>
>
> 2017-12-06 Richard Sandiford <richard.sandif...@linaro.org>
>
> gcc/
> * vector-builder.h (vector_builder::derived): New const overload.
> (vector_builder::elt): New function.
> * tree-vector-builder.h (tree_vector_builder::type): New function.
> (tree_vector_builder::apply_step): Declare.
> * tree-vector-builder.c (tree_vector_builder::apply_step): New
> function.
> * gimple-fold.h (tree_vector_builder): Declare.
> (gimple_build_vector): Take a tree_vector_builder instead of a
> type and vector of elements.
> * gimple-fold.c (gimple_build_vector): Likewise.
> * tree-vect-loop.c (get_initial_def_for_reduction): Update call
> accordingly.
> (get_initial_defs_for_reduction): Likewise.
> (vectorizable_induction): Likewise.
>
> Index: gcc/vector-builder.h
> ===================================================================
> --- gcc/vector-builder.h 2017-12-06 14:46:14.133599820 +0000
> +++ gcc/vector-builder.h 2017-12-06 14:49:04.289693414 +0000
> @@ -68,6 +68,10 @@ #define GCC_VECTOR_BUILDER_H
> given integral_p (ELT1) && integral_p (ELT2). There is no fixed
> choice of StepType.
>
> + T apply_step (T base, unsigned int factor, StepType step) const;
> +
> + Return a vector element with the value BASE + FACTOR * STEP.
> +
> bool can_elide_p (T elt) const;
>
> Return true if we can drop element ELT, even if the retained
> @@ -91,6 +95,7 @@ #define GCC_VECTOR_BUILDER_H
> unsigned int nelts_per_pattern () const { return m_nelts_per_pattern; }
> unsigned int encoded_nelts () const;
> bool encoded_full_vector_p () const;
> + T elt (unsigned int) const;
>
> void finalize ();
>
> @@ -163,6 +168,38 @@ vector_builder<T, Derived>::new_vector (
> this->truncate (0);
> }
>
> +/* Return the value of vector element I, which might or might not be
> + encoded explicitly. */
> +
> +template<typename T, typename Derived>
> +T
> +vector_builder<T, Derived>::elt (unsigned int i) const
> +{
> + /* This only makes sense if the encoding has been fully populated. */
> + gcc_checking_assert (encoded_nelts () <= this->length ());
> +
> + /* First handle elements that are already present in the underlying
> + vector, regardless of whether they're part of the encoding or not. */
> + if (i < this->length ())
> + return (*this)[i];
> +
> + /* Identify the pattern that contains element I and work out the index of
> + the last encoded element for that pattern. */
> + unsigned int pattern = i % m_npatterns;
> + unsigned int count = i / m_npatterns;
> + unsigned int final_i = encoded_nelts () - m_npatterns + pattern;
> + T final = (*this)[final_i];
> +
> + /* If there are no steps, the final encoded value is the right one. */
> + if (m_nelts_per_pattern <= 2)
> + return final;
> +
> + /* Otherwise work out the value from the last two encoded elements. */
> + T prev = (*this)[final_i - m_npatterns];
> + return derived ()->apply_step (final, count - 2,
> + derived ()->step (prev, final));
> +}
> +
> /* Change the encoding to NPATTERNS patterns of NELTS_PER_PATTERN each,
> but without changing the underlying vector. */
>
> Index: gcc/tree-vector-builder.h
> ===================================================================
> --- gcc/tree-vector-builder.h 2017-12-06 14:49:00.386854068 +0000
> +++ gcc/tree-vector-builder.h 2017-12-06 14:49:04.289693414 +0000
> @@ -45,6 +45,7 @@ #define GCC_TREE_VECTOR_BUILDER_H
> bool allow_steps_p () const;
> bool integral_p (const_tree) const;
> wide_int step (const_tree, const_tree) const;
> + tree apply_step (tree, unsigned int, const wide_int &) const;
> bool can_elide_p (const_tree) const;
> void note_representative (tree *, tree);
>
> Index: gcc/tree-vector-builder.c
> ===================================================================
> --- gcc/tree-vector-builder.c 2017-12-06 14:49:00.386854068 +0000
> +++ gcc/tree-vector-builder.c 2017-12-06 14:49:04.289693414 +0000
> @@ -96,6 +96,16 @@ tree_vector_builder::new_binary_operatio
> return true;
> }
>
> +/* Return a vector element with the value BASE + FACTOR * STEP. */
> +
> +tree
> +tree_vector_builder::apply_step (tree base, unsigned int factor,
> + const wide_int &step) const
> +{
> + return wide_int_to_tree (TREE_TYPE (base),
> + wi::to_wide (base) + factor * step);
> +}
> +
> /* Return a VECTOR_CST for the current constant. */
>
> tree
> Index: gcc/gimple-fold.h
> ===================================================================
> --- gcc/gimple-fold.h 2017-11-29 11:06:33.003002371 +0000
> +++ gcc/gimple-fold.h 2017-12-06 14:49:04.288693455 +0000
> @@ -135,11 +135,13 @@ gimple_build_vector_from_val (gimple_seq
> return gimple_build_vector_from_val (seq, UNKNOWN_LOCATION, type, op);
> }
>
> -extern tree gimple_build_vector (gimple_seq *, location_t, tree, vec<tree>);
> +class tree_vector_builder;
> +extern tree gimple_build_vector (gimple_seq *, location_t,
> + tree_vector_builder *);
> inline tree
> -gimple_build_vector (gimple_seq *seq, tree type, vec<tree> elts)
> +gimple_build_vector (gimple_seq *seq, tree_vector_builder *builder)
> {
> - return gimple_build_vector (seq, UNKNOWN_LOCATION, type, elts);
> + return gimple_build_vector (seq, UNKNOWN_LOCATION, builder);
> }
>
> extern bool gimple_stmt_nonnegative_warnv_p (gimple *, bool *, int = 0);
> Index: gcc/gimple-fold.c
> ===================================================================
> --- gcc/gimple-fold.c 2017-12-06 14:48:52.888162175 +0000
> +++ gcc/gimple-fold.c 2017-12-06 14:49:04.288693455 +0000
> @@ -7178,23 +7178,30 @@ gimple_build_vector_from_val (gimple_seq
> return res;
> }
>
> -/* Build a vector of type TYPE in which the elements have the values
> - given by ELTS. Return a gimple value for the result, appending any
> - new instructions to SEQ. */
> +/* Build a vector from BUILDER, handling the case in which some elements
> + are non-constant. Return a gimple value for the result, appending any
> + new instructions to SEQ.
> +
> + BUILDER must not have a stepped encoding on entry. This is because
> + the function is not geared up to handle the arithmetic that would
> + be needed in the variable case, and any code building a vector that
> + is known to be constant should use BUILDER->build () directly. */
>
> tree
> -gimple_build_vector (gimple_seq *seq, location_t loc, tree type,
> - vec<tree> elts)
> +gimple_build_vector (gimple_seq *seq, location_t loc,
> + tree_vector_builder *builder)
> {
> - unsigned int nelts = elts.length ();
> - gcc_assert (nelts == TYPE_VECTOR_SUBPARTS (type));
> - for (unsigned int i = 0; i < nelts; ++i)
> - if (!TREE_CONSTANT (elts[i]))
> + gcc_assert (builder->nelts_per_pattern () <= 2);
> + unsigned int encoded_nelts = builder->encoded_nelts ();
> + for (unsigned int i = 0; i < encoded_nelts; ++i)
> + if (!TREE_CONSTANT ((*builder)[i]))
> {
> + tree type = builder->type ();
> + unsigned int nelts = TYPE_VECTOR_SUBPARTS (type);
> vec<constructor_elt, va_gc> *v;
> vec_alloc (v, nelts);
> for (i = 0; i < nelts; ++i)
> - CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[i]);
> + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, builder->elt (i));
>
> tree res;
> if (gimple_in_ssa_p (cfun))
> @@ -7206,7 +7213,7 @@ gimple_build_vector (gimple_seq *seq, lo
> gimple_seq_add_stmt_without_update (seq, stmt);
> return res;
> }
> - return build_vector (type, elts);
> + return builder->build ();
> }
>
> /* Return true if the result of assignment STMT is known to be non-negative.
> Index: gcc/tree-vect-loop.c
> ===================================================================
> --- gcc/tree-vect-loop.c 2017-12-06 14:48:52.889162134 +0000
> +++ gcc/tree-vect-loop.c 2017-12-06 14:49:04.289693414 +0000
> @@ -3968,11 +3968,9 @@ get_initial_def_for_reduction (gimple *s
> struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
> tree scalar_type = TREE_TYPE (init_val);
> tree vectype = get_vectype_for_scalar_type (scalar_type);
> - int nunits;
> enum tree_code code = gimple_assign_rhs_code (stmt);
> tree def_for_init;
> tree init_def;
> - int i;
> bool nested_in_vect_loop = false;
> REAL_VALUE_TYPE real_init_val = dconst0;
> int int_init_val = 0;
> @@ -3980,7 +3978,6 @@ get_initial_def_for_reduction (gimple *s
> gimple_seq stmts = NULL;
>
> gcc_assert (vectype);
> - nunits = TYPE_VECTOR_SUBPARTS (vectype);
>
> gcc_assert (POINTER_TYPE_P (scalar_type) || INTEGRAL_TYPE_P (scalar_type)
> || SCALAR_FLOAT_TYPE_P (scalar_type));
> @@ -4053,11 +4050,10 @@ get_initial_def_for_reduction (gimple *s
> else
> {
> /* Option2: the first element is INIT_VAL. */
> - auto_vec<tree, 32> elts (nunits);
> + tree_vector_builder elts (vectype, 1, 2);
> elts.quick_push (init_val);
> - for (i = 1; i < nunits; ++i)
> - elts.quick_push (def_for_init);
> - init_def = gimple_build_vector (&stmts, vectype, elts);
> + elts.quick_push (def_for_init);
> + init_def = gimple_build_vector (&stmts, &elts);
> }
> }
> break;
> @@ -4182,7 +4178,7 @@ get_initial_defs_for_reduction (slp_tree
> number_of_copies = nunits * number_of_vectors / group_size;
>
> number_of_places_left_in_vector = nunits;
> - auto_vec<tree, 32> elts (nunits);
> + tree_vector_builder elts (vector_type, nunits, 1);
> elts.quick_grow (nunits);
> for (j = 0; j < number_of_copies; j++)
> {
> @@ -4205,12 +4201,14 @@ get_initial_defs_for_reduction (slp_tree
> if (number_of_places_left_in_vector == 0)
> {
> gimple_seq ctor_seq = NULL;
> - tree init = gimple_build_vector (&ctor_seq, vector_type, elts);
> + tree init = gimple_build_vector (&ctor_seq, &elts);
> if (ctor_seq != NULL)
> gsi_insert_seq_on_edge_immediate (pe, ctor_seq);
> voprnds.quick_push (init);
>
> number_of_places_left_in_vector = nunits;
> + elts.new_vector (vector_type, nunits, 1);
> + elts.quick_grow (nunits);
> }
> }
> }
> @@ -6698,7 +6696,7 @@ vectorizable_induction (gimple *phi,
> unsigned ivn;
> for (ivn = 0; ivn < nivs; ++ivn)
> {
> - auto_vec<tree, 32> elts (nunits);
> + tree_vector_builder elts (vectype, nunits, 1);
> stmts = NULL;
> for (unsigned eltn = 0; eltn < nunits; ++eltn)
> {
> @@ -6708,7 +6706,7 @@ vectorizable_induction (gimple *phi,
> elt, step_expr);
> elts.quick_push (elt);
> }
> - vec_init = gimple_build_vector (&stmts, vectype, elts);
> + vec_init = gimple_build_vector (&stmts, &elts);
> if (stmts)
> {
> new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
> @@ -6815,7 +6813,7 @@ vectorizable_induction (gimple *phi,
> stmts = NULL;
> new_name = gimple_convert (&stmts, TREE_TYPE (vectype), init_expr);
>
> - auto_vec<tree, 32> elts (nunits);
> + tree_vector_builder elts (vectype, nunits, 1);
> elts.quick_push (new_name);
> for (i = 1; i < nunits; i++)
> {
> @@ -6826,7 +6824,7 @@ vectorizable_induction (gimple *phi,
> }
> /* Create a vector from [new_name_0, new_name_1, ...,
> new_name_nunits-1] */
> - vec_init = gimple_build_vector (&stmts, vectype, elts);
> + vec_init = gimple_build_vector (&stmts, &elts);
> if (stmts)
> {
> new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
