diff options
Diffstat (limited to 'gcc/c')
| -rw-r--r-- | gcc/c/ChangeLog | 16 | ||||
| -rw-r--r-- | gcc/c/c-decl.c | 98 | ||||
| -rw-r--r-- | gcc/c/c-parser.c | 94 | ||||
| -rw-r--r-- | gcc/c/c-tree.h | 9 | ||||
| -rw-r--r-- | gcc/c/c-typeck.c | 89 |
5 files changed, 152 insertions, 154 deletions
diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index cd3a457..e6ef408 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,19 @@ +2012-11-16 Diego Novillo <dnovillo@google.com> + + 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. + 2012-10-29 Jonathan Wakely <jwakely.gcc@gmail.com> PR c++/54930 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<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); 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<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); 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<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) 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<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) |