@@ -1839,7 +1839,7 @@ strict_aliasing_warning (tree otype, tree type, tree expr)
void
sizeof_pointer_memaccess_warning (location_t *sizeof_arg_loc, tree callee,
- VEC(tree, gc) *params, tree *sizeof_arg,
+ vec<tree, va_gc> *params, tree *sizeof_arg,
bool (*comp_types) (tree, tree))
{
tree type, dest = NULL_TREE, src = NULL_TREE, tem;
@@ -1849,7 +1849,7 @@ sizeof_pointer_memaccess_warning (location_t *sizeof_arg_loc, tree callee,
if (TREE_CODE (callee) != FUNCTION_DECL
|| DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
- || VEC_length (tree, params) <= 1)
+ || vec_safe_length (params) <= 1)
return;
switch (DECL_FUNCTION_CODE (callee))
@@ -1870,55 +1870,55 @@ sizeof_pointer_memaccess_warning (location_t *sizeof_arg_loc, tree callee,
case BUILT_IN_MEMCPY_CHK:
case BUILT_IN_MEMMOVE:
case BUILT_IN_MEMMOVE_CHK:
- if (VEC_length (tree, params) < 3)
+ if (params->length () < 3)
return;
- src = VEC_index (tree, params, 1);
- dest = VEC_index (tree, params, 0);
+ src = (*params)[1];
+ dest = (*params)[0];
idx = 2;
break;
case BUILT_IN_BCOPY:
- if (VEC_length (tree, params) < 3)
+ if (params->length () < 3)
return;
- src = VEC_index (tree, params, 0);
- dest = VEC_index (tree, params, 1);
+ src = (*params)[0];
+ dest = (*params)[1];
idx = 2;
break;
case BUILT_IN_MEMCMP:
case BUILT_IN_BCMP:
- if (VEC_length (tree, params) < 3)
+ if (params->length () < 3)
return;
- src = VEC_index (tree, params, 1);
- dest = VEC_index (tree, params, 0);
+ src = (*params)[1];
+ dest = (*params)[0];
idx = 2;
cmp = true;
break;
case BUILT_IN_MEMSET:
case BUILT_IN_MEMSET_CHK:
- if (VEC_length (tree, params) < 3)
+ if (params->length () < 3)
return;
- dest = VEC_index (tree, params, 0);
+ dest = (*params)[0];
idx = 2;
break;
case BUILT_IN_BZERO:
- dest = VEC_index (tree, params, 0);
+ dest = (*params)[0];
idx = 1;
break;
case BUILT_IN_STRNDUP:
- src = VEC_index (tree, params, 0);
+ src = (*params)[0];
strop = true;
idx = 1;
break;
case BUILT_IN_MEMCHR:
- if (VEC_length (tree, params) < 3)
+ if (params->length () < 3)
return;
- src = VEC_index (tree, params, 0);
+ src = (*params)[0];
idx = 2;
break;
case BUILT_IN_SNPRINTF:
case BUILT_IN_SNPRINTF_CHK:
case BUILT_IN_VSNPRINTF:
case BUILT_IN_VSNPRINTF_CHK:
- dest = VEC_index (tree, params, 0);
+ dest = (*params)[0];
idx = 1;
strop = true;
break;
@@ -8729,9 +8729,7 @@ handle_target_attribute (tree *node, tree name, tree args, int flags,
/* Arguments being collected for optimization. */
typedef const char *const_char_p; /* For DEF_VEC_P. */
-DEF_VEC_P(const_char_p);
-DEF_VEC_ALLOC_P(const_char_p, gc);
-static GTY(()) VEC(const_char_p, gc) *optimize_args;
+static GTY(()) vec<const_char_p, va_gc> *optimize_args;
/* Inner function to convert a TREE_LIST to argv string to parse the optimize
@@ -8752,8 +8750,8 @@ parse_optimize_options (tree args, bool attr_p)
/* Build up argv vector. Just in case the string is stored away, use garbage
collected strings. */
- VEC_truncate (const_char_p, optimize_args, 0);
- VEC_safe_push (const_char_p, gc, optimize_args, NULL);
+ vec_safe_truncate (optimize_args, 0);
+ vec_safe_push (optimize_args, (const char *) NULL);
for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
{
@@ -8763,7 +8761,7 @@ parse_optimize_options (tree args, bool attr_p)
{
char buffer[20];
sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
- VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
+ vec_safe_push (optimize_args, ggc_strdup (buffer));
}
else if (TREE_CODE (value) == STRING_CST)
@@ -8825,17 +8823,17 @@ parse_optimize_options (tree args, bool attr_p)
memcpy (r, p, len2);
r[len2] = '\0';
- VEC_safe_push (const_char_p, gc, optimize_args, q);
+ vec_safe_push (optimize_args, (const char *) q);
}
}
}
- opt_argc = VEC_length (const_char_p, optimize_args);
+ opt_argc = optimize_args->length ();
opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
for (i = 1; i < opt_argc; i++)
- opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
+ opt_argv[i] = (*optimize_args)[i];
saved_flag_strict_aliasing = flag_strict_aliasing;
@@ -8852,7 +8850,7 @@ parse_optimize_options (tree args, bool attr_p)
/* Don't allow changing -fstrict-aliasing. */
flag_strict_aliasing = saved_flag_strict_aliasing;
- VEC_truncate (const_char_p, optimize_args, 0);
+ optimize_args->truncate (0);
return ret;
}
@@ -9736,9 +9734,9 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
}
else if (TREE_CODE (initial_value) == CONSTRUCTOR)
{
- VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
+ vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initial_value);
- if (VEC_empty (constructor_elt, v))
+ if (vec_safe_is_empty (v))
{
if (pedantic)
failure = 3;
@@ -9751,15 +9749,12 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
constructor_elt *ce;
bool fold_p = false;
- if (VEC_index (constructor_elt, v, 0).index)
+ if ((*v)[0].index)
maxindex = fold_convert_loc (input_location, sizetype,
- VEC_index (constructor_elt,
- v, 0).index);
+ (*v)[0].index);
curindex = maxindex;
- for (cnt = 1;
- VEC_iterate (constructor_elt, v, cnt, ce);
- cnt++)
+ for (cnt = 1; vec_safe_iterate (v, cnt, &ce); cnt++)
{
bool curfold_p = false;
if (ce->index)
@@ -9879,18 +9874,18 @@ builtin_type_for_size (int size, bool unsignedp)
Returns 0 if an error is encountered. */
static int
-sync_resolve_size (tree function, VEC(tree,gc) *params)
+sync_resolve_size (tree function, vec<tree, va_gc> *params)
{
tree type;
int size;
- if (VEC_empty (tree, params))
+ if (!params)
{
error ("too few arguments to function %qE", function);
return 0;
}
- type = TREE_TYPE (VEC_index (tree, params, 0));
+ type = TREE_TYPE ((*params)[0]);
if (TREE_CODE (type) != POINTER_TYPE)
goto incompatible;
@@ -9914,7 +9909,7 @@ sync_resolve_size (tree function, VEC(tree,gc) *params)
static bool
sync_resolve_params (location_t loc, tree orig_function, tree function,
- VEC(tree, gc) *params, bool orig_format)
+ vec<tree, va_gc> *params, bool orig_format)
{
function_args_iterator iter;
tree ptype;
@@ -9925,7 +9920,7 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
as the pointer parameter, so we shouldn't get any complaints from the
call to check_function_arguments what ever type the user used. */
function_args_iter_next (&iter);
- ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
+ ptype = TREE_TYPE (TREE_TYPE ((*params)[0]));
/* For the rest of the values, we need to cast these to FTYPE, so that we
don't get warnings for passing pointer types, etc. */
@@ -9940,7 +9935,7 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
break;
++parmnum;
- if (VEC_length (tree, params) <= parmnum)
+ if (params->length () <= parmnum)
{
error_at (loc, "too few arguments to function %qE", orig_function);
return false;
@@ -9956,17 +9951,17 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
/* Ideally for the first conversion we'd use convert_for_assignment
so that we get warnings for anything that doesn't match the pointer
type. This isn't portable across the C and C++ front ends atm. */
- val = VEC_index (tree, params, parmnum);
+ val = (*params)[parmnum];
val = convert (ptype, val);
val = convert (arg_type, val);
- VEC_replace (tree, params, parmnum, val);
+ (*params)[parmnum] = val;
}
function_args_iter_next (&iter);
}
/* __atomic routines are not variadic. */
- if (!orig_format && VEC_length (tree, params) != parmnum + 1)
+ if (!orig_format && params->length () != parmnum + 1)
{
error_at (loc, "too many arguments to function %qE", orig_function);
return false;
@@ -9976,7 +9971,7 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
being "an optional list of variables protected by the memory barrier".
No clue what that's supposed to mean, precisely, but we consider all
call-clobbered variables to be protected so we're safe. */
- VEC_truncate (tree, params, parmnum + 1);
+ params->truncate (parmnum + 1);
return true;
}
@@ -10004,7 +9999,8 @@ sync_resolve_return (tree first_param, tree result, bool orig_format)
0 is returned if the parameters are invalid. */
static int
-get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
+get_atomic_generic_size (location_t loc, tree function,
+ vec<tree, va_gc> *params)
{
unsigned int n_param;
unsigned int n_model;
@@ -10032,14 +10028,14 @@ get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
gcc_unreachable ();
}
- if (VEC_length (tree, params) != n_param)
+ if (vec_safe_length (params) != n_param)
{
error_at (loc, "incorrect number of arguments to function %qE", function);
return 0;
}
/* Get type of first parameter, and determine its size. */
- type_0 = TREE_TYPE (VEC_index (tree, params, 0));
+ type_0 = TREE_TYPE ((*params)[0]);
if (TREE_CODE (type_0) != POINTER_TYPE || VOID_TYPE_P (TREE_TYPE (type_0)))
{
error_at (loc, "argument 1 of %qE must be a non-void pointer type",
@@ -10071,7 +10067,7 @@ get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
for (x = 0; x < n_param - n_model; x++)
{
int size;
- tree type = TREE_TYPE (VEC_index (tree, params, x));
+ tree type = TREE_TYPE ((*params)[x]);
/* __atomic_compare_exchange has a bool in the 4th postion, skip it. */
if (n_param == 6 && x == 3)
continue;
@@ -10093,7 +10089,7 @@ get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
/* Check memory model parameters for validity. */
for (x = n_param - n_model ; x < n_param; x++)
{
- tree p = VEC_index (tree, params, x);
+ tree p = (*params)[x];
if (TREE_CODE (p) == INTEGER_CST)
{
int i = tree_low_cst (p, 1);
@@ -10126,30 +10122,30 @@ get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
static tree
add_atomic_size_parameter (unsigned n, location_t loc, tree function,
- VEC(tree,gc) *params)
+ vec<tree, va_gc> *params)
{
tree size_node;
/* Insert a SIZE_T parameter as the first param. If there isn't
enough space, allocate a new vector and recursively re-build with that. */
- if (!VEC_space (tree, params, 1))
+ if (!params->space (1))
{
unsigned int z, len;
- VEC(tree,gc) *vec;
+ vec<tree, va_gc> *v;
tree f;
- len = VEC_length (tree, params);
- vec = VEC_alloc (tree, gc, len + 1);
+ len = params->length ();
+ vec_alloc (v, len + 1);
for (z = 0; z < len; z++)
- VEC_quick_push (tree, vec, VEC_index (tree, params, z));
- f = build_function_call_vec (loc, function, vec, NULL);
- VEC_free (tree, gc, vec);
+ v->quick_push ((*params)[z]);
+ f = build_function_call_vec (loc, function, v, NULL);
+ vec_free (v);
return f;
}
/* Add the size parameter and leave as a function call for processing. */
size_node = build_int_cst (size_type_node, n);
- VEC_quick_insert (tree, params, 0, size_node);
+ params->quick_insert (0, size_node);
return NULL_TREE;
}
@@ -10165,7 +10161,7 @@ add_atomic_size_parameter (unsigned n, location_t loc, tree function,
NEW_RETURN is set to the the return value the result is copied into. */
static bool
resolve_overloaded_atomic_exchange (location_t loc, tree function,
- VEC(tree,gc) *params, tree *new_return)
+ vec<tree, va_gc> *params, tree *new_return)
{
tree p0, p1, p2, p3;
tree I_type, I_type_ptr;
@@ -10190,10 +10186,10 @@ resolve_overloaded_atomic_exchange (location_t loc, tree function,
into
*return = (T) (fn (In* mem, (In) *desired, model)) */
- p0 = VEC_index (tree, params, 0);
- p1 = VEC_index (tree, params, 1);
- p2 = VEC_index (tree, params, 2);
- p3 = VEC_index (tree, params, 3);
+ p0 = (*params)[0];
+ p1 = (*params)[1];
+ p2 = (*params)[2];
+ p3 = (*params)[3];
/* Create pointer to appropriate size. */
I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
@@ -10201,15 +10197,15 @@ resolve_overloaded_atomic_exchange (location_t loc, tree function,
/* Convert object pointer to required type. */
p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
- VEC_replace (tree, params, 0, p0);
+ (*params)[0] = p0;
/* Convert new value to required type, and dereference it. */
p1 = build_indirect_ref (loc, p1, RO_UNARY_STAR);
p1 = build1 (VIEW_CONVERT_EXPR, I_type, p1);
- VEC_replace (tree, params, 1, p1);
+ (*params)[1] = p1;
/* Move memory model to the 3rd position, and end param list. */
- VEC_replace (tree, params, 2, p3);
- VEC_truncate (tree, params, 3);
+ (*params)[2] = p3;
+ params->truncate (3);
/* Convert return pointer and dereference it for later assignment. */
*new_return = build_indirect_ref (loc, p2, RO_UNARY_STAR);
@@ -10229,7 +10225,7 @@ resolve_overloaded_atomic_exchange (location_t loc, tree function,
static bool
resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
- VEC(tree,gc) *params,
+ vec<tree, va_gc> *params,
tree *new_return)
{
tree p0, p1, p2;
@@ -10253,9 +10249,9 @@ resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
there is no danger this will be done twice. */
if (n > 0)
{
- VEC_replace (tree, params, 3, VEC_index (tree, params, 4));
- VEC_replace (tree, params, 4, VEC_index (tree, params, 5));
- VEC_truncate (tree, params, 5);
+ (*params)[3] = (*params)[4];
+ (*params)[4] = (*params)[5];
+ params->truncate (5);
}
*new_return = add_atomic_size_parameter (n, loc, function, params);
return true;
@@ -10266,9 +10262,9 @@ resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
into
bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */
- p0 = VEC_index (tree, params, 0);
- p1 = VEC_index (tree, params, 1);
- p2 = VEC_index (tree, params, 2);
+ p0 = (*params)[0];
+ p1 = (*params)[1];
+ p2 = (*params)[2];
/* Create pointer to appropriate size. */
I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
@@ -10276,16 +10272,16 @@ resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
/* Convert object pointer to required type. */
p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
- VEC_replace (tree, params, 0, p0);
+ (*params)[0] = p0;
/* Convert expected pointer to required type. */
p1 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p1);
- VEC_replace (tree, params, 1, p1);
+ (*params)[1] = p1;
/* Convert desired value to required type, and dereference it. */
p2 = build_indirect_ref (loc, p2, RO_UNARY_STAR);
p2 = build1 (VIEW_CONVERT_EXPR, I_type, p2);
- VEC_replace (tree, params, 2, p2);
+ (*params)[2] = p2;
/* The rest of the parameters are fine. NULL means no special return value
processing.*/
@@ -10306,7 +10302,7 @@ resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
static bool
resolve_overloaded_atomic_load (location_t loc, tree function,
- VEC(tree,gc) *params, tree *new_return)
+ vec<tree, va_gc> *params, tree *new_return)
{
tree p0, p1, p2;
tree I_type, I_type_ptr;
@@ -10331,9 +10327,9 @@ resolve_overloaded_atomic_load (location_t loc, tree function,
into
*return = (T) (fn ((In *) mem, model)) */
- p0 = VEC_index (tree, params, 0);
- p1 = VEC_index (tree, params, 1);
- p2 = VEC_index (tree, params, 2);
+ p0 = (*params)[0];
+ p1 = (*params)[1];
+ p2 = (*params)[2];
/* Create pointer to appropriate size. */
I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
@@ -10341,11 +10337,11 @@ resolve_overloaded_atomic_load (location_t loc, tree function,
/* Convert object pointer to required type. */
p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
- VEC_replace (tree, params, 0, p0);
+ (*params)[0] = p0;
/* Move memory model to the 2nd position, and end param list. */
- VEC_replace (tree, params, 1, p2);
- VEC_truncate (tree, params, 2);
+ (*params)[1] = p2;
+ params->truncate (2);
/* Convert return pointer and dereference it for later assignment. */
*new_return = build_indirect_ref (loc, p1, RO_UNARY_STAR);
@@ -10366,7 +10362,7 @@ resolve_overloaded_atomic_load (location_t loc, tree function,
static bool
resolve_overloaded_atomic_store (location_t loc, tree function,
- VEC(tree,gc) *params, tree *new_return)
+ vec<tree, va_gc> *params, tree *new_return)
{
tree p0, p1;
tree I_type, I_type_ptr;
@@ -10391,8 +10387,8 @@ resolve_overloaded_atomic_store (location_t loc, tree function,
into
fn ((In *) mem, (In) *value, model) */
- p0 = VEC_index (tree, params, 0);
- p1 = VEC_index (tree, params, 1);
+ p0 = (*params)[0];
+ p1 = (*params)[1];
/* Create pointer to appropriate size. */
I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
@@ -10400,12 +10396,12 @@ resolve_overloaded_atomic_store (location_t loc, tree function,
/* Convert object pointer to required type. */
p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
- VEC_replace (tree, params, 0, p0);
+ (*params)[0] = p0;
/* Convert new value to required type, and dereference it. */
p1 = build_indirect_ref (loc, p1, RO_UNARY_STAR);
p1 = build1 (VIEW_CONVERT_EXPR, I_type, p1);
- VEC_replace (tree, params, 1, p1);
+ (*params)[1] = p1;
/* The memory model is in the right spot already. Return is void. */
*new_return = NULL_TREE;
@@ -10426,7 +10422,8 @@ resolve_overloaded_atomic_store (location_t loc, tree function,
continue. */
tree
-resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
+resolve_overloaded_builtin (location_t loc, tree function,
+ vec<tree, va_gc> *params)
{
enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
bool orig_format = true;
@@ -10550,7 +10547,7 @@ resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
orig_format))
return error_mark_node;
- first_param = VEC_index (tree, params, 0);
+ first_param = (*params)[0];
result = build_function_call_vec (loc, new_function, params, NULL);
if (result == error_mark_node)
return result;
@@ -11097,9 +11094,9 @@ record_types_used_by_current_var_decl (tree decl)
{
gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
- while (!VEC_empty (tree, types_used_by_cur_var_decl))
+ while (types_used_by_cur_var_decl && !types_used_by_cur_var_decl->is_empty ())
{
- tree type = VEC_pop (tree, types_used_by_cur_var_decl);
+ tree type = types_used_by_cur_var_decl->pop ();
types_used_by_var_decl_insert (type, decl);
}
}
@@ -11121,7 +11118,7 @@ record_locally_defined_typedef (tree decl)
return;
l = (struct c_language_function *) cfun->language;
- VEC_safe_push (tree, gc, l->local_typedefs, decl);
+ vec_safe_push (l->local_typedefs, decl);
}
/* If T is a TYPE_DECL declared locally, mark it as used. */
@@ -11159,7 +11156,7 @@ maybe_warn_unused_local_typedefs (void)
if (warn_unused_local_typedefs
&& errorcount == unused_local_typedefs_warn_count)
{
- FOR_EACH_VEC_ELT (tree, l->local_typedefs, i, decl)
+ FOR_EACH_VEC_SAFE_ELT (l->local_typedefs, i, decl)
if (!TREE_USED (decl))
warning_at (DECL_SOURCE_LOCATION (decl),
OPT_Wunused_local_typedefs,
@@ -11167,86 +11164,82 @@ maybe_warn_unused_local_typedefs (void)
unused_local_typedefs_warn_count = errorcount;
}
- if (l->local_typedefs)
- {
- VEC_free (tree, gc, l->local_typedefs);
- l->local_typedefs = NULL;
- }
+ vec_free (l->local_typedefs);
}
/* The C and C++ parsers both use vectors to hold function arguments.
For efficiency, we keep a cache of unused vectors. This is the
cache. */
-typedef VEC(tree,gc)* tree_gc_vec;
-DEF_VEC_P(tree_gc_vec);
-DEF_VEC_ALLOC_P(tree_gc_vec,gc);
-static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
+typedef vec<tree, va_gc> *tree_gc_vec;
+static GTY((deletable)) vec<tree_gc_vec, va_gc> *tree_vector_cache;
/* Return a new vector from the cache. If the cache is empty,
allocate a new vector. These vectors are GC'ed, so it is OK if the
pointer is not released.. */
-VEC(tree,gc) *
+vec<tree, va_gc> *
make_tree_vector (void)
{
- if (!VEC_empty (tree_gc_vec, tree_vector_cache))
- return VEC_pop (tree_gc_vec, tree_vector_cache);
+ if (tree_vector_cache && !tree_vector_cache->is_empty ())
+ return tree_vector_cache->pop ();
else
{
- /* Passing 0 to VEC_alloc returns NULL, and our callers require
+ /* Passing 0 to vec::alloc returns NULL, and our callers require
that we always return a non-NULL value. The vector code uses
4 when growing a NULL vector, so we do too. */
- return VEC_alloc (tree, gc, 4);
+ vec<tree, va_gc> *v;
+ vec_alloc (v, 4);
+ return v;
}
}
/* Release a vector of trees back to the cache. */
void
-release_tree_vector (VEC(tree,gc) *vec)
+release_tree_vector (vec<tree, va_gc> *vec)
{
if (vec != NULL)
{
- VEC_truncate (tree, vec, 0);
- VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
+ vec->truncate (0);
+ vec_safe_push (tree_vector_cache, vec);
}
}
/* Get a new tree vector holding a single tree. */
-VEC(tree,gc) *
+vec<tree, va_gc> *
make_tree_vector_single (tree t)
{
- VEC(tree,gc) *ret = make_tree_vector ();
- VEC_quick_push (tree, ret, t);
+ vec<tree, va_gc> *ret = make_tree_vector ();
+ ret->quick_push (t);
return ret;
}
/* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */
-VEC(tree,gc) *
+vec<tree, va_gc> *
make_tree_vector_from_list (tree list)
{
- VEC(tree,gc) *ret = make_tree_vector ();
+ vec<tree, va_gc> *ret = make_tree_vector ();
for (; list; list = TREE_CHAIN (list))
- VEC_safe_push (tree, gc, ret, TREE_VALUE (list));
+ vec_safe_push (ret, TREE_VALUE (list));
return ret;
}
/* Get a new tree vector which is a copy of an existing one. */
-VEC(tree,gc) *
-make_tree_vector_copy (const VEC(tree,gc) *orig)
+vec<tree, va_gc> *
+make_tree_vector_copy (const vec<tree, va_gc> *orig)
{
- VEC(tree,gc) *ret;
+ vec<tree, va_gc> *ret;
unsigned int ix;
tree t;
ret = make_tree_vector ();
- VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
- FOR_EACH_VEC_ELT (tree, orig, ix, t)
- VEC_quick_push (tree, ret, t);
+ vec_safe_reserve (ret, vec_safe_length (orig));
+ FOR_EACH_VEC_SAFE_ELT (orig, ix, t)
+ ret->quick_push (t);
return ret;
}
@@ -486,7 +486,7 @@ typedef enum ref_operator {
struct GTY(()) stmt_tree_s {
/* A stack of statement lists being collected. */
- VEC(tree,gc) *x_cur_stmt_list;
+ vec<tree, va_gc> *x_cur_stmt_list;
/* In C++, Nonzero if we should treat statements as full
expressions. In particular, this variable is non-zero if at the
@@ -512,20 +512,16 @@ struct GTY(()) c_language_function {
/* Vector of locally defined typedefs, for
-Wunused-local-typedefs. */
- VEC(tree,gc) *local_typedefs;
+ vec<tree, va_gc> *local_typedefs;
};
#define stmt_list_stack (current_stmt_tree ()->x_cur_stmt_list)
/* When building a statement-tree, this is the current statement list
- being collected. We define it in this convoluted way, rather than
- using VEC_last, because it must be an lvalue. */
+ being collected. */
+#define cur_stmt_list (stmt_list_stack->last ())
-#define cur_stmt_list \
- (*(VEC_address (tree, stmt_list_stack) \
- + VEC_length (tree, stmt_list_stack) - 1))
-
-#define building_stmt_list_p() (!VEC_empty (tree, stmt_list_stack))
+#define building_stmt_list_p() (stmt_list_stack && !stmt_list_stack->is_empty())
/* Language-specific hooks. */
@@ -759,7 +755,7 @@ extern void constant_expression_warning (tree);
extern void constant_expression_error (tree);
extern bool strict_aliasing_warning (tree, tree, tree);
extern void sizeof_pointer_memaccess_warning (location_t *, tree,
- VEC(tree, gc) *, tree *,
+ vec<tree, va_gc> *, tree *,
bool (*) (tree, tree));
extern void warnings_for_convert_and_check (tree, tree, tree);
extern tree convert_and_check (tree, tree);
@@ -899,10 +895,10 @@ extern void c_do_switch_warnings (splay_tree, location_t, tree, tree);
extern tree build_function_call (location_t, tree, tree);
-extern tree build_function_call_vec (location_t, tree,
- VEC(tree,gc) *, VEC(tree,gc) *);
+extern tree build_function_call_vec (location_t, tree, vec<tree, va_gc> *,
+ vec<tree, va_gc> *);
-extern tree resolve_overloaded_builtin (location_t, tree, VEC(tree,gc) *);
+extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *);
extern tree finish_label_address_expr (tree, location_t);
@@ -997,11 +993,11 @@ extern void set_underlying_type (tree);
extern void record_locally_defined_typedef (tree);
extern void maybe_record_typedef_use (tree);
extern void maybe_warn_unused_local_typedefs (void);
-extern VEC(tree,gc) *make_tree_vector (void);
-extern void release_tree_vector (VEC(tree,gc) *);
-extern VEC(tree,gc) *make_tree_vector_single (tree);
-extern VEC(tree,gc) *make_tree_vector_from_list (tree);
-extern VEC(tree,gc) *make_tree_vector_copy (const VEC(tree,gc) *);
+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> *make_tree_vector_copy (const vec<tree, va_gc> *);
/* In c-gimplify.c */
extern void c_genericize (tree);
@@ -108,9 +108,9 @@ add_block_to_enclosing (tree block)
unsigned i;
tree enclosing;
gimple bind;
- VEC(gimple, heap) *stack = gimple_bind_expr_stack ();
+ vec<gimple> stack = gimple_bind_expr_stack ();
- FOR_EACH_VEC_ELT (gimple, stack, i, bind)
+ FOR_EACH_VEC_ELT (stack, i, bind)
if (gimple_bind_block (bind))
break;
@@ -33,7 +33,6 @@ along with GCC; see the file COPYING3. If not see
#include "tm_p.h" /* For REGISTER_TARGET_PRAGMAS (why is
this not a target hook?). */
#include "vec.h"
-#include "vecprim.h"
#include "target.h"
#include "diagnostic.h"
#include "opts.h"
@@ -241,10 +240,8 @@ typedef struct GTY(()) pending_weak_d
tree value;
} pending_weak;
-DEF_VEC_O(pending_weak);
-DEF_VEC_ALLOC_O(pending_weak,gc);
-static GTY(()) VEC(pending_weak,gc) *pending_weaks;
+static GTY(()) vec<pending_weak, va_gc> *pending_weaks;
static void apply_pragma_weak (tree, tree);
static void handle_pragma_weak (cpp_reader *);
@@ -294,11 +291,11 @@ maybe_apply_pragma_weak (tree decl)
id = DECL_ASSEMBLER_NAME (decl);
- FOR_EACH_VEC_ELT (pending_weak, pending_weaks, i, pe)
+ FOR_EACH_VEC_ELT (*pending_weaks, i, pe)
if (id == pe->name)
{
apply_pragma_weak (decl, pe->value);
- VEC_unordered_remove (pending_weak, pending_weaks, i);
+ pending_weaks->unordered_remove (i);
break;
}
}
@@ -313,7 +310,10 @@ maybe_apply_pending_pragma_weaks (void)
pending_weak *pe;
symtab_node target;
- FOR_EACH_VEC_ELT (pending_weak, pending_weaks, i, pe)
+ if (!pending_weaks)
+ return;
+
+ FOR_EACH_VEC_ELT (*pending_weaks, i, pe)
{
alias_id = pe->name;
id = pe->value;
@@ -373,7 +373,7 @@ handle_pragma_weak (cpp_reader * ARG_UNUSED (dummy))
else
{
pending_weak pe = {name, value};
- VEC_safe_push (pending_weak, gc, pending_weaks, pe);
+ vec_safe_push (pending_weaks, pe);
}
}
@@ -414,10 +414,8 @@ typedef struct GTY(()) pending_redefinition_d {
tree newname;
} pending_redefinition;
-DEF_VEC_O(pending_redefinition);
-DEF_VEC_ALLOC_O(pending_redefinition,gc);
-static GTY(()) VEC(pending_redefinition,gc) *pending_redefine_extname;
+static GTY(()) vec<pending_redefinition, va_gc> *pending_redefine_extname;
static void handle_pragma_redefine_extname (cpp_reader *);
@@ -488,7 +486,7 @@ add_to_renaming_pragma_list (tree oldname, tree newname)
unsigned ix;
pending_redefinition *p;
- FOR_EACH_VEC_ELT (pending_redefinition, pending_redefine_extname, ix, p)
+ FOR_EACH_VEC_SAFE_ELT (pending_redefine_extname, ix, p)
if (oldname == p->oldname)
{
if (p->newname != newname)
@@ -498,7 +496,7 @@ add_to_renaming_pragma_list (tree oldname, tree newname)
}
pending_redefinition e = {oldname, newname};
- VEC_safe_push (pending_redefinition, gc, pending_redefine_extname, e);
+ vec_safe_push (pending_redefine_extname, e);
}
/* The current prefix set by #pragma extern_prefix. */
@@ -532,7 +530,7 @@ maybe_apply_renaming_pragma (tree decl, tree asmname)
"conflict with previous rename");
/* Take any pending redefine_extname off the list. */
- FOR_EACH_VEC_ELT (pending_redefinition, pending_redefine_extname, ix, p)
+ FOR_EACH_VEC_SAFE_ELT (pending_redefine_extname, ix, p)
if (DECL_NAME (decl) == p->oldname)
{
/* Only warn if there is a conflict. */
@@ -540,20 +538,18 @@ maybe_apply_renaming_pragma (tree decl, tree asmname)
warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
"conflict with previous rename");
- VEC_unordered_remove (pending_redefinition,
- pending_redefine_extname, ix);
+ pending_redefine_extname->unordered_remove (ix);
break;
}
return 0;
}
/* Find out if we have a pending #pragma redefine_extname. */
- FOR_EACH_VEC_ELT (pending_redefinition, pending_redefine_extname, ix, p)
+ FOR_EACH_VEC_SAFE_ELT (pending_redefine_extname, ix, p)
if (DECL_NAME (decl) == p->oldname)
{
tree newname = p->newname;
- VEC_unordered_remove (pending_redefinition,
- pending_redefine_extname, ix);
+ pending_redefine_extname->unordered_remove (ix);
/* If we already have an asmname, #pragma redefine_extname is
ignored (with a warning if it conflicts). */
@@ -600,7 +596,7 @@ maybe_apply_renaming_pragma (tree decl, tree asmname)
static void handle_pragma_visibility (cpp_reader *);
-static VEC (int, heap) *visstack;
+static vec<int> visstack;
/* Push the visibility indicated by STR onto the top of the #pragma
visibility stack. KIND is 0 for #pragma GCC visibility, 1 for
@@ -612,8 +608,7 @@ static VEC (int, heap) *visstack;
void
push_visibility (const char *str, int kind)
{
- VEC_safe_push (int, heap, visstack,
- ((int) default_visibility) | (kind << 8));
+ visstack.safe_push (((int) default_visibility) | (kind << 8));
if (!strcmp (str, "default"))
default_visibility = VISIBILITY_DEFAULT;
else if (!strcmp (str, "internal"))
@@ -633,14 +628,14 @@ push_visibility (const char *str, int kind)
bool
pop_visibility (int kind)
{
- if (!VEC_length (int, visstack))
+ if (!visstack.length ())
return false;
- if ((VEC_last (int, visstack) >> 8) != kind)
+ if ((visstack.last () >> 8) != kind)
return false;
default_visibility
- = (enum symbol_visibility) (VEC_pop (int, visstack) & 0xff);
+ = (enum symbol_visibility) (visstack.pop () & 0xff);
visibility_options.inpragma
- = VEC_length (int, visstack) != 0;
+ = visstack.length () != 0;
return true;
}
@@ -1152,10 +1147,8 @@ handle_pragma_float_const_decimal64 (cpp_reader *ARG_UNUSED (dummy))
}
/* A vector of registered pragma callbacks, which is never freed. */
-DEF_VEC_O (internal_pragma_handler);
-DEF_VEC_ALLOC_O (internal_pragma_handler, heap);
-static VEC(internal_pragma_handler, heap) *registered_pragmas;
+static vec<internal_pragma_handler> registered_pragmas;
typedef struct
{
@@ -1163,10 +1156,8 @@ typedef struct
const char *name;
} pragma_ns_name;
-DEF_VEC_O (pragma_ns_name);
-DEF_VEC_ALLOC_O (pragma_ns_name, heap);
-static VEC(pragma_ns_name, heap) *registered_pp_pragmas;
+static vec<pragma_ns_name> registered_pp_pragmas;
struct omp_pragma_def { const char *name; unsigned int id; };
static const struct omp_pragma_def omp_pragmas[] = {
@@ -1202,13 +1193,10 @@ c_pp_lookup_pragma (unsigned int id, const char **space, const char **name)
}
if (id >= PRAGMA_FIRST_EXTERNAL
- && (id < PRAGMA_FIRST_EXTERNAL
- + VEC_length (pragma_ns_name, registered_pp_pragmas)))
+ && (id < PRAGMA_FIRST_EXTERNAL + registered_pp_pragmas.length ()))
{
- *space = VEC_index (pragma_ns_name, registered_pp_pragmas,
- id - PRAGMA_FIRST_EXTERNAL).space;
- *name = VEC_index (pragma_ns_name, registered_pp_pragmas,
- id - PRAGMA_FIRST_EXTERNAL).name;
+ *space = registered_pp_pragmas[id - PRAGMA_FIRST_EXTERNAL].space;
+ *name = registered_pp_pragmas[id - PRAGMA_FIRST_EXTERNAL].name;
return;
}
@@ -1233,15 +1221,14 @@ c_register_pragma_1 (const char *space, const char *name,
ns_name.space = space;
ns_name.name = name;
- VEC_safe_push (pragma_ns_name, heap, registered_pp_pragmas, ns_name);
- id = VEC_length (pragma_ns_name, registered_pp_pragmas);
+ registered_pp_pragmas.safe_push (ns_name);
+ id = registered_pp_pragmas.length ();
id += PRAGMA_FIRST_EXTERNAL - 1;
}
else
{
- VEC_safe_push (internal_pragma_handler, heap, registered_pragmas,
- ihandler);
- id = VEC_length (internal_pragma_handler, registered_pragmas);
+ registered_pragmas.safe_push (ihandler);
+ id = registered_pragmas.length ();
id += PRAGMA_FIRST_EXTERNAL - 1;
/* The C++ front end allocates 6 bits in cp_token; the C front end
@@ -1331,7 +1318,7 @@ c_invoke_pragma_handler (unsigned int id)
pragma_handler_2arg handler_2arg;
id -= PRAGMA_FIRST_EXTERNAL;
- ihandler = &VEC_index (internal_pragma_handler, registered_pragmas, id);
+ ihandler = ®istered_pragmas[id];
if (ihandler->extra_data)
{
handler_2arg = ihandler->handler.handler_2arg;
@@ -1662,7 +1662,7 @@ pp_c_expression_list (c_pretty_printer *pp, tree e)
/* Print out V, which contains the elements of a constructor. */
void
-pp_c_constructor_elts (c_pretty_printer *pp, VEC(constructor_elt,gc) *v)
+pp_c_constructor_elts (c_pretty_printer *pp, vec<constructor_elt, va_gc> *v)
{
unsigned HOST_WIDE_INT ix;
tree value;
@@ -1670,7 +1670,7 @@ pp_c_constructor_elts (c_pretty_printer *pp, VEC(constructor_elt,gc) *v)
FOR_EACH_CONSTRUCTOR_VALUE (v, ix, value)
{
pp_expression (pp, value);
- if (ix != VEC_length (constructor_elt, v) - 1)
+ if (ix != vec_safe_length (v) - 1)
pp_separate_with (pp, ',');
}
}
@@ -198,7 +198,7 @@ void pp_c_statement (c_pretty_printer *, tree);
void pp_c_expression (c_pretty_printer *, tree);
void pp_c_logical_or_expression (c_pretty_printer *, tree);
void pp_c_expression_list (c_pretty_printer *, tree);
-void pp_c_constructor_elts (c_pretty_printer *, VEC(constructor_elt,gc) *);
+void pp_c_constructor_elts (c_pretty_printer *, vec<constructor_elt, va_gc> *);
void pp_c_call_argument_list (c_pretty_printer *, tree);
void pp_c_unary_expression (c_pretty_printer *, tree);
void pp_c_cast_expression (c_pretty_printer *, tree);
@@ -37,7 +37,7 @@ push_stmt_list (void)
{
tree t;
t = alloc_stmt_list ();
- VEC_safe_push (tree, gc, stmt_list_stack, t);
+ vec_safe_push (stmt_list_stack, t);
return t;
}
@@ -52,10 +52,10 @@ pop_stmt_list (tree t)
nestings will be due to outstanding cleanups. */
while (1)
{
- u = VEC_pop (tree, stmt_list_stack);
- if (!VEC_empty (tree, stmt_list_stack))
+ u = stmt_list_stack->pop ();
+ if (!stmt_list_stack->is_empty ())
{
- tree x = VEC_last (tree, stmt_list_stack);
+ tree x = stmt_list_stack->last ();
STATEMENT_LIST_HAS_LABEL (x) |= STATEMENT_LIST_HAS_LABEL (u);
}
if (t == u)
@@ -286,8 +286,6 @@ struct GTY(()) c_goto_bindings {
};
typedef struct c_goto_bindings *c_goto_bindings_p;
-DEF_VEC_P(c_goto_bindings_p);
-DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);
/* The additional information we keep track of for a label binding.
These fields are updated as scopes are popped. */
@@ -302,11 +300,11 @@ struct GTY(()) c_label_vars {
warn if a goto branches to this label from later in the function.
Decls are added to this list as scopes are popped. We only add
the decls that matter. */
- VEC(tree,gc) *decls_in_scope;
+ vec<tree, va_gc> *decls_in_scope;
/* A list of goto statements to this label. This is only used for
goto statements seen before the label was defined, so that we can
issue appropriate warnings for them. */
- VEC(c_goto_bindings_p,gc) *gotos;
+ vec<c_goto_bindings_p, va_gc> *gotos;
};
/* Each c_scope structure describes the complete contents of one
@@ -496,11 +494,9 @@ static bool keep_next_level_flag;
static bool next_is_function_body;
-/* A VEC of pointers to c_binding structures. */
+/* A vector of pointers to c_binding structures. */
typedef struct c_binding *c_binding_ptr;
-DEF_VEC_P(c_binding_ptr);
-DEF_VEC_ALLOC_P(c_binding_ptr,heap);
/* Information that we keep for a struct or union while it is being
parsed. */
@@ -509,15 +505,15 @@ struct c_struct_parse_info
{
/* If warn_cxx_compat, a list of types defined within this
struct. */
- VEC(tree,heap) *struct_types;
+ vec<tree> struct_types;
/* If warn_cxx_compat, a list of field names which have bindings,
and which are defined in this struct, but which are not defined
in any enclosing struct. This is used to clear the in_struct
field of the c_bindings structure. */
- VEC(c_binding_ptr,heap) *fields;
+ vec<c_binding_ptr> fields;
/* If warn_cxx_compat, a list of typedef names used when defining
fields in this struct. */
- VEC(tree,heap) *typedefs_seen;
+ vec<tree> typedefs_seen;
};
/* Information for the struct or union currently being parsed, or
@@ -1019,16 +1015,14 @@ update_label_decls (struct c_scope *scope)
of B1, if any. Save it to issue a
warning if needed. */
if (decl_jump_unsafe (b1->decl))
- VEC_safe_push (tree, gc,
- label_vars->decls_in_scope,
- b1->decl);
+ vec_safe_push(label_vars->decls_in_scope, b1->decl);
}
}
}
/* Update the bindings of any goto statements associated
with this label. */
- FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+ FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
update_spot_bindings (scope, &g->goto_bindings);
}
}
@@ -1375,7 +1369,7 @@ c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
continue;
label_vars = b->u.label;
++label_vars->label_bindings.stmt_exprs;
- FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+ FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
++g->goto_bindings.stmt_exprs;
}
}
@@ -1413,7 +1407,7 @@ c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
label_vars->label_bindings.left_stmt_expr = true;
label_vars->label_bindings.stmt_exprs = 0;
}
- FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+ FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
{
--g->goto_bindings.stmt_exprs;
if (g->goto_bindings.stmt_exprs < 0)
@@ -3056,7 +3050,7 @@ make_label (location_t location, tree name, bool defining,
label_vars->shadowed = NULL;
set_spot_bindings (&label_vars->label_bindings, defining);
label_vars->decls_in_scope = make_tree_vector ();
- label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
+ label_vars->gotos = NULL;
*p_label_vars = label_vars;
return label;
@@ -3153,7 +3147,7 @@ lookup_label_for_goto (location_t loc, tree name)
g = ggc_alloc_c_goto_bindings ();
g->loc = loc;
set_spot_bindings (&g->goto_bindings, true);
- VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
+ vec_safe_push (label_vars->gotos, g);
return label;
}
@@ -3165,7 +3159,7 @@ lookup_label_for_goto (location_t loc, tree name)
...
goto lab;
Issue a warning or error. */
- FOR_EACH_VEC_ELT (tree, label_vars->decls_in_scope, ix, decl)
+ FOR_EACH_VEC_SAFE_ELT (label_vars->decls_in_scope, ix, decl)
warn_about_goto (loc, label, decl);
if (label_vars->label_bindings.left_stmt_expr)
@@ -3217,7 +3211,7 @@ check_earlier_gotos (tree label, struct c_label_vars* label_vars)
unsigned int ix;
struct c_goto_bindings *g;
- FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+ FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
{
struct c_binding *b;
struct c_scope *scope;
@@ -3267,7 +3261,7 @@ check_earlier_gotos (tree label, struct c_label_vars* label_vars)
/* Now that the label is defined, we will issue warnings about
subsequent gotos to this label when we see them. */
- VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
+ vec_safe_truncate (label_vars->gotos, 0);
label_vars->gotos = NULL;
}
@@ -3939,10 +3933,10 @@ add_flexible_array_elts_to_size (tree decl, tree init)
{
tree elt, type;
- if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
+ if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
return;
- elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init)).value;
+ elt = CONSTRUCTOR_ELTS (init)->last ().value;
type = TREE_TYPE (elt);
if (TREE_CODE (type) == ARRAY_TYPE
&& TYPE_SIZE (type) == NULL_TREE
@@ -4509,15 +4503,15 @@ finish_decl (tree decl, location_t init_loc, tree init,
tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
tree cleanup_decl = lookup_name (cleanup_id);
tree cleanup;
- VEC(tree,gc) *vec;
+ vec<tree, va_gc> *v;
/* Build "cleanup(&decl)" for the destructor. */
cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
- vec = VEC_alloc (tree, gc, 1);
- VEC_quick_push (tree, vec, cleanup);
+ vec_alloc (v, 1);
+ v->quick_push (cleanup);
cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
- cleanup_decl, vec, NULL);
- VEC_free (tree, gc, vec);
+ cleanup_decl, v, NULL);
+ vec_free (v);
/* Don't warn about decl unused; the cleanup uses it. */
TREE_USED (decl) = 1;
@@ -5656,7 +5650,7 @@ grokdeclarator (const struct c_declarator *declarator,
c_arg_tag *tag;
unsigned ix;
- FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
+ FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag)
TYPE_CONTEXT (tag->type) = type;
}
break;
@@ -6398,7 +6392,7 @@ get_parm_info (bool ellipsis, tree expr)
struct c_arg_info *arg_info = build_arg_info ();
tree parms = 0;
- VEC(c_arg_tag,gc) *tags = NULL;
+ vec<c_arg_tag, va_gc> *tags = NULL;
tree types = 0;
tree others = 0;
@@ -6523,7 +6517,7 @@ get_parm_info (bool ellipsis, tree expr)
tag.id = b->id;
tag.type = decl;
- VEC_safe_push (c_arg_tag, gc, tags, tag);
+ vec_safe_push (tags, tag);
break;
case CONST_DECL:
@@ -6735,9 +6729,9 @@ start_struct (location_t loc, enum tree_code code, tree name,
*enclosing_struct_parse_info = struct_parse_info;
struct_parse_info = XNEW (struct c_struct_parse_info);
- struct_parse_info->struct_types = VEC_alloc (tree, heap, 0);
- struct_parse_info->fields = VEC_alloc (c_binding_ptr, heap, 0);
- struct_parse_info->typedefs_seen = VEC_alloc (tree, heap, 0);
+ struct_parse_info->struct_types.create (0);
+ struct_parse_info->fields.create (0);
+ struct_parse_info->typedefs_seen.create (0);
/* FIXME: This will issue a warning for a use of a type defined
within a statement expr used within sizeof, et. al. This is not
@@ -6847,8 +6841,7 @@ grokfield (location_t loc,
to be cleared when this struct is finished. */
if (!b->in_struct)
{
- VEC_safe_push (c_binding_ptr, heap,
- struct_parse_info->fields, b);
+ struct_parse_info->fields.safe_push (b);
b->in_struct = 1;
}
}
@@ -7028,7 +7021,7 @@ warn_cxx_compat_finish_struct (tree fieldlist)
because the flag is used to issue visibility warnings, and we
only want to issue those warnings if the type is referenced
outside of the struct declaration. */
- FOR_EACH_VEC_ELT (tree, struct_parse_info->struct_types, ix, x)
+ FOR_EACH_VEC_ELT (struct_parse_info->struct_types, ix, x)
C_TYPE_DEFINED_IN_STRUCT (x) = 1;
/* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
@@ -7037,14 +7030,14 @@ warn_cxx_compat_finish_struct (tree fieldlist)
not parse in C++, because the C++ lookup rules say that the
typedef name would be looked up in the context of the struct, and
would thus be the field rather than the typedef. */
- if (!VEC_empty (tree, struct_parse_info->typedefs_seen)
+ if (!struct_parse_info->typedefs_seen.is_empty ()
&& fieldlist != NULL_TREE)
{
/* Use a pointer_set using the name of the typedef. We can use
a pointer_set because identifiers are interned. */
struct pointer_set_t *tset = pointer_set_create ();
- FOR_EACH_VEC_ELT (tree, struct_parse_info->typedefs_seen, ix, x)
+ FOR_EACH_VEC_ELT (struct_parse_info->typedefs_seen, ix, x)
pointer_set_insert (tset, DECL_NAME (x));
for (x = fieldlist; x != NULL_TREE; x = DECL_CHAIN (x))
@@ -7066,7 +7059,7 @@ warn_cxx_compat_finish_struct (tree fieldlist)
/* For each field which has a binding and which was not defined in
an enclosing struct, clear the in_struct field. */
- FOR_EACH_VEC_ELT (c_binding_ptr, struct_parse_info->fields, ix, b)
+ FOR_EACH_VEC_ELT (struct_parse_info->fields, ix, b)
b->in_struct = 0;
}
@@ -7353,9 +7346,9 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
if (warn_cxx_compat)
warn_cxx_compat_finish_struct (fieldlist);
- VEC_free (tree, heap, struct_parse_info->struct_types);
- VEC_free (c_binding_ptr, heap, struct_parse_info->fields);
- VEC_free (tree, heap, struct_parse_info->typedefs_seen);
+ struct_parse_info->struct_types.release ();
+ struct_parse_info->fields.release ();
+ struct_parse_info->typedefs_seen.release ();
XDELETE (struct_parse_info);
struct_parse_info = enclosing_struct_parse_info;
@@ -7365,7 +7358,7 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
if (warn_cxx_compat
&& struct_parse_info != NULL
&& !in_sizeof && !in_typeof && !in_alignof)
- VEC_safe_push (tree, heap, struct_parse_info->struct_types, t);
+ struct_parse_info->struct_types.safe_push (t);
return t;
}
@@ -7583,7 +7576,7 @@ finish_enum (tree enumtype, tree values, tree attributes)
if (warn_cxx_compat
&& struct_parse_info != NULL
&& !in_sizeof && !in_typeof && !in_alignof)
- VEC_safe_push (tree, heap, struct_parse_info->struct_types, enumtype);
+ struct_parse_info->struct_types.safe_push (enumtype);
return enumtype;
}
@@ -7981,7 +7974,7 @@ store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
}
/* And all the tag declarations. */
- FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
+ FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag)
if (tag->id)
bind (tag->id, tag->type, current_scope,
/*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
@@ -8598,8 +8591,7 @@ c_push_function_context (void)
cfun->language = p = ggc_alloc_cleared_language_function ();
p->base.x_stmt_tree = c_stmt_tree;
- c_stmt_tree.x_cur_stmt_list
- = VEC_copy (tree, gc, c_stmt_tree.x_cur_stmt_list);
+ c_stmt_tree.x_cur_stmt_list = vec_safe_copy (c_stmt_tree.x_cur_stmt_list);
p->x_break_label = c_break_label;
p->x_cont_label = c_cont_label;
p->x_switch_stack = c_switch_stack;
@@ -9538,7 +9530,7 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
/* If we are parsing a struct, record that a struct field
used a typedef. */
if (warn_cxx_compat && struct_parse_info != NULL)
- VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
+ struct_parse_info->typedefs_seen.safe_push (type);
}
}
else if (TREE_CODE (type) == IDENTIFIER_NODE)
@@ -10040,7 +10032,7 @@ collect_all_refs (const char *source_file)
tree t;
unsigned i;
- FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+ FOR_EACH_VEC_ELT (*all_translation_units, i, t)
collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t)), source_file);
collect_ada_nodes (BLOCK_VARS (ext_block), source_file);
@@ -10056,7 +10048,7 @@ for_each_global_decl (void (*callback) (tree decl))
tree decl;
unsigned i;
- FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+ FOR_EACH_VEC_ELT (*all_translation_units, i, t)
{
decls = DECL_INITIAL (t);
for (decl = BLOCK_VARS (decls); decl; decl = TREE_CHAIN (decl))
@@ -10116,7 +10108,7 @@ c_write_global_declarations (void)
/* Process all file scopes in this compilation, and the external_scope,
through wrapup_global_declarations and check_global_declarations. */
- FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+ FOR_EACH_VEC_ELT (*all_translation_units, i, t)
c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
c_write_global_declarations_1 (BLOCK_VARS (ext_block));
@@ -10135,7 +10127,7 @@ c_write_global_declarations (void)
if (!seen_error ())
{
timevar_push (TV_SYMOUT);
- FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+ FOR_EACH_VEC_ELT (*all_translation_units, i, t)
c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
c_write_global_declarations_2 (BLOCK_VARS (ext_block));
timevar_pop (TV_SYMOUT);
@@ -1178,9 +1178,9 @@ static struct c_expr c_parser_transaction_expression (c_parser *, enum rid);
static tree c_parser_transaction_cancel (c_parser *);
static struct c_expr c_parser_expression (c_parser *);
static struct c_expr c_parser_expression_conv (c_parser *);
-static VEC(tree,gc) *c_parser_expr_list (c_parser *, bool, bool,
- VEC(tree,gc) **, location_t *,
- tree *);
+static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool,
+ vec<tree, va_gc> **, location_t *,
+ tree *);
static void c_parser_omp_construct (c_parser *);
static void c_parser_omp_threadprivate (c_parser *);
static void c_parser_omp_barrier (c_parser *);
@@ -3540,7 +3540,7 @@ c_parser_attributes (c_parser *parser)
|| c_parser_next_token_is (parser, CPP_KEYWORD))
{
tree attr, attr_name, attr_args;
- VEC(tree,gc) *expr_list;
+ vec<tree, va_gc> *expr_list;
if (c_parser_next_token_is (parser, CPP_COMMA))
{
c_parser_consume_token (parser);
@@ -6123,10 +6123,10 @@ c_parser_alignof_expression (c_parser *parser)
stores the arguments in CEXPR_LIST. */
static bool
c_parser_get_builtin_args (c_parser *parser, const char *bname,
- VEC(c_expr_t,gc) **ret_cexpr_list)
+ vec<c_expr_t, va_gc> **ret_cexpr_list)
{
location_t loc = c_parser_peek_token (parser)->location;
- VEC (c_expr_t,gc) *cexpr_list;
+ vec<c_expr_t, va_gc> *cexpr_list;
c_expr_t expr;
*ret_cexpr_list = NULL;
@@ -6145,7 +6145,7 @@ c_parser_get_builtin_args (c_parser *parser, const char *bname,
}
expr = c_parser_expr_no_commas (parser, NULL);
- cexpr_list = VEC_alloc (c_expr_t, gc, 1);
+ vec_alloc (cexpr_list, 1);
C_EXPR_APPEND (cexpr_list, expr);
while (c_parser_next_token_is (parser, CPP_COMMA))
{
@@ -6511,7 +6511,7 @@ c_parser_postfix_expression (c_parser *parser)
break;
case RID_CHOOSE_EXPR:
{
- VEC (c_expr_t, gc) *cexpr_list;
+ vec<c_expr_t, va_gc> *cexpr_list;
c_expr_t *e1_p, *e2_p, *e3_p;
tree c;
@@ -6524,7 +6524,7 @@ c_parser_postfix_expression (c_parser *parser)
break;
}
- if (VEC_length (c_expr_t, cexpr_list) != 3)
+ if (vec_safe_length (cexpr_list) != 3)
{
error_at (loc, "wrong number of arguments to "
"%<__builtin_choose_expr%>");
@@ -6532,9 +6532,9 @@ c_parser_postfix_expression (c_parser *parser)
break;
}
- e1_p = &VEC_index (c_expr_t, cexpr_list, 0);
- e2_p = &VEC_index (c_expr_t, cexpr_list, 1);
- e3_p = &VEC_index (c_expr_t, cexpr_list, 2);
+ e1_p = &(*cexpr_list)[0];
+ e2_p = &(*cexpr_list)[1];
+ e3_p = &(*cexpr_list)[2];
c = e1_p->value;
mark_exp_read (e2_p->value);
@@ -6594,7 +6594,7 @@ c_parser_postfix_expression (c_parser *parser)
break;
case RID_BUILTIN_COMPLEX:
{
- VEC(c_expr_t, gc) *cexpr_list;
+ vec<c_expr_t, va_gc> *cexpr_list;
c_expr_t *e1_p, *e2_p;
c_parser_consume_token (parser);
@@ -6606,7 +6606,7 @@ c_parser_postfix_expression (c_parser *parser)
break;
}
- if (VEC_length (c_expr_t, cexpr_list) != 2)
+ if (vec_safe_length (cexpr_list) != 2)
{
error_at (loc, "wrong number of arguments to "
"%<__builtin_complex%>");
@@ -6614,8 +6614,8 @@ c_parser_postfix_expression (c_parser *parser)
break;
}
- e1_p = &VEC_index (c_expr_t, cexpr_list, 0);
- e2_p = &VEC_index (c_expr_t, cexpr_list, 1);
+ e1_p = &(*cexpr_list)[0];
+ e2_p = &(*cexpr_list)[1];
mark_exp_read (e1_p->value);
if (TREE_CODE (e1_p->value) == EXCESS_PRECISION_EXPR)
@@ -6655,7 +6655,7 @@ c_parser_postfix_expression (c_parser *parser)
}
case RID_BUILTIN_SHUFFLE:
{
- VEC(c_expr_t,gc) *cexpr_list;
+ vec<c_expr_t, va_gc> *cexpr_list;
unsigned int i;
c_expr_t *p;
@@ -6668,21 +6668,21 @@ c_parser_postfix_expression (c_parser *parser)
break;
}
- FOR_EACH_VEC_ELT (c_expr_t, cexpr_list, i, p)
+ FOR_EACH_VEC_SAFE_ELT (cexpr_list, i, p)
mark_exp_read (p->value);
- if (VEC_length (c_expr_t, cexpr_list) == 2)
+ if (vec_safe_length (cexpr_list) == 2)
expr.value =
c_build_vec_perm_expr
- (loc, VEC_index (c_expr_t, cexpr_list, 0).value,
- NULL_TREE, VEC_index (c_expr_t, cexpr_list, 1).value);
+ (loc, (*cexpr_list)[0].value,
+ NULL_TREE, (*cexpr_list)[1].value);
- else if (VEC_length (c_expr_t, cexpr_list) == 3)
+ else if (vec_safe_length (cexpr_list) == 3)
expr.value =
c_build_vec_perm_expr
- (loc, VEC_index (c_expr_t, cexpr_list, 0).value,
- VEC_index (c_expr_t, cexpr_list, 1).value,
- VEC_index (c_expr_t, cexpr_list, 2).value);
+ (loc, (*cexpr_list)[0].value,
+ (*cexpr_list)[1].value,
+ (*cexpr_list)[2].value);
else
{
error_at (loc, "wrong number of arguments to "
@@ -6872,8 +6872,8 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
location_t sizeof_arg_loc[3];
tree sizeof_arg[3];
unsigned int i;
- VEC(tree,gc) *exprlist;
- VEC(tree,gc) *origtypes;
+ vec<tree, va_gc> *exprlist;
+ vec<tree, va_gc> *origtypes;
while (true)
{
location_t op_loc = c_parser_peek_token (parser)->location;
@@ -6922,7 +6922,7 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
&& DECL_FUNCTION_CODE (orig_expr.value) == BUILT_IN_CONSTANT_P)
expr.original_code = C_MAYBE_CONST_EXPR;
expr.original_type = NULL;
- if (exprlist != NULL)
+ if (exprlist)
{
release_tree_vector (exprlist);
release_tree_vector (origtypes);
@@ -7069,13 +7069,13 @@ c_parser_expression_conv (c_parser *parser)
nonempty-expr-list , assignment-expression
*/
-static VEC(tree,gc) *
+static vec<tree, va_gc> *
c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
- VEC(tree,gc) **p_orig_types, location_t *sizeof_arg_loc,
- tree *sizeof_arg)
+ vec<tree, va_gc> **p_orig_types,
+ location_t *sizeof_arg_loc, tree *sizeof_arg)
{
- VEC(tree,gc) *ret;
- VEC(tree,gc) *orig_types;
+ vec<tree, va_gc> *ret;
+ vec<tree, va_gc> *orig_types;
struct c_expr expr;
location_t loc = c_parser_peek_token (parser)->location;
location_t cur_sizeof_arg_loc = UNKNOWN_LOCATION;
@@ -7095,9 +7095,9 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
expr = default_function_array_read_conversion (loc, expr);
if (fold_p)
expr.value = c_fully_fold (expr.value, false, NULL);
- VEC_quick_push (tree, ret, expr.value);
- if (orig_types != NULL)
- VEC_quick_push (tree, orig_types, expr.original_type);
+ ret->quick_push (expr.value);
+ if (orig_types)
+ orig_types->quick_push (expr.original_type);
if (sizeof_arg != NULL
&& cur_sizeof_arg_loc != UNKNOWN_LOCATION
&& expr.original_code == SIZEOF_EXPR)
@@ -7119,9 +7119,9 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
expr = default_function_array_read_conversion (loc, expr);
if (fold_p)
expr.value = c_fully_fold (expr.value, false, NULL);
- VEC_safe_push (tree, gc, ret, expr.value);
- if (orig_types != NULL)
- VEC_safe_push (tree, gc, orig_types, expr.original_type);
+ vec_safe_push (ret, expr.value);
+ if (orig_types)
+ vec_safe_push (orig_types, expr.original_type);
if (++idx < 3
&& sizeof_arg != NULL
&& cur_sizeof_arg_loc != UNKNOWN_LOCATION
@@ -7131,7 +7131,7 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
sizeof_arg_loc[idx] = cur_sizeof_arg_loc;
}
}
- if (orig_types != NULL)
+ if (orig_types)
*p_orig_types = orig_types;
return ret;
}
@@ -8209,13 +8209,13 @@ static tree
c_parser_objc_keywordexpr (c_parser *parser)
{
tree ret;
- VEC(tree,gc) *expr_list = c_parser_expr_list (parser, true, true,
+ vec<tree, va_gc> *expr_list = c_parser_expr_list (parser, true, true,
NULL, NULL, NULL);
- if (VEC_length (tree, expr_list) == 1)
+ if (vec_safe_length (expr_list) == 1)
{
/* Just return the expression, remove a level of
indirection. */
- ret = VEC_index (tree, expr_list, 0);
+ ret = (*expr_list)[0];
}
else
{
@@ -9923,7 +9923,7 @@ c_parser_omp_for_loop (location_t loc,
bool fail = false, open_brace_parsed = false;
int i, collapse = 1, nbraces = 0;
location_t for_loc;
- VEC(tree,gc) *for_block = make_tree_vector ();
+ vec<tree, va_gc> *for_block = make_tree_vector ();
for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
@@ -9955,7 +9955,7 @@ c_parser_omp_for_loop (location_t loc,
if (c_parser_next_tokens_start_declaration (parser))
{
if (i > 0)
- VEC_safe_push (tree, gc, for_block, c_begin_compound_stmt (true));
+ vec_safe_push (for_block, c_begin_compound_stmt (true));
c_parser_declaration_or_fndef (parser, true, true, true, true, true, NULL);
decl = check_for_loop_decls (for_loc, flag_isoc99);
if (decl == NULL)
@@ -10186,12 +10186,12 @@ c_parser_omp_for_loop (location_t loc,
ret = stmt;
}
pop_scopes:
- while (!VEC_empty (tree, for_block))
+ while (!for_block->is_empty ())
{
/* FIXME diagnostics: LOC below should be the actual location of
this particular for block. We need to build a list of
locations to go along with FOR_BLOCK. */
- stmt = c_end_compound_stmt (loc, VEC_pop (tree, for_block), true);
+ stmt = c_end_compound_stmt (loc, for_block->pop (), true);
add_stmt (stmt);
}
release_tree_vector (for_block);
@@ -135,15 +135,12 @@ struct c_expr
typedef struct c_expr c_expr_t;
/* A varray of c_expr_t. */
-DEF_VEC_O (c_expr_t);
-DEF_VEC_ALLOC_O (c_expr_t, gc);
-DEF_VEC_ALLOC_O (c_expr_t, heap);
/* Append a new c_expr_t element to V. */
#define C_EXPR_APPEND(V, ELEM) \
do { \
c_expr_t __elem = (ELEM); \
- VEC_safe_push (c_expr_t, gc, V, __elem); \
+ vec_safe_push (V, __elem); \
} while (0)
/* A kind of type specifier. Note that this information is currently
@@ -363,15 +360,13 @@ typedef struct c_arg_tag_d {
tree type;
} c_arg_tag;
-DEF_VEC_O(c_arg_tag);
-DEF_VEC_ALLOC_O(c_arg_tag,gc);
/* Information about the parameters in a function declarator. */
struct c_arg_info {
/* A list of parameter decls. */
tree parms;
/* A list of structure, union and enum tags defined. */
- VEC(c_arg_tag,gc) *tags;
+ vec<c_arg_tag, va_gc> *tags;
/* A list of argument types to go in the FUNCTION_TYPE. */
tree types;
/* A list of non-parameter decls (notably enumeration constants)
@@ -80,8 +80,8 @@ static int function_types_compatible_p (const_tree, const_tree, bool *,
bool *);
static int type_lists_compatible_p (const_tree, const_tree, bool *, bool *);
static tree lookup_field (tree, tree);
-static int convert_arguments (tree, VEC(tree,gc) *, VEC(tree,gc) *, tree,
- tree);
+static int convert_arguments (tree, vec<tree, va_gc> *, vec<tree, va_gc> *,
+ tree, tree);
static tree pointer_diff (location_t, tree, tree);
static tree convert_for_assignment (location_t, tree, tree, tree,
enum impl_conv, bool, tree, tree, int);
@@ -2662,14 +2662,14 @@ c_expr_sizeof_type (location_t loc, struct c_type_name *t)
tree
build_function_call (location_t loc, tree function, tree params)
{
- VEC(tree,gc) *vec;
+ vec<tree, va_gc> *v;
tree ret;
- vec = VEC_alloc (tree, gc, list_length (params));
+ vec_alloc (v, list_length (params));
for (; params; params = TREE_CHAIN (params))
- VEC_quick_push (tree, vec, TREE_VALUE (params));
- ret = build_function_call_vec (loc, function, vec, NULL);
- VEC_free (tree, gc, vec);
+ v->quick_push (TREE_VALUE (params));
+ ret = build_function_call_vec (loc, function, v, NULL);
+ vec_free (v);
return ret;
}
@@ -2690,8 +2690,9 @@ static void inform_declaration (tree decl)
PARAMS. */
tree
-build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
- VEC(tree,gc) *origtypes)
+build_function_call_vec (location_t loc, tree function,
+ vec<tree, va_gc> *params,
+ vec<tree, va_gc> *origtypes)
{
tree fntype, fundecl = 0;
tree name = NULL_TREE, result;
@@ -2729,9 +2730,8 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
/* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
expressions, like those used for ObjC messenger dispatches. */
- if (!VEC_empty (tree, params))
- function = objc_rewrite_function_call (function,
- VEC_index (tree, params, 0));
+ if (params && !params->is_empty ())
+ function = objc_rewrite_function_call (function, (*params)[0]);
function = c_fully_fold (function, false, NULL);
@@ -2800,8 +2800,7 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
/* Before the abort, allow the function arguments to exit or
call longjmp. */
for (i = 0; i < nargs; i++)
- trap = build2 (COMPOUND_EXPR, void_type_node,
- VEC_index (tree, params, i), trap);
+ trap = build2 (COMPOUND_EXPR, void_type_node, (*params)[i], trap);
if (VOID_TYPE_P (return_type))
{
@@ -2816,7 +2815,8 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
if (AGGREGATE_TYPE_P (return_type))
rhs = build_compound_literal (loc, return_type,
- build_constructor (return_type, 0),
+ build_constructor (return_type,
+ NULL),
false);
else
rhs = build_zero_cst (return_type);
@@ -2826,7 +2826,7 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
}
}
- argarray = VEC_address (tree, params);
+ argarray = vec_safe_address (params);
/* Check that arguments to builtin functions match the expectations. */
if (fundecl
@@ -2886,8 +2886,8 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
failure. */
static int
-convert_arguments (tree typelist, VEC(tree,gc) *values,
- VEC(tree,gc) *origtypes, tree function, tree fundecl)
+convert_arguments (tree typelist, vec<tree, va_gc> *values,
+ vec<tree, va_gc> *origtypes, tree function, tree fundecl)
{
tree typetail, val;
unsigned int parmnum;
@@ -2934,7 +2934,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
converted arguments. */
for (typetail = typelist, parmnum = 0;
- VEC_iterate (tree, values, parmnum, val);
+ values && values->iterate (parmnum, &val);
++parmnum)
{
tree type = typetail ? TREE_VALUE (typetail) : 0;
@@ -3127,9 +3127,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
sake of better warnings from convert_and_check. */
if (excess_precision)
val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
- origtype = (origtypes == NULL
- ? NULL_TREE
- : VEC_index (tree, origtypes, parmnum));
+ origtype = (!origtypes) ? NULL_TREE : (*origtypes)[parmnum];
parmval = convert_for_assignment (input_location, type, val,
origtype, ic_argpass, npc,
fundecl, function,
@@ -3173,7 +3171,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
/* Convert `short' and `char' to full-size `int'. */
parmval = default_conversion (val);
- VEC_replace (tree, values, parmnum, parmval);
+ (*values)[parmnum] = parmval;
if (parmval == error_mark_node)
error_args = true;
@@ -3181,7 +3179,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
typetail = TREE_CHAIN (typetail);
}
- gcc_assert (parmnum == VEC_length (tree, values));
+ gcc_assert (parmnum == vec_safe_length (values));
if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
{
@@ -6341,7 +6339,7 @@ static tree constructor_bit_index;
/* If we are saving up the elements rather than allocating them,
this is the list of elements so far (in reverse order,
most recent first). */
-static VEC(constructor_elt,gc) *constructor_elements;
+static vec<constructor_elt, va_gc> *constructor_elements;
/* 1 if constructor should be incrementally stored into a constructor chain,
0 if all the elements should be kept in AVL tree. */
@@ -6417,7 +6415,7 @@ struct constructor_stack
tree unfilled_index;
tree unfilled_fields;
tree bit_index;
- VEC(constructor_elt,gc) *elements;
+ vec<constructor_elt, va_gc> *elements;
struct init_node *pending_elts;
int offset;
int depth;
@@ -6462,7 +6460,7 @@ struct initializer_stack
tree decl;
struct constructor_stack *constructor_stack;
struct constructor_range_stack *constructor_range_stack;
- VEC(constructor_elt,gc) *elements;
+ vec<constructor_elt, va_gc> *elements;
struct spelling *spelling;
struct spelling *spelling_base;
int spelling_size;
@@ -6611,7 +6609,7 @@ really_start_incremental_init (tree type)
constructor_simple = 1;
constructor_nonconst = 0;
constructor_depth = SPELLING_DEPTH ();
- constructor_elements = 0;
+ constructor_elements = NULL;
constructor_pending_elts = 0;
constructor_type = type;
constructor_incremental = 1;
@@ -6757,7 +6755,7 @@ push_init_level (int implicit, struct obstack * braced_init_obstack)
constructor_simple = 1;
constructor_nonconst = 0;
constructor_depth = SPELLING_DEPTH ();
- constructor_elements = 0;
+ constructor_elements = NULL;
constructor_incremental = 1;
constructor_designated = 0;
constructor_pending_elts = 0;
@@ -6807,7 +6805,7 @@ push_init_level (int implicit, struct obstack * braced_init_obstack)
constructor_simple = TREE_STATIC (value);
constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
constructor_elements = CONSTRUCTOR_ELTS (value);
- if (!VEC_empty (constructor_elt, constructor_elements)
+ if (!vec_safe_is_empty (constructor_elements)
&& (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == ARRAY_TYPE))
set_nonincremental_init (braced_init_obstack);
@@ -6957,9 +6955,8 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack)
&& constructor_unfilled_fields)
{
bool constructor_zeroinit =
- (VEC_length (constructor_elt, constructor_elements) == 1
- && integer_zerop
- (VEC_index (constructor_elt, constructor_elements, 0).value));
+ (vec_safe_length (constructor_elements) == 1
+ && integer_zerop ((*constructor_elements)[0].value));
/* Do not warn for flexible array members or zero-length arrays. */
while (constructor_unfilled_fields
@@ -6997,19 +6994,19 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack)
{
/* A nonincremental scalar initializer--just return
the element, after verifying there is just one. */
- if (VEC_empty (constructor_elt,constructor_elements))
+ if (vec_safe_is_empty (constructor_elements))
{
if (!constructor_erroneous)
error_init ("empty scalar initializer");
ret.value = error_mark_node;
}
- else if (VEC_length (constructor_elt,constructor_elements) != 1)
+ else if (vec_safe_length (constructor_elements) != 1)
{
error_init ("extra elements in scalar initializer");
- ret.value = VEC_index (constructor_elt,constructor_elements,0).value;
+ ret.value = (*constructor_elements)[0].value;
}
else
- ret.value = VEC_index (constructor_elt,constructor_elements,0).value;
+ ret.value = (*constructor_elements)[0].value;
}
else
{
@@ -7534,7 +7531,7 @@ set_nonincremental_init (struct obstack * braced_init_obstack)
add_pending_init (index, value, NULL_TREE, true,
braced_init_obstack);
}
- constructor_elements = 0;
+ constructor_elements = NULL;
if (TREE_CODE (constructor_type) == RECORD_TYPE)
{
constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
@@ -7679,10 +7676,9 @@ find_init_member (tree field, struct obstack * braced_init_obstack)
}
else if (TREE_CODE (constructor_type) == UNION_TYPE)
{
- if (!VEC_empty (constructor_elt, constructor_elements)
- && (VEC_last (constructor_elt, constructor_elements).index
- == field))
- return VEC_last (constructor_elt, constructor_elements).value;
+ if (!vec_safe_is_empty (constructor_elements)
+ && (constructor_elements->last ().index == field))
+ return constructor_elements->last ().value;
}
return 0;
}
@@ -7859,12 +7855,11 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type,
return;
}
else if (TREE_CODE (constructor_type) == UNION_TYPE
- && !VEC_empty (constructor_elt, constructor_elements))
+ && !vec_safe_is_empty (constructor_elements))
{
if (!implicit)
{
- if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
- constructor_elements).value))
+ if (TREE_SIDE_EFFECTS (constructor_elements->last ().value))
warning_init (0,
"initialized field with side-effects overwritten");
else if (warn_override_init)
@@ -7872,14 +7867,14 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type,
}
/* We can have just one union field set. */
- constructor_elements = 0;
+ constructor_elements = NULL;
}
/* Otherwise, output this element either to
constructor_elements or to the assembler file. */
constructor_elt celt = {field, value};
- VEC_safe_push (constructor_elt, gc, constructor_elements, celt);
+ vec_safe_push (constructor_elements, celt);
/* Advance the variable that indicates sequential elements output. */
if (TREE_CODE (constructor_type) == ARRAY_TYPE)