From patchwork Thu Nov 15 21:53:31 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: VEC re-write [patch 05/25] From: Diego Novillo X-Patchwork-Id: 199443 Message-Id: <20121115215332.1BCBFC0916@torture.tor.corp.google.com> To: joseph@codesourcery.com, gcc-patches@gcc.gnu.org Date: Thu, 15 Nov 2012 16:53:31 -0500 2012-11-15 Diego Novillo Adjust for new vec API (http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec) * c-common.c: Use new vec API in vec.h. * c-common.h: Likewise. * c-gimplify.c: Likewise. * c-pragma.c: Likewise. * c-pretty-print.c: Likewise. * c-pretty-print.h: Likewise. * c-semantics.c: Likewise. * c-decl.c: Likewise. * c-parser.c: Likewise. * c-tree.h: Likewise. * c-typeck.c: Likewise. diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index 7828d21..fac7190 100644 --- a/gcc/c-family/c-common.c +++ b/gcc/c-family/c-common.c @@ -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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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_gc_vec; +static GTY((deletable)) vec *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 * 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 *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 *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 * make_tree_vector_single (tree t) { - VEC(tree,gc) *ret = make_tree_vector (); - VEC_quick_push (tree, ret, t); + vec *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 * make_tree_vector_from_list (tree list) { - VEC(tree,gc) *ret = make_tree_vector (); + vec *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 * +make_tree_vector_copy (const vec *orig) { - VEC(tree,gc) *ret; + vec *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; } diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index 5c545f2..afd8f07 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -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 *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 *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 *, 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 *, + vec *); -extern tree resolve_overloaded_builtin (location_t, tree, VEC(tree,gc) *); +extern tree resolve_overloaded_builtin (location_t, tree, vec *); 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 *make_tree_vector (void); +extern void release_tree_vector (vec *); +extern vec *make_tree_vector_single (tree); +extern vec *make_tree_vector_from_list (tree); +extern vec *make_tree_vector_copy (const vec *); /* In c-gimplify.c */ extern void c_genericize (tree); diff --git a/gcc/c-family/c-gimplify.c b/gcc/c-family/c-gimplify.c index 821c5d5..27814e1 100644 --- a/gcc/c-family/c-gimplify.c +++ b/gcc/c-family/c-gimplify.c @@ -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 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; diff --git a/gcc/c-family/c-pragma.c b/gcc/c-family/c-pragma.c index 70d8748e..f04cc6f 100644 --- a/gcc/c-family/c-pragma.c +++ b/gcc/c-family/c-pragma.c @@ -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_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_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 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 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 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; diff --git a/gcc/c-family/c-pretty-print.c b/gcc/c-family/c-pretty-print.c index edeccce..c8df1ac 100644 --- a/gcc/c-family/c-pretty-print.c +++ b/gcc/c-family/c-pretty-print.c @@ -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 *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, ','); } } diff --git a/gcc/c-family/c-pretty-print.h b/gcc/c-family/c-pretty-print.h index 2f9f94a..801663c 100644 --- a/gcc/c-family/c-pretty-print.h +++ b/gcc/c-family/c-pretty-print.h @@ -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 *); 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); diff --git a/gcc/c-family/c-semantics.c b/gcc/c-family/c-semantics.c index 1a21ec1..dca7ec9 100644 --- a/gcc/c-family/c-semantics.c +++ b/gcc/c-family/c-semantics.c @@ -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) diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c index f031466..b1c88bd 100644 --- a/gcc/c/c-decl.c +++ b/gcc/c/c-decl.c @@ -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 *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 *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 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 fields; /* If warn_cxx_compat, a list of typedef names used when defining fields in this struct. */ - VEC(tree,heap) *typedefs_seen; + vec 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 *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 *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); diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c index bfa98af..d85bff0 100644 --- a/gcc/c/c-parser.c +++ b/gcc/c/c-parser.c @@ -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 *c_parser_expr_list (c_parser *, bool, bool, + vec **, 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 *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 **ret_cexpr_list) { location_t loc = c_parser_peek_token (parser)->location; - VEC (c_expr_t,gc) *cexpr_list; + vec *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 *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 *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 *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 *exprlist; + vec *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 * 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 **p_orig_types, + location_t *sizeof_arg_loc, tree *sizeof_arg) { - VEC(tree,gc) *ret; - VEC(tree,gc) *orig_types; + vec *ret; + vec *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 *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 *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); diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h index 17fc719..531cc7c 100644 --- a/gcc/c/c-tree.h +++ b/gcc/c/c-tree.h @@ -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 *tags; /* A list of argument types to go in the FUNCTION_TYPE. */ tree types; /* A list of non-parameter decls (notably enumeration constants) diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c index cf63355..2032f66 100644 --- a/gcc/c/c-typeck.c +++ b/gcc/c/c-typeck.c @@ -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 *, vec *, + 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 *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 *params, + vec *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 *values, + vec *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_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 *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 *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)