This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Use vec<> in build_vector
- From: Richard Sandiford <richard dot sandiford at linaro dot org>
- To: gcc-patches at gcc dot gnu dot org
- Date: Thu, 14 Sep 2017 12:14:26 +0100
- Subject: Use vec<> in build_vector
- Authentication-results: sourceware.org; auth=none
This patch makes build_vector take the elements as a vec<> rather
than a tree *. This is useful for SVE because it bundles the number
of elements with the elements themselves, and enforces the fact that
the number is constant. Also, I think things like the folds can be used
with any generic GNU vector, not just those that match machine vectors,
so the arguments to XALLOCAVEC had no clear limit.
Tested on aarch64-linux-gnu, x86_64-linux-gnu and powerpc64le-linux-gnu.
OK to install?
Richard
2017-09-14 Richard Sandiford <richard.sandiford@linaro.org>
Alan Hayward <alan.hayward@arm.com>
David Sherwood <david.sherwood@arm.com>
gcc/
* tree.h (build_vector): Take a vec<tree> instead of a tree *.
* tree.c (build_vector): Likewise.
(build_vector_from_ctor): Update accordingly.
(build_vector_from_val): Likewise.
* gimple-fold.c (gimple_fold_stmt_to_constant_1): Likewise.
* tree-ssa-forwprop.c (simplify_vector_constructor): Likewise.
* tree-vect-generic.c (add_rshift): Likewise.
(expand_vector_divmod): Likewise.
(optimize_vector_constructor): Likewise.
* tree-vect-slp.c (vect_get_constant_vectors): Likewise.
(vect_transform_slp_perm_load): Likewise.
(vect_schedule_slp_instance): Likewise.
* tree-vect-stmts.c (vectorizable_bswap): Likewise.
(vectorizable_call): Likewise.
(vect_gen_perm_mask_any): Likewise. Add elements in order.
* expmed.c (make_tree): Likewise.
* fold-const.c (fold_negate_expr_1): Use auto_vec<tree> when building
a vector passed to build_vector.
(fold_convert_const): Likewise.
(exact_inverse): Likewise.
(fold_ternary_loc): Likewise.
(fold_relational_const): Likewise.
(const_binop): Likewise. Use VECTOR_CST_ELT directly when operating
on VECTOR_CSTs, rather than going through vec_cst_ctor_to_array.
(const_unop): Likewise. Store the reduction accumulator in a
variable rather than an array.
(vec_cst_ctor_to_array): Take the number of elements as a parameter.
(fold_vec_perm): Update calls accordingly. Use auto_vec<tree> for
the new vector, rather than constructing it after the input arrays.
(native_interpret_vector): Use auto_vec<tree> when building
a vector passed to build_vector. Add elements in order.
* tree-vect-loop.c (get_initial_defs_for_reduction): Use
auto_vec<tree> when building a vector passed to build_vector.
(vect_create_epilog_for_reduction): Likewise.
(vectorizable_induction): Likewise.
(get_initial_def_for_reduction): Likewise. Fix indentation of
case statements.
* config/sparc/sparc.c (sparc_handle_vis_mul8x16): Change n_elts
to a vec<tree> *.
(sparc_fold_builtin): Use auto_vec<tree> when building a vector
passed to build_vector.
Index: gcc/tree.h
===================================================================
--- gcc/tree.h 2017-09-14 11:23:57.004947653 +0100
+++ gcc/tree.h 2017-09-14 11:24:42.669777533 +0100
@@ -4026,7 +4026,7 @@ extern tree build_int_cst (tree, HOST_WI
extern tree build_int_cstu (tree type, unsigned HOST_WIDE_INT cst);
extern tree build_int_cst_type (tree, HOST_WIDE_INT);
extern tree make_vector (unsigned CXX_MEM_STAT_INFO);
-extern tree build_vector (tree, tree * CXX_MEM_STAT_INFO);
+extern tree build_vector (tree, vec<tree> CXX_MEM_STAT_INFO);
extern tree build_vector_from_ctor (tree, vec<constructor_elt, va_gc> *);
extern tree build_vector_from_val (tree, tree);
extern void recompute_constructor_flags (tree);
Index: gcc/tree.c
===================================================================
--- gcc/tree.c 2017-09-14 11:23:57.004947653 +0100
+++ gcc/tree.c 2017-09-14 11:24:42.669777533 +0100
@@ -1702,18 +1702,20 @@ make_vector (unsigned len MEM_STAT_DECL)
}
/* Return a new VECTOR_CST node whose type is TYPE and whose values
- are in a list pointed to by VALS. */
+ are given by VALS. */
tree
-build_vector (tree type, tree *vals MEM_STAT_DECL)
+build_vector (tree type, vec<tree> vals MEM_STAT_DECL)
{
+ unsigned int nelts = vals.length ();
+ gcc_assert (nelts == TYPE_VECTOR_SUBPARTS (type));
int over = 0;
unsigned cnt = 0;
- tree v = make_vector (TYPE_VECTOR_SUBPARTS (type));
+ tree v = make_vector (nelts);
TREE_TYPE (v) = type;
/* Iterate through elements and check for overflow. */
- for (cnt = 0; cnt < TYPE_VECTOR_SUBPARTS (type); ++cnt)
+ for (cnt = 0; cnt < nelts; ++cnt)
{
tree value = vals[cnt];
@@ -1736,20 +1738,21 @@ build_vector (tree type, tree *vals MEM_
tree
build_vector_from_ctor (tree type, vec<constructor_elt, va_gc> *v)
{
- tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
- unsigned HOST_WIDE_INT idx, pos = 0;
+ unsigned int nelts = TYPE_VECTOR_SUBPARTS (type);
+ unsigned HOST_WIDE_INT idx;
tree value;
+ auto_vec<tree, 32> vec (nelts);
FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
{
if (TREE_CODE (value) == VECTOR_CST)
for (unsigned i = 0; i < VECTOR_CST_NELTS (value); ++i)
- vec[pos++] = VECTOR_CST_ELT (value, i);
+ vec.quick_push (VECTOR_CST_ELT (value, i));
else
- vec[pos++] = value;
+ vec.quick_push (value);
}
- while (pos < TYPE_VECTOR_SUBPARTS (type))
- vec[pos++] = build_zero_cst (TREE_TYPE (type));
+ while (vec.length () < nelts)
+ vec.quick_push (build_zero_cst (TREE_TYPE (type)));
return build_vector (type, vec);
}
@@ -1774,9 +1777,9 @@ build_vector_from_val (tree vectype, tre
if (CONSTANT_CLASS_P (sc))
{
- tree *v = XALLOCAVEC (tree, nunits);
+ auto_vec<tree, 32> v (nunits);
for (i = 0; i < nunits; ++i)
- v[i] = sc;
+ v.quick_push (sc);
return build_vector (vectype, v);
}
else
Index: gcc/gimple-fold.c
===================================================================
--- gcc/gimple-fold.c 2017-09-13 18:03:47.077908038 +0100
+++ gcc/gimple-fold.c 2017-09-14 11:24:42.666088258 +0100
@@ -5919,18 +5919,18 @@ gimple_fold_stmt_to_constant_1 (gimple *
&& (CONSTRUCTOR_NELTS (rhs)
== TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs))))
{
- unsigned i;
- tree val, *vec;
+ unsigned i, nelts;
+ tree val;
- vec = XALLOCAVEC (tree,
- TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs)));
+ nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs));
+ auto_vec<tree, 32> vec (nelts);
FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val)
{
val = (*valueize) (val);
if (TREE_CODE (val) == INTEGER_CST
|| TREE_CODE (val) == REAL_CST
|| TREE_CODE (val) == FIXED_CST)
- vec[i] = val;
+ vec.quick_push (val);
else
return NULL_TREE;
}
Index: gcc/tree-ssa-forwprop.c
===================================================================
--- gcc/tree-ssa-forwprop.c 2017-08-21 15:50:48.662709938 +0100
+++ gcc/tree-ssa-forwprop.c 2017-09-14 11:24:42.667010577 +0100
@@ -2051,7 +2051,7 @@ simplify_vector_constructor (gimple_stmt
}
else
{
- tree mask_type, *mask_elts;
+ tree mask_type;
if (!can_vec_perm_p (TYPE_MODE (type), false, sel))
return false;
@@ -2062,9 +2062,9 @@ simplify_vector_constructor (gimple_stmt
|| GET_MODE_SIZE (TYPE_MODE (mask_type))
!= GET_MODE_SIZE (TYPE_MODE (type)))
return false;
- mask_elts = XALLOCAVEC (tree, nelts);
+ auto_vec<tree, 32> mask_elts (nelts);
for (i = 0; i < nelts; i++)
- mask_elts[i] = build_int_cst (TREE_TYPE (mask_type), sel[i]);
+ mask_elts.quick_push (build_int_cst (TREE_TYPE (mask_type), sel[i]));
op2 = build_vector (mask_type, mask_elts);
if (conv_code == ERROR_MARK)
gimple_assign_set_rhs_with_ops (gsi, VEC_PERM_EXPR, orig, orig, op2);
Index: gcc/tree-vect-generic.c
===================================================================
--- gcc/tree-vect-generic.c 2017-09-12 14:24:48.541917623 +0100
+++ gcc/tree-vect-generic.c 2017-09-14 11:24:42.667010577 +0100
@@ -398,9 +398,9 @@ add_rshift (gimple_stmt_iterator *gsi, t
if (op != unknown_optab
&& optab_handler (op, TYPE_MODE (type)) != CODE_FOR_nothing)
{
- tree *vec = XALLOCAVEC (tree, nunits);
+ auto_vec<tree, 32> vec (nunits);
for (i = 0; i < nunits; i++)
- vec[i] = build_int_cst (TREE_TYPE (type), shiftcnts[i]);
+ vec.quick_push (build_int_cst (TREE_TYPE (type), shiftcnts[i]));
return gimplify_build2 (gsi, RSHIFT_EXPR, type, op0,
build_vector (type, vec));
}
@@ -429,7 +429,6 @@ expand_vector_divmod (gimple_stmt_iterat
unsigned int i;
signop sign_p = TYPE_SIGN (TREE_TYPE (type));
unsigned HOST_WIDE_INT mask = GET_MODE_MASK (TYPE_MODE (TREE_TYPE (type)));
- tree *vec;
tree cur_op, mulcst, tem;
optab op;
@@ -593,8 +592,6 @@ expand_vector_divmod (gimple_stmt_iterat
mode = -2;
}
- vec = XALLOCAVEC (tree, nunits);
-
if (use_pow2)
{
tree addend = NULL_TREE;
@@ -638,10 +635,11 @@ expand_vector_divmod (gimple_stmt_iterat
mask_type = build_same_sized_truth_vector_type (type);
zero = build_zero_cst (type);
cond = build2 (LT_EXPR, mask_type, op0, zero);
+ auto_vec<tree, 32> vec (nunits);
for (i = 0; i < nunits; i++)
- vec[i] = build_int_cst (TREE_TYPE (type),
- (HOST_WIDE_INT_1U
- << shifts[i]) - 1);
+ vec.quick_push (build_int_cst (TREE_TYPE (type),
+ (HOST_WIDE_INT_1U
+ << shifts[i]) - 1));
cst = build_vector (type, vec);
addend = make_ssa_name (type);
stmt = gimple_build_assign (addend, VEC_COND_EXPR, cond,
@@ -676,10 +674,11 @@ expand_vector_divmod (gimple_stmt_iterat
else
{
tree mask;
+ auto_vec<tree, 32> vec (nunits);
for (i = 0; i < nunits; i++)
- vec[i] = build_int_cst (TREE_TYPE (type),
- (HOST_WIDE_INT_1U
- << shifts[i]) - 1);
+ vec.quick_push (build_int_cst (TREE_TYPE (type),
+ (HOST_WIDE_INT_1U
+ << shifts[i]) - 1));
mask = build_vector (type, vec);
op = optab_for_tree_code (BIT_AND_EXPR, type, optab_default);
if (op != unknown_optab
@@ -754,8 +753,9 @@ expand_vector_divmod (gimple_stmt_iterat
return NULL_TREE;
}
+ auto_vec<tree, 32> vec (nunits);
for (i = 0; i < nunits; i++)
- vec[i] = build_int_cst (TREE_TYPE (type), mulc[i]);
+ vec.quick_push (build_int_cst (TREE_TYPE (type), mulc[i]));
mulcst = build_vector (type, vec);
cur_op = gimplify_build2 (gsi, MULT_HIGHPART_EXPR, type, cur_op, mulcst);
@@ -1066,7 +1066,6 @@ optimize_vector_constructor (gimple_stmt
unsigned int i, j, nelts = TYPE_VECTOR_SUBPARTS (type);
bool all_same = true;
constructor_elt *elt;
- tree *cst;
gimple *g;
tree base = NULL_TREE;
optab op;
@@ -1105,22 +1104,23 @@ optimize_vector_constructor (gimple_stmt
}
if (all_same)
return;
- cst = XALLOCAVEC (tree, nelts);
+ auto_vec<tree, 32> cst (nelts);
for (i = 0; i < nelts; i++)
{
- tree this_base = CONSTRUCTOR_ELT (rhs, i)->value;;
- cst[i] = build_zero_cst (TREE_TYPE (base));
+ tree this_base = CONSTRUCTOR_ELT (rhs, i)->value;
+ tree elt = build_zero_cst (TREE_TYPE (base));
while (this_base != base)
{
g = SSA_NAME_DEF_STMT (this_base);
- cst[i] = fold_binary (PLUS_EXPR, TREE_TYPE (base),
- cst[i], gimple_assign_rhs2 (g));
- if (cst[i] == NULL_TREE
- || TREE_CODE (cst[i]) != INTEGER_CST
- || TREE_OVERFLOW (cst[i]))
+ elt = fold_binary (PLUS_EXPR, TREE_TYPE (base),
+ elt, gimple_assign_rhs2 (g));
+ if (elt == NULL_TREE
+ || TREE_CODE (elt) != INTEGER_CST
+ || TREE_OVERFLOW (elt))
return;
this_base = gimple_assign_rhs1 (g);
}
+ cst.quick_push (elt);
}
for (i = 0; i < nelts; i++)
CONSTRUCTOR_ELT (rhs, i)->value = base;
Index: gcc/tree-vect-slp.c
===================================================================
--- gcc/tree-vect-slp.c 2017-08-30 12:19:19.719220029 +0100
+++ gcc/tree-vect-slp.c 2017-09-14 11:24:42.667932896 +0100
@@ -3105,7 +3105,6 @@ vect_get_constant_vectors (tree op, slp_
stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
unsigned nunits;
tree vec_cst;
- tree *elts;
unsigned j, number_of_places_left_in_vector;
tree vector_type;
tree vop;
@@ -3158,7 +3157,8 @@ vect_get_constant_vectors (tree op, slp_
number_of_places_left_in_vector = nunits;
constant_p = true;
- elts = XALLOCAVEC (tree, nunits);
+ auto_vec<tree, 32> elts (nunits);
+ elts.quick_grow (nunits);
bool place_after_defs = false;
for (j = 0; j < number_of_copies; j++)
{
@@ -3600,10 +3600,10 @@ vect_transform_slp_perm_load (slp_tree n
if (! noop_p)
{
- tree *mask_elts = XALLOCAVEC (tree, nunits);
+ auto_vec<tree, 32> mask_elts (nunits);
for (int l = 0; l < nunits; ++l)
- mask_elts[l] = build_int_cst (mask_element_type,
- mask[l]);
+ mask_elts.quick_push (build_int_cst (mask_element_type,
+ mask[l]));
mask_vec = build_vector (mask_type, mask_elts);
}
@@ -3759,13 +3759,14 @@ vect_schedule_slp_instance (slp_tree nod
unsigned k = 0, l;
for (j = 0; j < v0.length (); ++j)
{
- tree *melts = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (vectype));
- for (l = 0; l < TYPE_VECTOR_SUBPARTS (vectype); ++l)
+ unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
+ auto_vec<tree, 32> melts (nunits);
+ for (l = 0; l < nunits; ++l)
{
if (k >= group_size)
k = 0;
- melts[l] = build_int_cst
- (meltype, mask[k++] * TYPE_VECTOR_SUBPARTS (vectype) + l);
+ tree t = build_int_cst (meltype, mask[k++] * nunits + l);
+ melts.quick_push (t);
}
tmask = build_vector (mvectype, melts);
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c 2017-09-06 20:47:36.983150825 +0100
+++ gcc/tree-vect-stmts.c 2017-09-14 11:24:42.668855214 +0100
@@ -2480,10 +2480,10 @@ vectorizable_bswap (gimple *stmt, gimple
if (! char_vectype)
return false;
- unsigned char *elts
- = XALLOCAVEC (unsigned char, TYPE_VECTOR_SUBPARTS (char_vectype));
+ unsigned int num_bytes = TYPE_VECTOR_SUBPARTS (char_vectype);
+ unsigned char *elts = XALLOCAVEC (unsigned char, num_bytes);
unsigned char *elt = elts;
- unsigned word_bytes = TYPE_VECTOR_SUBPARTS (char_vectype) / nunits;
+ unsigned word_bytes = num_bytes / nunits;
for (unsigned i = 0; i < nunits; ++i)
for (unsigned j = 0; j < word_bytes; ++j)
*elt++ = (i + 1) * word_bytes - j - 1;
@@ -2507,9 +2507,9 @@ vectorizable_bswap (gimple *stmt, gimple
return true;
}
- tree *telts = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (char_vectype));
- for (unsigned i = 0; i < TYPE_VECTOR_SUBPARTS (char_vectype); ++i)
- telts[i] = build_int_cst (char_type_node, elts[i]);
+ auto_vec<tree, 32> telts (num_bytes);
+ for (unsigned i = 0; i < num_bytes; ++i)
+ telts.quick_push (build_int_cst (char_type_node, elts[i]));
tree bswap_vconst = build_vector (char_vectype, telts);
/* Transform. */
@@ -2928,10 +2928,10 @@ vectorizable_call (gimple *gs, gimple_st
if (gimple_call_internal_p (stmt)
&& gimple_call_internal_fn (stmt) == IFN_GOMP_SIMD_LANE)
{
- tree *v = XALLOCAVEC (tree, nunits_out);
- int k;
- for (k = 0; k < nunits_out; ++k)
- v[k] = build_int_cst (unsigned_type_node, j * nunits_out + k);
+ auto_vec<tree, 32> v (nunits_out);
+ for (int k = 0; k < nunits_out; ++k)
+ v.quick_push (build_int_cst (unsigned_type_node,
+ j * nunits_out + k));
tree cst = build_vector (vectype_out, v);
tree new_var
= vect_get_new_ssa_name (vectype_out, vect_simple_var, "cst_");
@@ -6505,7 +6505,7 @@ vectorizable_store (gimple *stmt, gimple
tree
vect_gen_perm_mask_any (tree vectype, const unsigned char *sel)
{
- tree mask_elt_type, mask_type, mask_vec, *mask_elts;
+ tree mask_elt_type, mask_type, mask_vec;
int i, nunits;
nunits = TYPE_VECTOR_SUBPARTS (vectype);
@@ -6514,9 +6514,9 @@ vect_gen_perm_mask_any (tree vectype, co
(int_mode_for_mode (TYPE_MODE (TREE_TYPE (vectype))).require (), 1);
mask_type = get_vectype_for_scalar_type (mask_elt_type);
- mask_elts = XALLOCAVEC (tree, nunits);
- for (i = nunits - 1; i >= 0; i--)
- mask_elts[i] = build_int_cst (mask_elt_type, sel[i]);
+ auto_vec<tree, 32> mask_elts (nunits);
+ for (i = 0; i < nunits; ++i)
+ mask_elts.quick_push (build_int_cst (mask_elt_type, sel[i]));
mask_vec = build_vector (mask_type, mask_elts);
return mask_vec;
Index: gcc/expmed.c
===================================================================
--- gcc/expmed.c 2017-09-14 11:23:44.291407202 +0100
+++ gcc/expmed.c 2017-09-14 11:24:42.664243620 +0100
@@ -5180,15 +5180,14 @@ make_tree (tree type, rtx x)
{
int units = CONST_VECTOR_NUNITS (x);
tree itype = TREE_TYPE (type);
- tree *elts;
int i;
/* Build a tree with vector elements. */
- elts = XALLOCAVEC (tree, units);
- for (i = units - 1; i >= 0; --i)
+ auto_vec<tree, 32> elts (units);
+ for (i = 0; i < units; ++i)
{
rtx elt = CONST_VECTOR_ELT (x, i);
- elts[i] = make_tree (itype, elt);
+ elts.quick_push (make_tree (itype, elt));
}
return build_vector (type, elts);
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c 2017-09-14 11:23:57.004041291 +0100
+++ gcc/fold-const.c 2017-09-14 11:24:42.666088258 +0100
@@ -136,7 +136,6 @@ static tree fold_not_const (const_tree,
static tree fold_relational_const (enum tree_code, tree, tree, tree);
static tree fold_convert_const (enum tree_code, tree, tree);
static tree fold_view_convert_expr (tree, tree);
-static bool vec_cst_ctor_to_array (tree, tree *);
static tree fold_negate_expr (location_t, tree);
@@ -565,13 +564,14 @@ fold_negate_expr_1 (location_t loc, tree
case VECTOR_CST:
{
int count = VECTOR_CST_NELTS (t), i;
- tree *elts = XALLOCAVEC (tree, count);
+ auto_vec<tree, 32> elts (count);
for (i = 0; i < count; i++)
{
- elts[i] = fold_negate_expr (loc, VECTOR_CST_ELT (t, i));
- if (elts[i] == NULL_TREE)
+ tree elt = fold_negate_expr (loc, VECTOR_CST_ELT (t, i));
+ if (elt == NULL_TREE)
return NULL_TREE;
+ elts.quick_push (elt);
}
return build_vector (type, elts);
@@ -1414,19 +1414,20 @@ const_binop (enum tree_code code, tree a
{
tree type = TREE_TYPE (arg1);
int count = VECTOR_CST_NELTS (arg1), i;
- tree *elts = XALLOCAVEC (tree, count);
+ auto_vec<tree, 32> elts (count);
for (i = 0; i < count; i++)
{
tree elem1 = VECTOR_CST_ELT (arg1, i);
tree elem2 = VECTOR_CST_ELT (arg2, i);
- elts[i] = const_binop (code, elem1, elem2);
+ tree elt = const_binop (code, elem1, elem2);
/* It is possible that const_binop cannot handle the given
code and return NULL_TREE */
- if (elts[i] == NULL_TREE)
+ if (elt == NULL_TREE)
return NULL_TREE;
+ elts.quick_push (elt);
}
return build_vector (type, elts);
@@ -1438,18 +1439,19 @@ const_binop (enum tree_code code, tree a
{
tree type = TREE_TYPE (arg1);
int count = VECTOR_CST_NELTS (arg1), i;
- tree *elts = XALLOCAVEC (tree, count);
+ auto_vec<tree, 32> elts (count);
for (i = 0; i < count; i++)
{
tree elem1 = VECTOR_CST_ELT (arg1, i);
- elts[i] = const_binop (code, elem1, arg2);
+ tree elt = const_binop (code, elem1, arg2);
/* It is possible that const_binop cannot handle the given
code and return NULL_TREE. */
- if (elts[i] == NULL_TREE)
+ if (elt == NULL_TREE)
return NULL_TREE;
+ elts.quick_push (elt);
}
return build_vector (type, elts);
@@ -1481,7 +1483,6 @@ const_binop (enum tree_code code, tree t
case VEC_PACK_TRUNC_EXPR:
case VEC_PACK_FIX_TRUNC_EXPR:
{
- tree *elts;
unsigned int out_nelts, in_nelts, i;
if (TREE_CODE (arg1) != VECTOR_CST
@@ -1493,18 +1494,18 @@ const_binop (enum tree_code code, tree t
gcc_assert (in_nelts == VECTOR_CST_NELTS (arg2)
&& out_nelts == TYPE_VECTOR_SUBPARTS (type));
- elts = XALLOCAVEC (tree, out_nelts);
- if (!vec_cst_ctor_to_array (arg1, elts)
- || !vec_cst_ctor_to_array (arg2, elts + in_nelts))
- return NULL_TREE;
-
+ auto_vec<tree, 32> elts (out_nelts);
for (i = 0; i < out_nelts; i++)
{
- elts[i] = fold_convert_const (code == VEC_PACK_TRUNC_EXPR
- ? NOP_EXPR : FIX_TRUNC_EXPR,
- TREE_TYPE (type), elts[i]);
- if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
+ tree elt = (i < in_nelts
+ ? VECTOR_CST_ELT (arg1, i)
+ : VECTOR_CST_ELT (arg2, i - in_nelts));
+ elt = fold_convert_const (code == VEC_PACK_TRUNC_EXPR
+ ? NOP_EXPR : FIX_TRUNC_EXPR,
+ TREE_TYPE (type), elt);
+ if (elt == NULL_TREE || !CONSTANT_CLASS_P (elt))
return NULL_TREE;
+ elts.quick_push (elt);
}
return build_vector (type, elts);
@@ -1516,7 +1517,6 @@ const_binop (enum tree_code code, tree t
case VEC_WIDEN_MULT_ODD_EXPR:
{
unsigned int out_nelts, in_nelts, out, ofs, scale;
- tree *elts;
if (TREE_CODE (arg1) != VECTOR_CST || TREE_CODE (arg2) != VECTOR_CST)
return NULL_TREE;
@@ -1526,11 +1526,6 @@ const_binop (enum tree_code code, tree t
gcc_assert (in_nelts == VECTOR_CST_NELTS (arg2)
&& out_nelts == TYPE_VECTOR_SUBPARTS (type));
- elts = XALLOCAVEC (tree, in_nelts * 2);
- if (!vec_cst_ctor_to_array (arg1, elts)
- || !vec_cst_ctor_to_array (arg2, elts + in_nelts))
- return NULL_TREE;
-
if (code == VEC_WIDEN_MULT_LO_EXPR)
scale = 0, ofs = BYTES_BIG_ENDIAN ? out_nelts : 0;
else if (code == VEC_WIDEN_MULT_HI_EXPR)
@@ -1540,20 +1535,21 @@ const_binop (enum tree_code code, tree t
else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
scale = 1, ofs = 1;
+ auto_vec<tree, 32> elts (out_nelts);
for (out = 0; out < out_nelts; out++)
{
- unsigned int in1 = (out << scale) + ofs;
- unsigned int in2 = in1 + in_nelts;
- tree t1, t2;
-
- t1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in1]);
- t2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in2]);
+ unsigned int in = (out << scale) + ofs;
+ tree t1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type),
+ VECTOR_CST_ELT (arg1, in));
+ tree t2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type),
+ VECTOR_CST_ELT (arg2, in));
if (t1 == NULL_TREE || t2 == NULL_TREE)
return NULL_TREE;
- elts[out] = const_binop (MULT_EXPR, t1, t2);
- if (elts[out] == NULL_TREE || !CONSTANT_CLASS_P (elts[out]))
+ tree elt = const_binop (MULT_EXPR, t1, t2);
+ if (elt == NULL_TREE || !CONSTANT_CLASS_P (elt))
return NULL_TREE;
+ elts.quick_push (elt);
}
return build_vector (type, elts);
@@ -1638,18 +1634,17 @@ const_unop (enum tree_code code, tree ty
/* Perform BIT_NOT_EXPR on each element individually. */
else if (TREE_CODE (arg0) == VECTOR_CST)
{
- tree *elements;
tree elem;
unsigned count = VECTOR_CST_NELTS (arg0), i;
- elements = XALLOCAVEC (tree, count);
+ auto_vec<tree, 32> elements (count);
for (i = 0; i < count; i++)
{
elem = VECTOR_CST_ELT (arg0, i);
elem = const_unop (BIT_NOT_EXPR, TREE_TYPE (type), elem);
if (elem == NULL_TREE)
break;
- elements[i] = elem;
+ elements.quick_push (elem);
}
if (i == count)
return build_vector (type, elements);
@@ -1677,7 +1672,6 @@ const_unop (enum tree_code code, tree ty
case VEC_UNPACK_FLOAT_HI_EXPR:
{
unsigned int out_nelts, in_nelts, i;
- tree *elts;
enum tree_code subcode;
if (TREE_CODE (arg0) != VECTOR_CST)
@@ -1687,24 +1681,24 @@ const_unop (enum tree_code code, tree ty
out_nelts = in_nelts / 2;
gcc_assert (out_nelts == TYPE_VECTOR_SUBPARTS (type));
- elts = XALLOCAVEC (tree, in_nelts);
- if (!vec_cst_ctor_to_array (arg0, elts))
- return NULL_TREE;
-
+ unsigned int offset = 0;
if ((!BYTES_BIG_ENDIAN) ^ (code == VEC_UNPACK_LO_EXPR
|| code == VEC_UNPACK_FLOAT_LO_EXPR))
- elts += out_nelts;
+ offset = out_nelts;
if (code == VEC_UNPACK_LO_EXPR || code == VEC_UNPACK_HI_EXPR)
subcode = NOP_EXPR;
else
subcode = FLOAT_EXPR;
+ auto_vec<tree, 32> elts (out_nelts);
for (i = 0; i < out_nelts; i++)
{
- elts[i] = fold_convert_const (subcode, TREE_TYPE (type), elts[i]);
- if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
+ tree elt = fold_convert_const (subcode, TREE_TYPE (type),
+ VECTOR_CST_ELT (arg0, i + offset));
+ if (elt == NULL_TREE || !CONSTANT_CLASS_P (elt))
return NULL_TREE;
+ elts.quick_push (elt);
}
return build_vector (type, elts);
@@ -1715,17 +1709,12 @@ const_unop (enum tree_code code, tree ty
case REDUC_PLUS_EXPR:
{
unsigned int nelts, i;
- tree *elts;
enum tree_code subcode;
if (TREE_CODE (arg0) != VECTOR_CST)
return NULL_TREE;
nelts = VECTOR_CST_NELTS (arg0);
- elts = XALLOCAVEC (tree, nelts);
- if (!vec_cst_ctor_to_array (arg0, elts))
- return NULL_TREE;
-
switch (code)
{
case REDUC_MIN_EXPR: subcode = MIN_EXPR; break;
@@ -1734,14 +1723,15 @@ const_unop (enum tree_code code, tree ty
default: gcc_unreachable ();
}
+ tree res = VECTOR_CST_ELT (arg0, 0);
for (i = 1; i < nelts; i++)
{
- elts[0] = const_binop (subcode, elts[0], elts[i]);
- if (elts[0] == NULL_TREE || !CONSTANT_CLASS_P (elts[0]))
+ res = const_binop (subcode, res, VECTOR_CST_ELT (arg0, i));
+ if (res == NULL_TREE || !CONSTANT_CLASS_P (res))
return NULL_TREE;
}
- return elts[0];
+ return res;
}
default:
@@ -2163,14 +2153,14 @@ fold_convert_const (enum tree_code code,
{
int len = VECTOR_CST_NELTS (arg1);
tree elttype = TREE_TYPE (type);
- tree *v = XALLOCAVEC (tree, len);
+ auto_vec<tree, 32> v (len);
for (int i = 0; i < len; ++i)
{
tree elt = VECTOR_CST_ELT (arg1, i);
tree cvt = fold_convert_const (code, elttype, elt);
if (cvt == NULL_TREE)
return NULL_TREE;
- v[i] = cvt;
+ v.quick_push (cvt);
}
return build_vector (type, v);
}
@@ -7392,7 +7382,6 @@ native_interpret_vector (tree type, cons
{
tree etype, elem;
int i, size, count;
- tree *elements;
etype = TREE_TYPE (type);
size = GET_MODE_SIZE (SCALAR_TYPE_MODE (etype));
@@ -7400,13 +7389,13 @@ native_interpret_vector (tree type, cons
if (size * count > len)
return NULL_TREE;
- elements = XALLOCAVEC (tree, count);
- for (i = count - 1; i >= 0; i--)
+ auto_vec<tree, 32> elements (count);
+ for (i = 0; i < count; ++i)
{
elem = native_interpret_expr (etype, ptr+(i*size), size);
if (!elem)
return NULL_TREE;
- elements[i] = elem;
+ elements.quick_push (elem);
}
return build_vector (type, elements);
}
@@ -8761,12 +8750,13 @@ fold_mult_zconjz (location_t loc, tree t
/* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
- CONSTRUCTOR ARG into array ELTS and return true if successful. */
+ CONSTRUCTOR ARG into array ELTS, which has NELTS elements, and return
+ true if successful. */
static bool
-vec_cst_ctor_to_array (tree arg, tree *elts)
+vec_cst_ctor_to_array (tree arg, unsigned int nelts, tree *elts)
{
- unsigned int nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg)), i;
+ unsigned int i;
if (TREE_CODE (arg) == VECTOR_CST)
{
@@ -8799,7 +8789,6 @@ vec_cst_ctor_to_array (tree arg, tree *e
fold_vec_perm (tree type, tree arg0, tree arg1, const unsigned char *sel)
{
unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
- tree *elts;
bool need_ctor = false;
gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts
@@ -8808,16 +8797,17 @@ fold_vec_perm (tree type, tree arg0, tre
|| TREE_TYPE (TREE_TYPE (arg1)) != TREE_TYPE (type))
return NULL_TREE;
- elts = XALLOCAVEC (tree, nelts * 3);
- if (!vec_cst_ctor_to_array (arg0, elts)
- || !vec_cst_ctor_to_array (arg1, elts + nelts))
+ tree *in_elts = XALLOCAVEC (tree, nelts * 2);
+ if (!vec_cst_ctor_to_array (arg0, nelts, in_elts)
+ || !vec_cst_ctor_to_array (arg1, nelts, in_elts + nelts))
return NULL_TREE;
+ auto_vec<tree, 32> out_elts (nelts);
for (i = 0; i < nelts; i++)
{
- if (!CONSTANT_CLASS_P (elts[sel[i]]))
+ if (!CONSTANT_CLASS_P (in_elts[sel[i]]))
need_ctor = true;
- elts[i + 2 * nelts] = unshare_expr (elts[sel[i]]);
+ out_elts.quick_push (unshare_expr (in_elts[sel[i]]));
}
if (need_ctor)
@@ -8825,11 +8815,11 @@ fold_vec_perm (tree type, tree arg0, tre
vec<constructor_elt, va_gc> *v;
vec_alloc (v, nelts);
for (i = 0; i < nelts; i++)
- CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[2 * nelts + i]);
+ CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, out_elts[i]);
return build_constructor (type, v);
}
else
- return build_vector (type, &elts[2 * nelts]);
+ return build_vector (type, out_elts);
}
/* Try to fold a pointer difference of type TYPE two address expressions of
@@ -8879,7 +8869,7 @@ fold_addr_of_array_ref_difference (locat
exact_inverse (tree type, tree cst)
{
REAL_VALUE_TYPE r;
- tree unit_type, *elts;
+ tree unit_type;
machine_mode mode;
unsigned vec_nelts, i;
@@ -8894,20 +8884,22 @@ exact_inverse (tree type, tree cst)
return NULL_TREE;
case VECTOR_CST:
- vec_nelts = VECTOR_CST_NELTS (cst);
- elts = XALLOCAVEC (tree, vec_nelts);
- unit_type = TREE_TYPE (type);
- mode = TYPE_MODE (unit_type);
+ {
+ vec_nelts = VECTOR_CST_NELTS (cst);
+ unit_type = TREE_TYPE (type);
+ mode = TYPE_MODE (unit_type);
- for (i = 0; i < vec_nelts; i++)
- {
- r = TREE_REAL_CST (VECTOR_CST_ELT (cst, i));
- if (!exact_real_inverse (mode, &r))
- return NULL_TREE;
- elts[i] = build_real (unit_type, r);
- }
+ auto_vec<tree, 32> elts (vec_nelts);
+ for (i = 0; i < vec_nelts; i++)
+ {
+ r = TREE_REAL_CST (VECTOR_CST_ELT (cst, i));
+ if (!exact_real_inverse (mode, &r))
+ return NULL_TREE;
+ elts.quick_push (build_real (unit_type, r));
+ }
- return build_vector (type, elts);
+ return build_vector (type, elts);
+ }
default:
return NULL_TREE;
@@ -11596,9 +11588,9 @@ fold_ternary_loc (location_t loc, enum t
if (n == 1)
return VECTOR_CST_ELT (arg0, idx);
- tree *vals = XALLOCAVEC (tree, n);
+ auto_vec<tree, 32> vals (n);
for (unsigned i = 0; i < n; ++i)
- vals[i] = VECTOR_CST_ELT (arg0, idx + i);
+ vals.quick_push (VECTOR_CST_ELT (arg0, idx + i));
return build_vector (type, vals);
}
}
@@ -11731,10 +11723,10 @@ fold_ternary_loc (location_t loc, enum t
if (need_mask_canon && arg2 == op2)
{
- tree *tsel = XALLOCAVEC (tree, nelts);
tree eltype = TREE_TYPE (TREE_TYPE (arg2));
+ auto_vec<tree, 32> tsel (nelts);
for (i = 0; i < nelts; i++)
- tsel[i] = build_int_cst (eltype, sel[i]);
+ tsel.quick_push (build_int_cst (eltype, sel[i]));
op2 = build_vector (TREE_TYPE (arg2), tsel);
changed = true;
}
@@ -11775,8 +11767,10 @@ fold_ternary_loc (location_t loc, enum t
else
{
unsigned int nelts = VECTOR_CST_NELTS (arg0);
- tree *elts = XALLOCAVEC (tree, nelts);
- memcpy (elts, VECTOR_CST_ELTS (arg0), sizeof (tree) * nelts);
+ auto_vec<tree, 32> elts (nelts);
+ elts.quick_grow (nelts);
+ memcpy (&elts[0], VECTOR_CST_ELTS (arg0),
+ sizeof (tree) * nelts);
elts[k] = arg1;
return build_vector (type, elts);
}
@@ -13894,10 +13888,10 @@ fold_relational_const (enum tree_code co
return constant_boolean_node (true, type);
}
unsigned count = VECTOR_CST_NELTS (op0);
- tree *elts = XALLOCAVEC (tree, count);
gcc_assert (VECTOR_CST_NELTS (op1) == count
&& TYPE_VECTOR_SUBPARTS (type) == count);
+ auto_vec<tree, 32> elts (count);
for (unsigned i = 0; i < count; i++)
{
tree elem_type = TREE_TYPE (type);
@@ -13910,7 +13904,8 @@ fold_relational_const (enum tree_code co
if (tem == NULL_TREE)
return NULL_TREE;
- elts[i] = build_int_cst (elem_type, integer_zerop (tem) ? 0 : -1);
+ elts.quick_push (build_int_cst (elem_type,
+ integer_zerop (tem) ? 0 : -1));
}
return build_vector (type, elts);
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c 2017-08-30 12:19:19.718220029 +0100
+++ gcc/tree-vect-loop.c 2017-09-14 11:24:42.667932896 +0100
@@ -3969,7 +3969,6 @@ get_initial_def_for_reduction (gimple *s
enum tree_code code = gimple_assign_rhs_code (stmt);
tree def_for_init;
tree init_def;
- tree *elts;
int i;
bool nested_in_vect_loop = false;
REAL_VALUE_TYPE real_init_val = dconst0;
@@ -4015,15 +4014,16 @@ get_initial_def_for_reduction (gimple *s
switch (code)
{
- case WIDEN_SUM_EXPR:
- case DOT_PROD_EXPR:
- case SAD_EXPR:
- case PLUS_EXPR:
- case MINUS_EXPR:
- case BIT_IOR_EXPR:
- case BIT_XOR_EXPR:
- case MULT_EXPR:
- case BIT_AND_EXPR:
+ case WIDEN_SUM_EXPR:
+ case DOT_PROD_EXPR:
+ case SAD_EXPR:
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ case BIT_IOR_EXPR:
+ case BIT_XOR_EXPR:
+ case MULT_EXPR:
+ case BIT_AND_EXPR:
+ {
/* ADJUSMENT_DEF is NULL when called from
vect_create_epilog_for_reduction to vectorize double reduction. */
if (adjustment_def)
@@ -4044,17 +4044,19 @@ get_initial_def_for_reduction (gimple *s
def_for_init = build_int_cst (scalar_type, int_init_val);
/* Create a vector of '0' or '1' except the first element. */
- elts = XALLOCAVEC (tree, nunits);
+ auto_vec<tree, 32> elts (nunits);
+ elts.quick_grow (nunits);
for (i = nunits - 2; i >= 0; --i)
elts[i + 1] = def_for_init;
/* Option1: the first element is '0' or '1' as well. */
- if (adjustment_def)
- {
+ if (adjustment_def)
+ {
elts[0] = def_for_init;
- init_def = build_vector (vectype, elts);
- break;
- }
+
+ init_def = build_vector (vectype, elts);
+ break;
+ }
/* Option2: the first element is INIT_VAL. */
elts[0] = init_val;
@@ -4069,12 +4071,13 @@ get_initial_def_for_reduction (gimple *s
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[i]);
init_def = build_constructor (vectype, v);
}
+ }
+ break;
- break;
-
- case MIN_EXPR:
- case MAX_EXPR:
- case COND_EXPR:
+ case MIN_EXPR:
+ case MAX_EXPR:
+ case COND_EXPR:
+ {
if (adjustment_def)
{
*adjustment_def = NULL_TREE;
@@ -4088,10 +4091,11 @@ get_initial_def_for_reduction (gimple *s
if (! gimple_seq_empty_p (stmts))
gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts);
init_def = build_vector_from_val (vectype, init_val);
- break;
+ }
+ break;
- default:
- gcc_unreachable ();
+ default:
+ gcc_unreachable ();
}
return init_def;
@@ -4111,7 +4115,6 @@ get_initial_defs_for_reduction (slp_tree
stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
unsigned nunits;
tree vec_cst;
- tree *elts;
unsigned j, number_of_places_left_in_vector;
tree vector_type, scalar_type;
tree vop;
@@ -4195,7 +4198,8 @@ get_initial_defs_for_reduction (slp_tree
number_of_places_left_in_vector = nunits;
constant_p = true;
- elts = XALLOCAVEC (tree, nunits);
+ auto_vec<tree, 32> elts (nunits);
+ elts.quick_grow (nunits);
for (j = 0; j < number_of_copies; j++)
{
for (i = group_size - 1; stmts.iterate (i, &stmt); i--)
@@ -4533,9 +4537,9 @@ vect_create_epilog_for_reduction (vec<tr
vector size (STEP). */
/* Create a {1,2,3,...} vector. */
- tree *vtemp = XALLOCAVEC (tree, nunits_out);
+ auto_vec<tree, 32> vtemp (nunits_out);
for (k = 0; k < nunits_out; ++k)
- vtemp[k] = build_int_cst (cr_index_scalar_type, k + 1);
+ vtemp.quick_push (build_int_cst (cr_index_scalar_type, k + 1));
tree series_vect = build_vector (cr_index_vector_type, vtemp);
/* Create a vector of the step value. */
@@ -6731,7 +6735,7 @@ vectorizable_induction (gimple *phi,
unsigned ivn;
for (ivn = 0; ivn < nivs; ++ivn)
{
- tree *elts = XALLOCAVEC (tree, nunits);
+ auto_vec<tree, 32> elts (nunits);
bool constant_p = true;
for (unsigned eltn = 0; eltn < nunits; ++eltn)
{
@@ -6749,7 +6753,7 @@ vectorizable_induction (gimple *phi,
}
if (! CONSTANT_CLASS_P (elt))
constant_p = false;
- elts[eltn] = elt;
+ elts.quick_push (elt);
}
if (constant_p)
new_vec = build_vector (vectype, elts);
Index: gcc/config/sparc/sparc.c
===================================================================
--- gcc/config/sparc/sparc.c 2017-09-14 11:23:44.419204251 +0100
+++ gcc/config/sparc/sparc.c 2017-09-14 11:24:42.664243620 +0100
@@ -11446,7 +11446,7 @@ sparc_vis_mul8x16 (int e8, int e16)
the result into the array N_ELTS, whose elements are of INNER_TYPE. */
static void
-sparc_handle_vis_mul8x16 (tree *n_elts, enum sparc_builtins fncode,
+sparc_handle_vis_mul8x16 (vec<tree> *n_elts, enum sparc_builtins fncode,
tree inner_type, tree cst0, tree cst1)
{
unsigned i, num = VECTOR_CST_NELTS (cst0);
@@ -11460,7 +11460,7 @@ sparc_handle_vis_mul8x16 (tree *n_elts,
int val
= sparc_vis_mul8x16 (TREE_INT_CST_LOW (VECTOR_CST_ELT (cst0, i)),
TREE_INT_CST_LOW (VECTOR_CST_ELT (cst1, i)));
- n_elts[i] = build_int_cst (inner_type, val);
+ n_elts->quick_push (build_int_cst (inner_type, val));
}
break;
@@ -11472,7 +11472,7 @@ sparc_handle_vis_mul8x16 (tree *n_elts,
int val
= sparc_vis_mul8x16 (TREE_INT_CST_LOW (VECTOR_CST_ELT (cst0, i)),
scale);
- n_elts[i] = build_int_cst (inner_type, val);
+ n_elts->quick_push (build_int_cst (inner_type, val));
}
break;
@@ -11484,7 +11484,7 @@ sparc_handle_vis_mul8x16 (tree *n_elts,
int val
= sparc_vis_mul8x16 (TREE_INT_CST_LOW (VECTOR_CST_ELT (cst0, i)),
scale);
- n_elts[i] = build_int_cst (inner_type, val);
+ n_elts->quick_push (build_int_cst (inner_type, val));
}
break;
@@ -11533,14 +11533,15 @@ sparc_fold_builtin (tree fndecl, int n_a
if (TREE_CODE (arg0) == VECTOR_CST)
{
tree inner_type = TREE_TYPE (rtype);
- tree *n_elts;
unsigned i;
- n_elts = XALLOCAVEC (tree, VECTOR_CST_NELTS (arg0));
+ auto_vec<tree, 32> n_elts (VECTOR_CST_NELTS (arg0));
for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
- n_elts[i] = build_int_cst (inner_type,
- TREE_INT_CST_LOW
- (VECTOR_CST_ELT (arg0, i)) << 4);
+ {
+ unsigned HOST_WIDE_INT val
+ = TREE_INT_CST_LOW (VECTOR_CST_ELT (arg0, i));
+ n_elts.quick_push (build_int_cst (inner_type, val << 4));
+ }
return build_vector (rtype, n_elts);
}
break;
@@ -11556,8 +11557,8 @@ sparc_fold_builtin (tree fndecl, int n_a
if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
{
tree inner_type = TREE_TYPE (rtype);
- tree *n_elts = XALLOCAVEC (tree, VECTOR_CST_NELTS (arg0));
- sparc_handle_vis_mul8x16 (n_elts, code, inner_type, arg0, arg1);
+ auto_vec<tree, 32> n_elts (VECTOR_CST_NELTS (arg0));
+ sparc_handle_vis_mul8x16 (&n_elts, code, inner_type, arg0, arg1);
return build_vector (rtype, n_elts);
}
break;
@@ -11570,12 +11571,12 @@ sparc_fold_builtin (tree fndecl, int n_a
if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
{
- tree *n_elts = XALLOCAVEC (tree, 2 * VECTOR_CST_NELTS (arg0));
+ auto_vec<tree, 32> n_elts (2 * VECTOR_CST_NELTS (arg0));
unsigned i;
for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
{
- n_elts[2*i] = VECTOR_CST_ELT (arg0, i);
- n_elts[2*i+1] = VECTOR_CST_ELT (arg1, i);
+ n_elts.quick_push (VECTOR_CST_ELT (arg0, i));
+ n_elts.quick_push (VECTOR_CST_ELT (arg1, i));
}
return build_vector (rtype, n_elts);