https://gcc.gnu.org/g:1c402757ca18d91b8979b5ba634fc945dbb8b94b
commit r15-7119-g1c402757ca18d91b8979b5ba634fc945dbb8b94b
Author: Jakub Jelinek <ja...@redhat.com>
Date: Wed Jan 22 09:22:56 2025 +0100
c++: Introduce append_ctor_to_tree_vector
On Mon, Jan 20, 2025 at 05:14:33PM -0500, Jason Merrill wrote:
> > --- gcc/cp/call.cc.jj 2025-01-15 18:24:36.135503866 +0100
> > +++ gcc/cp/call.cc 2025-01-17 14:42:38.201643385 +0100
> > @@ -4258,11 +4258,30 @@ add_list_candidates (tree fns, tree firs
> > /* Expand the CONSTRUCTOR into a new argument vec. */
>
> Maybe we could factor out a function called something like
> append_ctor_to_tree_vector from the common code between this and
> make_tree_vector_from_ctor?
>
> But this is OK as is if you don't want to pursue that.
I had the previous patch already tested and wanted to avoid delaying
the large initializer speedup re-reversion any further, so I've committed
the patch as is.
Here is an incremental patch to factor that out.
2025-01-22 Jakub Jelinek <ja...@redhat.com>
gcc/c-family/
* c-common.h (append_ctor_to_tree_vector): Declare.
* c-common.cc (append_ctor_to_tree_vector): New function.
(make_tree_vector_from_ctor): Use it.
gcc/cp/
* call.cc (add_list_candidates): Use append_ctor_to_tree_vector.
Diff:
---
gcc/c-family/c-common.cc | 33 +++++++++++++++++++++------------
gcc/c-family/c-common.h | 2 ++
gcc/cp/call.cc | 24 ++----------------------
3 files changed, 25 insertions(+), 34 deletions(-)
diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
index 91d90725152a..c193eb2c463a 100644
--- a/gcc/c-family/c-common.cc
+++ b/gcc/c-family/c-common.cc
@@ -9010,33 +9010,42 @@ make_tree_vector_from_list (tree list)
return ret;
}
-/* Get a new tree vector of the values of a CONSTRUCTOR. */
+/* Append to a tree vector V the values of a CONSTRUCTOR CTOR
+ and return the new possibly reallocated vector. */
vec<tree, va_gc> *
-make_tree_vector_from_ctor (tree ctor)
+append_ctor_to_tree_vector (vec<tree, va_gc> *v, tree ctor)
{
- vec<tree,va_gc> *ret = make_tree_vector ();
- unsigned nelts = CONSTRUCTOR_NELTS (ctor);
- vec_safe_reserve (ret, CONSTRUCTOR_NELTS (ctor));
+ unsigned nelts = vec_safe_length (v) + CONSTRUCTOR_NELTS (ctor);
+ vec_safe_reserve (v, CONSTRUCTOR_NELTS (ctor));
for (unsigned i = 0; i < CONSTRUCTOR_NELTS (ctor); ++i)
if (TREE_CODE (CONSTRUCTOR_ELT (ctor, i)->value) == RAW_DATA_CST)
{
tree raw_data = CONSTRUCTOR_ELT (ctor, i)->value;
nelts += RAW_DATA_LENGTH (raw_data) - 1;
- vec_safe_reserve (ret, nelts - ret->length ());
+ vec_safe_reserve (v, nelts - v->length ());
if (TYPE_PRECISION (TREE_TYPE (raw_data)) > CHAR_BIT
|| TYPE_UNSIGNED (TREE_TYPE (raw_data)))
for (unsigned j = 0; j < (unsigned) RAW_DATA_LENGTH (raw_data); ++j)
- ret->quick_push (build_int_cst (TREE_TYPE (raw_data),
- RAW_DATA_UCHAR_ELT (raw_data, j)));
+ v->quick_push (build_int_cst (TREE_TYPE (raw_data),
+ RAW_DATA_UCHAR_ELT (raw_data, j)));
else
for (unsigned j = 0; j < (unsigned) RAW_DATA_LENGTH (raw_data); ++j)
- ret->quick_push (build_int_cst (TREE_TYPE (raw_data),
- RAW_DATA_SCHAR_ELT (raw_data, j)));
+ v->quick_push (build_int_cst (TREE_TYPE (raw_data),
+ RAW_DATA_SCHAR_ELT (raw_data, j)));
}
else
- ret->quick_push (CONSTRUCTOR_ELT (ctor, i)->value);
- return ret;
+ v->quick_push (CONSTRUCTOR_ELT (ctor, i)->value);
+ return v;
+}
+
+/* Get a new tree vector of the values of a CONSTRUCTOR. */
+
+vec<tree, va_gc> *
+make_tree_vector_from_ctor (tree ctor)
+{
+ vec<tree,va_gc> *ret = make_tree_vector ();
+ return append_ctor_to_tree_vector (ret, ctor);
}
/* Get a new tree vector which is a copy of an existing one. */
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 94b1d2d2b496..c5eb11d85fd5 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -1190,6 +1190,8 @@ extern vec<tree, va_gc> *make_tree_vector (void);
extern void release_tree_vector (vec<tree, va_gc> *);
extern vec<tree, va_gc> *make_tree_vector_single (tree);
extern vec<tree, va_gc> *make_tree_vector_from_list (tree);
+extern vec<tree, va_gc> *append_ctor_to_tree_vector (vec<tree, va_gc> *,
+ tree);
extern vec<tree, va_gc> *make_tree_vector_from_ctor (tree);
extern vec<tree, va_gc> *make_tree_vector_copy (const vec<tree, va_gc> *);
diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index 80015dfe9da6..469af83ccbfd 100644
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -4258,30 +4258,10 @@ add_list_candidates (tree fns, tree first_arg,
/* Expand the CONSTRUCTOR into a new argument vec. */
vec<tree, va_gc> *new_args;
- unsigned nelts = nart + CONSTRUCTOR_NELTS (init_list);
- vec_alloc (new_args, nelts);
+ vec_alloc (new_args, nart + CONSTRUCTOR_NELTS (init_list));
for (unsigned i = 0; i < nart; ++i)
new_args->quick_push ((*args)[i]);
- for (unsigned i = 0; i < CONSTRUCTOR_NELTS (init_list); ++i)
- if (TREE_CODE (CONSTRUCTOR_ELT (init_list, i)->value) == RAW_DATA_CST)
- {
- tree raw_data = CONSTRUCTOR_ELT (init_list, i)->value;
- nelts += RAW_DATA_LENGTH (raw_data) - 1;
- vec_safe_reserve (new_args, nelts - new_args->length ());
- if (TYPE_PRECISION (TREE_TYPE (raw_data)) > CHAR_BIT
- || TYPE_UNSIGNED (TREE_TYPE (raw_data)))
- for (unsigned j = 0; j < (unsigned) RAW_DATA_LENGTH (raw_data); ++j)
- new_args->quick_push (build_int_cst (TREE_TYPE (raw_data),
- RAW_DATA_UCHAR_ELT (raw_data,
- j)));
- else
- for (unsigned j = 0; j < (unsigned) RAW_DATA_LENGTH (raw_data); ++j)
- new_args->quick_push (build_int_cst (TREE_TYPE (raw_data),
- RAW_DATA_SCHAR_ELT (raw_data,
- j)));
- }
- else
- new_args->quick_push (CONSTRUCTOR_ELT (init_list, i)->value);
+ new_args = append_ctor_to_tree_vector (new_args, init_list);
/* We aren't looking for list-ctors anymore. */
flags &= ~LOOKUP_LIST_ONLY;
