diff options
Diffstat (limited to 'gcc/ada/gcc-interface')
| -rw-r--r-- | gcc/ada/gcc-interface/decl.c | 84 | ||||
| -rw-r--r-- | gcc/ada/gcc-interface/gigi.h | 2 | ||||
| -rw-r--r-- | gcc/ada/gcc-interface/trans.c | 190 | ||||
| -rw-r--r-- | gcc/ada/gcc-interface/utils.c | 108 | ||||
| -rw-r--r-- | gcc/ada/gcc-interface/utils2.c | 29 |
5 files changed, 198 insertions, 215 deletions
diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index dfefff2..b3cf22c 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -106,8 +106,6 @@ typedef struct subst_pair_d { tree replacement; } subst_pair; -DEF_VEC_O(subst_pair); -DEF_VEC_ALLOC_O(subst_pair,heap); typedef struct variant_desc_d { /* The type of the variant. */ @@ -123,8 +121,6 @@ typedef struct variant_desc_d { tree new_type; } variant_desc; -DEF_VEC_O(variant_desc); -DEF_VEC_ALLOC_O(variant_desc,heap); /* A hash table used to cache the result of annotate_value. */ static GTY ((if_marked ("tree_int_map_marked_p"), @@ -153,21 +149,21 @@ static void components_to_record (tree, Node_Id, tree, int, bool, bool, bool, static Uint annotate_value (tree); static void annotate_rep (Entity_Id, tree); static tree build_position_list (tree, bool, tree, tree, unsigned int, tree); -static VEC(subst_pair,heap) *build_subst_list (Entity_Id, Entity_Id, bool); -static VEC(variant_desc,heap) *build_variant_list (tree, - VEC(subst_pair,heap) *, - VEC(variant_desc,heap) *); +static vec<subst_pair> build_subst_list (Entity_Id, Entity_Id, bool); +static vec<variant_desc> build_variant_list (tree, + vec<subst_pair> , + vec<variant_desc> ); static tree validate_size (Uint, tree, Entity_Id, enum tree_code, bool, bool); static void set_rm_size (Uint, tree, Entity_Id); static unsigned int validate_alignment (Uint, Entity_Id, unsigned int); static void check_ok_for_atomic (tree, Entity_Id, bool); static tree create_field_decl_from (tree, tree, tree, tree, tree, - VEC(subst_pair,heap) *); + vec<subst_pair> ); static tree create_rep_part (tree, tree, tree); static tree get_rep_part (tree); -static tree create_variant_part_from (tree, VEC(variant_desc,heap) *, tree, - tree, VEC(subst_pair,heap) *); -static void copy_and_substitute_in_size (tree, tree, VEC(subst_pair,heap) *); +static tree create_variant_part_from (tree, vec<variant_desc> , tree, + tree, vec<subst_pair> ); +static void copy_and_substitute_in_size (tree, tree, vec<subst_pair> ); /* The relevant constituents of a subprogram binding to a GCC builtin. Used to pass around calls performing profile compatibility checks. */ @@ -1157,7 +1153,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) = TYPE_PADDING_P (gnu_type) ? TYPE_FIELDS (TREE_TYPE (TYPE_FIELDS (gnu_type))) : TYPE_FIELDS (gnu_type); - VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 1); + vec<constructor_elt, va_gc> *v; + vec_alloc (v, 1); tree t = build_template (TREE_TYPE (template_field), TREE_TYPE (DECL_CHAIN (template_field)), NULL_TREE); @@ -1329,8 +1326,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) = TREE_TYPE (DECL_CHAIN (TYPE_FIELDS (gnu_alloc_type))); if (TREE_CODE (gnu_expr) == CONSTRUCTOR - && 1 == VEC_length (constructor_elt, - CONSTRUCTOR_ELTS (gnu_expr))) + && 1 == vec_safe_length (CONSTRUCTOR_ELTS (gnu_expr))) gnu_expr = 0; else gnu_expr @@ -3293,13 +3289,13 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) && Present (Discriminant_Constraint (gnat_entity)) && Stored_Constraint (gnat_entity) != No_Elist) { - VEC(subst_pair,heap) *gnu_subst_list + vec<subst_pair> gnu_subst_list = build_subst_list (gnat_entity, gnat_base_type, definition); tree gnu_unpad_base_type, gnu_rep_part, gnu_variant_part, t; tree gnu_pos_list, gnu_field_list = NULL_TREE; bool selected_variant = false; Entity_Id gnat_field; - VEC(variant_desc,heap) *gnu_variant_list; + vec<variant_desc> gnu_variant_list; gnu_type = make_node (RECORD_TYPE); TYPE_NAME (gnu_type) = gnu_entity_name; @@ -3330,12 +3326,13 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) gnu_variant_list = build_variant_list (TREE_TYPE (gnu_variant_part), - gnu_subst_list, NULL); + gnu_subst_list, + vec<variant_desc>()); /* If all the qualifiers are unconditionally true, the innermost variant is statically selected. */ selected_variant = true; - FOR_EACH_VEC_ELT (variant_desc, gnu_variant_list, i, v) + FOR_EACH_VEC_ELT (gnu_variant_list, i, v) if (!integer_onep (v->qual)) { selected_variant = false; @@ -3344,7 +3341,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) /* Otherwise, create the new variants. */ if (!selected_variant) - FOR_EACH_VEC_ELT (variant_desc, gnu_variant_list, i, v) + FOR_EACH_VEC_ELT (gnu_variant_list, i, v) { tree old_variant = v->type; tree new_variant = make_node (RECORD_TYPE); @@ -3362,13 +3359,14 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) } else { - gnu_variant_list = NULL; + gnu_variant_list.create (0); selected_variant = false; } gnu_pos_list = build_position_list (gnu_unpad_base_type, - gnu_variant_list && !selected_variant, + gnu_variant_list.exists () + && !selected_variant, size_zero_node, bitsize_zero_node, BIGGEST_ALIGNMENT, NULL_TREE); @@ -3449,7 +3447,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) unsigned int i; t = NULL_TREE; - FOR_EACH_VEC_ELT (variant_desc, gnu_variant_list, i, v) + FOR_EACH_VEC_ELT (gnu_variant_list, i, v) if (gnu_context == v->type || ((gnu_rep_part = get_rep_part (v->type)) && gnu_context == TREE_TYPE (gnu_rep_part))) @@ -3515,7 +3513,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) /* If there is a variant list and no selected variant, we need to create the nest of variant parts from the old nest. */ - if (gnu_variant_list && !selected_variant) + if (gnu_variant_list.exists () && !selected_variant) { tree new_variant_part = create_variant_part_from (gnu_variant_part, @@ -3587,8 +3585,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) gnat_entity); } - VEC_free (variant_desc, heap, gnu_variant_list); - VEC_free (subst_pair, heap, gnu_subst_list); + gnu_variant_list.release (); + gnu_subst_list.release (); /* Now we can finalize it. */ rest_of_record_type_compilation (gnu_type); @@ -7551,10 +7549,10 @@ build_position_list (tree gnu_type, bool do_not_flatten_variant, tree gnu_pos, of operands to SUBSTITUTE_IN_EXPR. DEFINITION is true if this is for a definition of GNAT_SUBTYPE. */ -static VEC(subst_pair,heap) * +static vec<subst_pair> build_subst_list (Entity_Id gnat_subtype, Entity_Id gnat_type, bool definition) { - VEC(subst_pair,heap) *gnu_list = NULL; + vec<subst_pair> gnu_list = vec<subst_pair>(); Entity_Id gnat_discrim; Node_Id gnat_value; @@ -7573,7 +7571,7 @@ build_subst_list (Entity_Id gnat_subtype, Entity_Id gnat_type, bool definition) get_entity_name (gnat_discrim), definition, true, false)); subst_pair s = {gnu_field, replacement}; - VEC_safe_push (subst_pair, heap, gnu_list, s); + gnu_list.safe_push (s); } return gnu_list; @@ -7584,9 +7582,9 @@ build_subst_list (Entity_Id gnat_subtype, Entity_Id gnat_type, bool definition) the substitutions described in SUBST_LIST. GNU_LIST is a pre-existing list to be prepended to the newly created entries. */ -static VEC(variant_desc,heap) * -build_variant_list (tree qual_union_type, VEC(subst_pair,heap) *subst_list, - VEC(variant_desc,heap) *gnu_list) +static vec<variant_desc> +build_variant_list (tree qual_union_type, vec<subst_pair> subst_list, + vec<variant_desc> gnu_list) { tree gnu_field; @@ -7598,7 +7596,7 @@ build_variant_list (tree qual_union_type, VEC(subst_pair,heap) *subst_list, unsigned int i; subst_pair *s; - FOR_EACH_VEC_ELT (subst_pair, subst_list, i, s) + FOR_EACH_VEC_ELT (subst_list, i, s) qual = SUBSTITUTE_IN_EXPR (qual, s->discriminant, s->replacement); /* If the new qualifier is not unconditionally false, its variant may @@ -7608,7 +7606,7 @@ build_variant_list (tree qual_union_type, VEC(subst_pair,heap) *subst_list, tree variant_type = TREE_TYPE (gnu_field), variant_subpart; variant_desc v = {variant_type, gnu_field, qual, NULL_TREE}; - VEC_safe_push (variant_desc, heap, gnu_list, v); + gnu_list.safe_push (v); /* Recurse on the variant subpart of the variant, if any. */ variant_subpart = get_variant_part (variant_type); @@ -8170,7 +8168,7 @@ intrin_profiles_compatible_p (intrin_binding_t * inb) static tree create_field_decl_from (tree old_field, tree field_type, tree record_type, tree size, tree pos_list, - VEC(subst_pair,heap) *subst_list) + vec<subst_pair> subst_list) { tree t = TREE_VALUE (purpose_member (old_field, pos_list)); tree pos = TREE_VEC_ELT (t, 0), bitpos = TREE_VEC_ELT (t, 2); @@ -8180,7 +8178,7 @@ create_field_decl_from (tree old_field, tree field_type, tree record_type, subst_pair *s; if (CONTAINS_PLACEHOLDER_P (pos)) - FOR_EACH_VEC_ELT (subst_pair, subst_list, i, s) + FOR_EACH_VEC_ELT (subst_list, i, s) pos = SUBSTITUTE_IN_EXPR (pos, s->discriminant, s->replacement); /* If the position is now a constant, we can set it as the position of the @@ -8276,9 +8274,9 @@ get_variant_part (tree record_type) static tree create_variant_part_from (tree old_variant_part, - VEC(variant_desc,heap) *variant_list, + vec<variant_desc> variant_list, tree record_type, tree pos_list, - VEC(subst_pair,heap) *subst_list) + vec<subst_pair> subst_list) { tree offset = DECL_FIELD_OFFSET (old_variant_part); tree old_union_type = TREE_TYPE (old_variant_part); @@ -8315,7 +8313,7 @@ create_variant_part_from (tree old_variant_part, copy_and_substitute_in_size (new_union_type, old_union_type, subst_list); /* Now finish up the new variants and populate the union type. */ - FOR_EACH_VEC_ELT_REVERSE (variant_desc, variant_list, i, v) + FOR_EACH_VEC_ELT_REVERSE (variant_list, i, v) { tree old_field = v->field, new_field; tree old_variant, old_variant_subpart, new_variant, field_list; @@ -8397,7 +8395,7 @@ create_variant_part_from (tree old_variant_part, static void copy_and_substitute_in_size (tree new_type, tree old_type, - VEC(subst_pair,heap) *subst_list) + vec<subst_pair> subst_list) { unsigned int i; subst_pair *s; @@ -8409,19 +8407,19 @@ copy_and_substitute_in_size (tree new_type, tree old_type, relate_alias_sets (new_type, old_type, ALIAS_SET_COPY); if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (new_type))) - FOR_EACH_VEC_ELT (subst_pair, subst_list, i, s) + FOR_EACH_VEC_ELT (subst_list, i, s) TYPE_SIZE (new_type) = SUBSTITUTE_IN_EXPR (TYPE_SIZE (new_type), s->discriminant, s->replacement); if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (new_type))) - FOR_EACH_VEC_ELT (subst_pair, subst_list, i, s) + FOR_EACH_VEC_ELT (subst_list, i, s) TYPE_SIZE_UNIT (new_type) = SUBSTITUTE_IN_EXPR (TYPE_SIZE_UNIT (new_type), s->discriminant, s->replacement); if (CONTAINS_PLACEHOLDER_P (TYPE_ADA_SIZE (new_type))) - FOR_EACH_VEC_ELT (subst_pair, subst_list, i, s) + FOR_EACH_VEC_ELT (subst_list, i, s) SET_TYPE_ADA_SIZE (new_type, SUBSTITUTE_IN_EXPR (TYPE_ADA_SIZE (new_type), s->discriminant, s->replacement)); diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h index d4a8176..1d0d2fb 100644 --- a/gcc/ada/gcc-interface/gigi.h +++ b/gcc/ada/gcc-interface/gigi.h @@ -884,7 +884,7 @@ extern tree build_call_raise_column (int msg, Node_Id gnat_node); /* Return a CONSTRUCTOR of TYPE whose elements are V. This is not the same as build_constructor in the language-independent tree.c. */ -extern tree gnat_build_constructor (tree type, VEC(constructor_elt,gc) *v); +extern tree gnat_build_constructor (tree type, vec<constructor_elt, va_gc> *v); /* Return a COMPONENT_REF to access a field that is given by COMPONENT, an IDENTIFIER_NODE giving the name of the field, FIELD, a FIELD_DECL, diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c index dbc4689..2b23627 100644 --- a/gcc/ada/gcc-interface/trans.c +++ b/gcc/ada/gcc-interface/trans.c @@ -110,11 +110,9 @@ bool type_annotate_only; /* Current filename without path. */ const char *ref_filename; -DEF_VEC_I(Node_Id); -DEF_VEC_ALLOC_I(Node_Id,heap); /* List of N_Validate_Unchecked_Conversion nodes in the unit. */ -static VEC(Node_Id,heap) *gnat_validate_uc_list; +static vec<Node_Id> gnat_validate_uc_list; /* When not optimizing, we cache the 'First, 'Last and 'Length attributes of unconstrained array IN parameters to avoid emitting a great deal of @@ -129,13 +127,11 @@ struct GTY (()) parm_attr_d { typedef struct parm_attr_d *parm_attr; -DEF_VEC_P(parm_attr); -DEF_VEC_ALLOC_P(parm_attr,gc); struct GTY(()) language_function { - VEC(parm_attr,gc) *parm_attr_cache; + vec<parm_attr, va_gc> *parm_attr_cache; bitmap named_ret_val; - VEC(tree,gc) *other_ret_val; + vec<tree, va_gc> *other_ret_val; int gnat_ret; }; @@ -184,21 +180,21 @@ static GTY(()) struct elab_info *elab_info_list; /* Stack of exception pointer variables. Each entry is the VAR_DECL that stores the address of the raised exception. Nonzero means we are in an exception handler. Not used in the zero-cost case. */ -static GTY(()) VEC(tree,gc) *gnu_except_ptr_stack; +static GTY(()) vec<tree, va_gc> *gnu_except_ptr_stack; /* In ZCX case, current exception pointer. Used to re-raise it. */ static GTY(()) tree gnu_incoming_exc_ptr; /* Stack for storing the current elaboration procedure decl. */ -static GTY(()) VEC(tree,gc) *gnu_elab_proc_stack; +static GTY(()) vec<tree, va_gc> *gnu_elab_proc_stack; /* Stack of labels to be used as a goto target instead of a return in some functions. See processing for N_Subprogram_Body. */ -static GTY(()) VEC(tree,gc) *gnu_return_label_stack; +static GTY(()) vec<tree, va_gc> *gnu_return_label_stack; /* Stack of variable for the return value of a function with copy-in/copy-out parameters. See processing for N_Subprogram_Body. */ -static GTY(()) VEC(tree,gc) *gnu_return_var_stack; +static GTY(()) vec<tree, va_gc> *gnu_return_var_stack; /* Structure used to record information for a range check. */ struct GTY(()) range_check_info_d { @@ -210,28 +206,24 @@ struct GTY(()) range_check_info_d { typedef struct range_check_info_d *range_check_info; -DEF_VEC_P(range_check_info); -DEF_VEC_ALLOC_P(range_check_info,gc); /* Structure used to record information for a loop. */ struct GTY(()) loop_info_d { tree label; tree loop_var; - VEC(range_check_info,gc) *checks; + vec<range_check_info, va_gc> *checks; }; typedef struct loop_info_d *loop_info; -DEF_VEC_P(loop_info); -DEF_VEC_ALLOC_P(loop_info,gc); /* Stack of loop_info structures associated with LOOP_STMT nodes. */ -static GTY(()) VEC(loop_info,gc) *gnu_loop_stack; +static GTY(()) vec<loop_info, va_gc> *gnu_loop_stack; /* The stacks for N_{Push,Pop}_*_Label. */ -static GTY(()) VEC(tree,gc) *gnu_constraint_error_label_stack; -static GTY(()) VEC(tree,gc) *gnu_storage_error_label_stack; -static GTY(()) VEC(tree,gc) *gnu_program_error_label_stack; +static GTY(()) vec<tree, va_gc> *gnu_constraint_error_label_stack; +static GTY(()) vec<tree, va_gc> *gnu_storage_error_label_stack; +static GTY(()) vec<tree, va_gc> *gnu_program_error_label_stack; /* Map GNAT tree codes to GCC tree codes for simple expressions. */ static enum tree_code gnu_codes[Number_Node_Kinds]; @@ -242,7 +234,7 @@ static void record_code_position (Node_Id); static void insert_code_for (Node_Id); static void add_cleanup (tree, Node_Id); static void add_stmt_list (List_Id); -static void push_exception_label_stack (VEC(tree,gc) **, Entity_Id); +static void push_exception_label_stack (vec<tree, va_gc> **, Entity_Id); static tree build_stmt_group (List_Id, bool); static inline bool stmt_group_may_fallthru (void); static enum gimplify_status gnat_gimplify_stmt (tree *); @@ -588,14 +580,12 @@ gigi (Node_Id gnat_root, int max_gnat_node, int number_name ATTRIBUTE_UNUSED, tree null_node = fold_convert (ptr_void_ftype, null_pointer_node); tree field_list = NULL_TREE; int j; - VEC(constructor_elt,gc) *null_vec = NULL; + vec<constructor_elt, va_gc> *null_vec = NULL; constructor_elt *elt; fdesc_type_node = make_node (RECORD_TYPE); - VEC_safe_grow (constructor_elt, gc, null_vec, - TARGET_VTABLE_USES_DESCRIPTORS); - elt = (VEC_address (constructor_elt,null_vec) - + TARGET_VTABLE_USES_DESCRIPTORS - 1); + vec_safe_grow (null_vec, TARGET_VTABLE_USES_DESCRIPTORS); + elt = (null_vec->address () + TARGET_VTABLE_USES_DESCRIPTORS - 1); for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; j++) { @@ -651,10 +641,10 @@ gigi (Node_Id gnat_root, int max_gnat_node, int number_name ATTRIBUTE_UNUSED, user available facilities for Intrinsic imports. */ gnat_install_builtins (); - VEC_safe_push (tree, gc, gnu_except_ptr_stack, NULL_TREE); - VEC_safe_push (tree, gc, gnu_constraint_error_label_stack, NULL_TREE); - VEC_safe_push (tree, gc, gnu_storage_error_label_stack, NULL_TREE); - VEC_safe_push (tree, gc, gnu_program_error_label_stack, NULL_TREE); + vec_safe_push (gnu_except_ptr_stack, NULL_TREE); + vec_safe_push (gnu_constraint_error_label_stack, NULL_TREE); + vec_safe_push (gnu_storage_error_label_stack, NULL_TREE); + vec_safe_push (gnu_program_error_label_stack, NULL_TREE); /* Process any Pragma Ident for the main unit. */ if (Present (Ident_String (Main_Unit))) @@ -671,9 +661,9 @@ gigi (Node_Id gnat_root, int max_gnat_node, int number_name ATTRIBUTE_UNUSED, /* Then process the N_Validate_Unchecked_Conversion nodes. We do this at the very end to avoid having to second-guess the front-end when we run into dummy nodes during the regular processing. */ - for (i = 0; VEC_iterate (Node_Id, gnat_validate_uc_list, i, gnat_iter); i++) + for (i = 0; gnat_validate_uc_list.iterate (i, &gnat_iter); i++) validate_unchecked_conversion (gnat_iter); - VEC_free (Node_Id, heap, gnat_validate_uc_list); + gnat_validate_uc_list.release (); /* Finally see if we have any elaboration procedures to deal with. */ for (info = elab_info_list; info; info = info->next) @@ -1367,7 +1357,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute) /* Descriptors can only be built here for top-level functions. */ bool build_descriptor = (global_bindings_p () != 0); int i; - VEC(constructor_elt,gc) *gnu_vec = NULL; + vec<constructor_elt, va_gc> *gnu_vec = NULL; constructor_elt *elt; gnu_result_type = get_unpadded_type (Etype (gnat_node)); @@ -1383,10 +1373,8 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute) gnu_result = build1 (INDIRECT_REF, gnu_result_type, gnu_result); } - VEC_safe_grow (constructor_elt, gc, gnu_vec, - TARGET_VTABLE_USES_DESCRIPTORS); - elt = (VEC_address (constructor_elt, gnu_vec) - + TARGET_VTABLE_USES_DESCRIPTORS - 1); + vec_safe_grow (gnu_vec, TARGET_VTABLE_USES_DESCRIPTORS); + elt = (gnu_vec->address () + TARGET_VTABLE_USES_DESCRIPTORS - 1); for (gnu_field = TYPE_FIELDS (gnu_result_type), i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; gnu_field = DECL_CHAIN (gnu_field), i++) @@ -1739,7 +1727,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute) and the dimension in the cache and create a new one on failure. */ if (!optimize && Present (gnat_param)) { - FOR_EACH_VEC_ELT (parm_attr, f_parm_attr_cache, i, pa) + FOR_EACH_VEC_SAFE_ELT (f_parm_attr_cache, i, pa) if (pa->id == gnat_param && pa->dim == Dimension) break; @@ -1748,7 +1736,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute) pa = ggc_alloc_cleared_parm_attr_d (); pa->id = gnat_param; pa->dim = Dimension; - VEC_safe_push (parm_attr, gc, f_parm_attr_cache, pa); + vec_safe_push (f_parm_attr_cache, pa); } } @@ -2210,7 +2198,7 @@ push_range_check_info (tree var) struct loop_info_d *iter = NULL; unsigned int i; - if (VEC_empty (loop_info, gnu_loop_stack)) + if (vec_safe_is_empty (gnu_loop_stack)) return NULL; var = remove_conversions (var, false); @@ -2221,8 +2209,8 @@ push_range_check_info (tree var) if (decl_function_context (var) != current_function_decl) return NULL; - for (i = VEC_length (loop_info, gnu_loop_stack) - 1; - VEC_iterate (loop_info, gnu_loop_stack, i, iter); + for (i = vec_safe_length (gnu_loop_stack) - 1; + vec_safe_iterate (gnu_loop_stack, i, &iter); i--) if (var == iter->loop_var) break; @@ -2230,7 +2218,7 @@ push_range_check_info (tree var) if (iter) { struct range_check_info_d *rci = ggc_alloc_range_check_info_d (); - VEC_safe_push (range_check_info, gc, iter->checks, rci); + vec_safe_push (iter->checks, rci); return rci; } @@ -2312,7 +2300,7 @@ Loop_Statement_to_gnu (Node_Id gnat_node) tree gnu_result; /* Push the loop_info structure associated with the LOOP_STMT. */ - VEC_safe_push (loop_info, gc, gnu_loop_stack, gnu_loop_info); + vec_safe_push (gnu_loop_stack, gnu_loop_info); /* Set location information for statement and end label. */ set_expr_location_from_node (gnu_loop_stmt, gnat_node); @@ -2576,7 +2564,7 @@ Loop_Statement_to_gnu (Node_Id gnat_node) if (Present (gnat_iter_scheme) && No (Condition (gnat_iter_scheme))) { struct range_check_info_d *rci; - unsigned n_checks = VEC_length (range_check_info, gnu_loop_info->checks); + unsigned n_checks = vec_safe_length (gnu_loop_info->checks); unsigned int i; /* First, if we have computed a small number of invariant conditions for @@ -2593,7 +2581,7 @@ Loop_Statement_to_gnu (Node_Id gnat_node) that can be entirely optimized away in the end. */ if (1 <= n_checks && n_checks <= 4) for (i = 0; - VEC_iterate (range_check_info, gnu_loop_info->checks, i, rci); + vec_safe_iterate (gnu_loop_info->checks, i, &rci); i++) { tree low_ok @@ -2636,7 +2624,7 @@ Loop_Statement_to_gnu (Node_Id gnat_node) else gnu_result = gnu_loop_stmt; - VEC_pop (loop_info, gnu_loop_stack); + gnu_loop_stack->pop (); return gnu_result; } @@ -2928,10 +2916,8 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) { if (TYPE_IS_FAT_POINTER_P (TREE_TYPE (ret_val))) ret_val - = VEC_index (constructor_elt, - CONSTRUCTOR_ELTS - (TREE_OPERAND (TREE_OPERAND (ret_val, 0), 1)), - 1).value; + = (*CONSTRUCTOR_ELTS (TREE_OPERAND (TREE_OPERAND (ret_val, 0), + 1)))[1].value; else ret_val = TREE_OPERAND (TREE_OPERAND (ret_val, 0), 1); } @@ -2960,7 +2946,8 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) tree saved_current_function_decl = current_function_decl; tree var = DECL_EXPR_DECL (t); tree alloc, p_array, new_var, new_ret; - VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 2); + vec<constructor_elt, va_gc> *v; + vec_alloc (v, 2); /* Create an artificial context to build the allocation. */ current_function_decl = decl_function_context (var); @@ -2988,19 +2975,15 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) DECL_INITIAL (new_var) = build2 (COMPOUND_EXPR, TREE_TYPE (new_var), TREE_OPERAND (alloc, 0), - VEC_index (constructor_elt, - CONSTRUCTOR_ELTS (TREE_OPERAND (alloc, 1)), - 0).value); + (*CONSTRUCTOR_ELTS (TREE_OPERAND (alloc, 1)))[0].value); /* Build a modified CONSTRUCTOR that references NEW_VAR. */ p_array = TYPE_FIELDS (TREE_TYPE (alloc)); CONSTRUCTOR_APPEND_ELT (v, p_array, fold_convert (TREE_TYPE (p_array), new_var)); CONSTRUCTOR_APPEND_ELT (v, DECL_CHAIN (p_array), - VEC_index (constructor_elt, - CONSTRUCTOR_ELTS - (TREE_OPERAND (alloc, 1)), - 1).value); + (*CONSTRUCTOR_ELTS ( + TREE_OPERAND (alloc, 1)))[1].value); new_ret = build_constructor (TREE_TYPE (alloc), v); } else @@ -3048,7 +3031,7 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) the other return values. GNAT_RET is a representative return node. */ static void -finalize_nrv (tree fndecl, bitmap nrv, VEC(tree,gc) *other, Node_Id gnat_ret) +finalize_nrv (tree fndecl, bitmap nrv, vec<tree, va_gc> *other, Node_Id gnat_ret) { struct cgraph_node *node; struct nrv_data data; @@ -3064,7 +3047,7 @@ finalize_nrv (tree fndecl, bitmap nrv, VEC(tree,gc) *other, Node_Id gnat_ret) data.nrv = nrv; data.result = NULL_TREE; data.visited = NULL; - for (i = 0; VEC_iterate(tree, other, i, iter); i++) + for (i = 0; vec_safe_iterate (other, i, &iter); i++) walk_tree_without_duplicates (&iter, prune_nrv_r, &data); if (bitmap_empty_p (nrv)) return; @@ -3186,7 +3169,7 @@ build_return_expr (tree ret_obj, tree ret_val) totally transparent given the read-compose-write semantics of assignments from CONSTRUCTORs. */ else if (EXPR_P (ret_val)) - VEC_safe_push (tree, gc, f_other_ret_val, ret_val); + vec_safe_push (f_other_ret_val, ret_val); } } else @@ -3204,7 +3187,7 @@ build_function_stub (tree gnu_subprog, Entity_Id gnat_subprog) tree gnu_subprog_type, gnu_subprog_addr, gnu_subprog_call; tree gnu_subprog_param, gnu_stub_param, gnu_param; tree gnu_stub_decl = DECL_FUNCTION_STUB (gnu_subprog); - VEC(tree,gc) *gnu_param_vec = NULL; + vec<tree, va_gc> *gnu_param_vec = NULL; gnu_subprog_type = TREE_TYPE (gnu_subprog); @@ -3238,7 +3221,7 @@ build_function_stub (tree gnu_subprog, Entity_Id gnat_subprog) else gnu_param = gnu_stub_param; - VEC_safe_push (tree, gc, gnu_param_vec, gnu_param); + vec_safe_push (gnu_param_vec, gnu_param); } /* Invoke the internal subprogram. */ @@ -3286,7 +3269,7 @@ Subprogram_Body_to_gnu (Node_Id gnat_node) tree gnu_return_var_elmt = NULL_TREE; tree gnu_result; struct language_function *gnu_subprog_language; - VEC(parm_attr,gc) *cache; + vec<parm_attr, va_gc> *cache; /* If this is a generic object or if it has been eliminated, ignore it. */ @@ -3340,7 +3323,7 @@ Subprogram_Body_to_gnu (Node_Id gnat_node) { tree gnu_return_var = NULL_TREE; - VEC_safe_push (tree, gc, gnu_return_label_stack, + vec_safe_push (gnu_return_label_stack, create_artificial_label (input_location)); start_stmt_group (); @@ -3366,7 +3349,7 @@ Subprogram_Body_to_gnu (Node_Id gnat_node) TREE_VALUE (gnu_return_var_elmt) = gnu_return_var; } - VEC_safe_push (tree, gc, gnu_return_var_stack, gnu_return_var); + vec_safe_push (gnu_return_var_stack, gnu_return_var); /* See whether there are parameters for which we don't have a GCC tree yet. These must be Out parameters. Make a VAR_DECL for them and @@ -3392,7 +3375,7 @@ Subprogram_Body_to_gnu (Node_Id gnat_node) } } else - VEC_safe_push (tree, gc, gnu_return_label_stack, NULL_TREE); + vec_safe_push (gnu_return_label_stack, NULL_TREE); /* Get a tree corresponding to the code for the subprogram. */ start_stmt_group (); @@ -3433,7 +3416,7 @@ Subprogram_Body_to_gnu (Node_Id gnat_node) start_stmt_group (); - FOR_EACH_VEC_ELT (parm_attr, cache, i, pa) + FOR_EACH_VEC_ELT (*cache, i, pa) { if (pa->first) add_stmt_with_node_force (pa->first, gnat_node); @@ -3467,7 +3450,7 @@ Subprogram_Body_to_gnu (Node_Id gnat_node) add_stmt (gnu_result); add_stmt (build1 (LABEL_EXPR, void_type_node, - VEC_last (tree, gnu_return_label_stack))); + gnu_return_label_stack->last ())); if (list_length (gnu_cico_list) == 1) gnu_retval = TREE_VALUE (gnu_cico_list); @@ -3481,7 +3464,7 @@ Subprogram_Body_to_gnu (Node_Id gnat_node) gnu_result = end_stmt_group (); } - VEC_pop (tree, gnu_return_label_stack); + gnu_return_label_stack->pop (); /* Attempt setting the end_locus of our GCC body tree, typically a BIND_EXPR or STATEMENT_LIST, then the end_locus of our GCC subprogram @@ -3639,7 +3622,7 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, /* The return type of the FUNCTION_TYPE. */ tree gnu_result_type = TREE_TYPE (gnu_subprog_type); tree gnu_subprog_addr = build_unary_op (ADDR_EXPR, NULL_TREE, gnu_subprog); - VEC(tree,gc) *gnu_actual_vec = NULL; + vec<tree, va_gc> *gnu_actual_vec = NULL; tree gnu_name_list = NULL_TREE; tree gnu_stmt_list = NULL_TREE; tree gnu_after_list = NULL_TREE; @@ -4042,7 +4025,7 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, gnu_actual = convert (DECL_ARG_TYPE (gnu_formal), gnu_actual); } - VEC_safe_push (tree, gc, gnu_actual_vec, gnu_actual); + vec_safe_push (gnu_actual_vec, gnu_actual); } gnu_call @@ -4402,7 +4385,7 @@ Handled_Sequence_Of_Statements_to_gnu (Node_Id gnat_node) start_stmt_group (); gnat_pushlevel (); - VEC_safe_push (tree, gc, gnu_except_ptr_stack, + vec_safe_push (gnu_except_ptr_stack, create_var_decl (get_identifier ("EXCEPT_PTR"), NULL_TREE, build_pointer_type (except_type_node), build_call_n_expr (get_excptr_decl, 0), @@ -4431,7 +4414,7 @@ Handled_Sequence_Of_Statements_to_gnu (Node_Id gnat_node) /* If none of the exception handlers did anything, re-raise but do not defer abortion. */ gnu_expr = build_call_n_expr (raise_nodefer_decl, 1, - VEC_last (tree, gnu_except_ptr_stack)); + gnu_except_ptr_stack->last ()); set_expr_location_from_node (gnu_expr, Present (End_Label (gnat_node)) ? End_Label (gnat_node) : gnat_node); @@ -4443,7 +4426,7 @@ Handled_Sequence_Of_Statements_to_gnu (Node_Id gnat_node) /* End the binding level dedicated to the exception handlers and get the whole statement group. */ - VEC_pop (tree, gnu_except_ptr_stack); + gnu_except_ptr_stack->pop (); gnat_poplevel (); gnu_handler = end_stmt_group (); @@ -4536,7 +4519,7 @@ Exception_Handler_to_gnu_sjlj (Node_Id gnat_node) build_component_ref (build_unary_op (INDIRECT_REF, NULL_TREE, - VEC_last (tree, gnu_except_ptr_stack)), + gnu_except_ptr_stack->last ()), get_identifier ("not_handled_by_others"), NULL_TREE, false)), integer_zero_node); @@ -4558,8 +4541,8 @@ Exception_Handler_to_gnu_sjlj (Node_Id gnat_node) this_choice = build_binary_op (EQ_EXPR, boolean_type_node, - VEC_last (tree, gnu_except_ptr_stack), - convert (TREE_TYPE (VEC_last (tree, gnu_except_ptr_stack)), + gnu_except_ptr_stack->last (), + convert (TREE_TYPE (gnu_except_ptr_stack->last ()), build_unary_op (ADDR_EXPR, NULL_TREE, gnu_expr))); /* If this is the distinguished exception "Non_Ada_Error" (and we are @@ -4570,7 +4553,7 @@ Exception_Handler_to_gnu_sjlj (Node_Id gnat_node) tree gnu_comp = build_component_ref (build_unary_op (INDIRECT_REF, NULL_TREE, - VEC_last (tree, gnu_except_ptr_stack)), + gnu_except_ptr_stack->last ()), get_identifier ("lang"), NULL_TREE, false); this_choice @@ -4711,7 +4694,7 @@ Compilation_Unit_to_gnu (Node_Id gnat_node) gnat_unit); struct elab_info *info; - VEC_safe_push (tree, gc, gnu_elab_proc_stack, gnu_elab_proc_decl); + vec_safe_push (gnu_elab_proc_stack, gnu_elab_proc_decl); DECL_ELABORATION_PROC_P (gnu_elab_proc_decl) = 1; /* Initialize the information structure for the function. */ @@ -4792,7 +4775,7 @@ Compilation_Unit_to_gnu (Node_Id gnat_node) /* Generate elaboration code for this unit, if necessary, and say whether we did or not. */ - VEC_pop (tree, gnu_elab_proc_stack); + gnu_elab_proc_stack->pop (); /* Invalidate the global renaming pointers. This is necessary because stabilization of the renamed entities may create SAVE_EXPRs which @@ -5235,8 +5218,8 @@ gnat_to_gnu (Node_Id gnat_node) int length = String_Length (gnat_string); int i; tree gnu_idx = TYPE_MIN_VALUE (TYPE_DOMAIN (gnu_result_type)); - VEC(constructor_elt,gc) *gnu_vec - = VEC_alloc (constructor_elt, gc, length); + vec<constructor_elt, va_gc> *gnu_vec; + vec_alloc (gnu_vec, length); for (i = 0; i < length; i++) { @@ -5658,7 +5641,8 @@ gnat_to_gnu (Node_Id gnat_node) gnu_aggr_type = TYPE_REPRESENTATIVE_ARRAY (gnu_result_type); if (Null_Record_Present (gnat_node)) - gnu_result = gnat_build_constructor (gnu_aggr_type, NULL); + gnu_result = gnat_build_constructor (gnu_aggr_type, + NULL); else if (TREE_CODE (gnu_aggr_type) == RECORD_TYPE || TREE_CODE (gnu_aggr_type) == UNION_TYPE) @@ -6231,7 +6215,7 @@ gnat_to_gnu (Node_Id gnat_node) ? gnat_to_gnu (Condition (gnat_node)) : NULL_TREE), (Present (Name (gnat_node)) ? get_gnu_tree (Entity (Name (gnat_node))) - : VEC_last (loop_info, gnu_loop_stack)->label)); + : gnu_loop_stack->last ()->label)); break; case N_Simple_Return_Statement: @@ -6246,7 +6230,7 @@ gnat_to_gnu (Node_Id gnat_node) /* If this function has copy-in/copy-out parameters, get the real object for the return. See Subprogram_to_gnu. */ if (TYPE_CI_CO_LIST (gnu_subprog_type)) - gnu_ret_obj = VEC_last (tree, gnu_return_var_stack); + gnu_ret_obj = gnu_return_var_stack->last (); else gnu_ret_obj = DECL_RESULT (current_function_decl); @@ -6331,18 +6315,18 @@ gnat_to_gnu (Node_Id gnat_node) /* If we have a return label defined, convert this into a branch to that label. The return proper will be handled elsewhere. */ - if (VEC_last (tree, gnu_return_label_stack)) + if (gnu_return_label_stack->last ()) { if (gnu_ret_obj) add_stmt (build_binary_op (MODIFY_EXPR, NULL_TREE, gnu_ret_obj, gnu_ret_val)); gnu_result = build1 (GOTO_EXPR, void_type_node, - VEC_last (tree, gnu_return_label_stack)); + gnu_return_label_stack->last ()); /* When not optimizing, make sure the return is preserved. */ if (!optimize && Comes_From_Source (gnat_node)) - DECL_ARTIFICIAL (VEC_last (tree, gnu_return_label_stack)) = 0; + DECL_ARTIFICIAL (gnu_return_label_stack->last ()) = 0; } /* Otherwise, build a regular return. */ @@ -6569,15 +6553,15 @@ gnat_to_gnu (Node_Id gnat_node) break; case N_Pop_Constraint_Error_Label: - VEC_pop (tree, gnu_constraint_error_label_stack); + gnu_constraint_error_label_stack->pop (); break; case N_Pop_Storage_Error_Label: - VEC_pop (tree, gnu_storage_error_label_stack); + gnu_storage_error_label_stack->pop (); break; case N_Pop_Program_Error_Label: - VEC_pop (tree, gnu_program_error_label_stack); + gnu_program_error_label_stack->pop (); break; /******************************/ @@ -6857,7 +6841,7 @@ gnat_to_gnu (Node_Id gnat_node) /* The only validation we currently do on an unchecked conversion is that of aliasing assumptions. */ if (flag_strict_aliasing) - VEC_safe_push (Node_Id, heap, gnat_validate_uc_list, gnat_node); + gnat_validate_uc_list.safe_push (gnat_node); gnu_result = alloc_stmt_list (); break; @@ -7032,13 +7016,13 @@ gnat_to_gnu (Node_Id gnat_node) label to push onto the stack. */ static void -push_exception_label_stack (VEC(tree,gc) **gnu_stack, Entity_Id gnat_label) +push_exception_label_stack (vec<tree, va_gc> **gnu_stack, Entity_Id gnat_label) { tree gnu_label = (Present (gnat_label) ? gnat_to_gnu_entity (gnat_label, NULL_TREE, 0) : NULL_TREE); - VEC_safe_push (tree, gc, *gnu_stack, gnu_label); + vec_safe_push (*gnu_stack, gnu_label); } /* Record the current code position in GNAT_NODE. */ @@ -8678,7 +8662,7 @@ pos_to_constructor (Node_Id gnat_expr, tree gnu_array_type, { tree gnu_index = TYPE_MIN_VALUE (TYPE_DOMAIN (gnu_array_type)); tree gnu_expr; - VEC(constructor_elt,gc) *gnu_expr_vec = NULL; + vec<constructor_elt, va_gc> *gnu_expr_vec = NULL; for ( ; Present (gnat_expr); gnat_expr = Next (gnat_expr)) { @@ -8719,7 +8703,7 @@ static tree extract_values (tree values, tree record_type) { tree field, tem; - VEC(constructor_elt,gc) *v = NULL; + vec<constructor_elt, va_gc> *v = NULL; for (field = TYPE_FIELDS (record_type); field; field = DECL_CHAIN (field)) { @@ -8737,7 +8721,7 @@ extract_values (tree values, tree record_type) { value = extract_values (values, TREE_TYPE (field)); if (TREE_CODE (value) == CONSTRUCTOR - && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (value))) + && vec_safe_is_empty (CONSTRUCTOR_ELTS (value))) value = 0; } else @@ -9126,11 +9110,11 @@ tree get_exception_label (char kind) { if (kind == N_Raise_Constraint_Error) - return VEC_last (tree, gnu_constraint_error_label_stack); + return gnu_constraint_error_label_stack->last (); else if (kind == N_Raise_Storage_Error) - return VEC_last (tree, gnu_storage_error_label_stack); + return gnu_storage_error_label_stack->last (); else if (kind == N_Raise_Program_Error) - return VEC_last (tree, gnu_program_error_label_stack); + return gnu_program_error_label_stack->last (); else return NULL_TREE; } @@ -9140,7 +9124,7 @@ get_exception_label (char kind) tree get_elaboration_procedure (void) { - return VEC_last (tree, gnu_elab_proc_stack); + return gnu_elab_proc_stack->last (); } #include "gt-ada-trans.h" diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c index 43a8356..6aa465b 100644 --- a/gcc/ada/gcc-interface/utils.c +++ b/gcc/ada/gcc-interface/utils.c @@ -201,13 +201,13 @@ static GTY((deletable)) struct gnat_binding_level *free_binding_level; static GTY(()) tree global_context; /* An array of global declarations. */ -static GTY(()) VEC(tree,gc) *global_decls; +static GTY(()) vec<tree, va_gc> *global_decls; /* An array of builtin function declarations. */ -static GTY(()) VEC(tree,gc) *builtin_decls; +static GTY(()) vec<tree, va_gc> *builtin_decls; /* An array of global renaming pointers. */ -static GTY(()) VEC(tree,gc) *global_renaming_pointers; +static GTY(()) vec<tree, va_gc> *global_renaming_pointers; /* A chain of unused BLOCK nodes. */ static GTY((deletable)) tree free_block_chain; @@ -576,10 +576,10 @@ gnat_pushdecl (tree decl, Node_Id gnat_node) if (DECL_EXTERNAL (decl)) { if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl)) - VEC_safe_push (tree, gc, builtin_decls, decl); + vec_safe_push (builtin_decls, decl); } else if (global_bindings_p ()) - VEC_safe_push (tree, gc, global_decls, decl); + vec_safe_push (global_decls, decl); else { DECL_CHAIN (decl) = BLOCK_VARS (current_binding_level->block); @@ -1953,11 +1953,11 @@ create_subprog_type (tree return_type, tree param_decl_list, tree cico_list, /* A list of the data type nodes of the subprogram formal parameters. This list is generated by traversing the input list of PARM_DECL nodes. */ - VEC(tree,gc) *param_type_list = NULL; + vec<tree, va_gc> *param_type_list = NULL; tree t, type; for (t = param_decl_list; t; t = DECL_CHAIN (t)) - VEC_safe_push (tree, gc, param_type_list, TREE_TYPE (t)); + vec_safe_push (param_type_list, TREE_TYPE (t)); type = build_function_type_vec (return_type, param_type_list); @@ -2517,7 +2517,7 @@ void record_global_renaming_pointer (tree decl) { gcc_assert (!DECL_LOOP_PARM_P (decl) && DECL_RENAMED_OBJECT (decl)); - VEC_safe_push (tree, gc, global_renaming_pointers, decl); + vec_safe_push (global_renaming_pointers, decl); } /* Invalidate the global renaming pointers. */ @@ -2528,10 +2528,13 @@ invalidate_global_renaming_pointers (void) unsigned int i; tree iter; - FOR_EACH_VEC_ELT (tree, global_renaming_pointers, i, iter) + if (global_renaming_pointers == NULL) + return; + + FOR_EACH_VEC_ELT (*global_renaming_pointers, i, iter) SET_DECL_RENAMED_OBJECT (iter, NULL_TREE); - VEC_free (tree, gc, global_renaming_pointers); + vec_free (global_renaming_pointers); } /* Return true if VALUE is a known to be a multiple of FACTOR, which must be @@ -3091,7 +3094,7 @@ max_size (tree exp, bool max_p) tree build_template (tree template_type, tree array_type, tree expr) { - VEC(constructor_elt,gc) *template_elts = NULL; + vec<constructor_elt, va_gc> *template_elts = NULL; tree bound_list = NULL_TREE; tree field; @@ -3755,7 +3758,7 @@ build_vms_descriptor (tree type, Mechanism_Type mech, Entity_Id gnat_entity) tree fill_vms_descriptor (tree gnu_type, tree gnu_expr, Node_Id gnat_actual) { - VEC(constructor_elt,gc) *v = NULL; + vec<constructor_elt, va_gc> *v = NULL; tree field; gnu_expr = maybe_unconstrained_array (gnu_expr); @@ -3813,7 +3816,7 @@ convert_vms_descriptor64 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog) /* See the head comment of build_vms_descriptor. */ int iklass = TREE_INT_CST_LOW (DECL_INITIAL (klass)); tree lfield, ufield; - VEC(constructor_elt,gc) *v; + vec<constructor_elt, va_gc> *v; /* Convert POINTER to the pointer-to-array type. */ gnu_expr64 = convert (p_array_type, gnu_expr64); @@ -3823,7 +3826,7 @@ convert_vms_descriptor64 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog) case 1: /* Class S */ case 15: /* Class SB */ /* Build {1, LENGTH} template; LENGTH64 is the 5th field. */ - v = VEC_alloc (constructor_elt, gc, 2); + vec_alloc (v, 2); t = DECL_CHAIN (DECL_CHAIN (klass)); t = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE); CONSTRUCTOR_APPEND_ELT (v, min_field, @@ -3855,7 +3858,7 @@ convert_vms_descriptor64 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog) (TREE_TYPE (DECL_CHAIN (TYPE_FIELDS (template_type))), ufield); /* Build the template in the form of a constructor. */ - v = VEC_alloc (constructor_elt, gc, 2); + vec_alloc (v, 2); CONSTRUCTOR_APPEND_ELT (v, TYPE_FIELDS (template_type), lfield); CONSTRUCTOR_APPEND_ELT (v, DECL_CHAIN (TYPE_FIELDS (template_type)), ufield); @@ -3903,7 +3906,7 @@ convert_vms_descriptor64 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog) (TREE_TYPE (DECL_CHAIN (TYPE_FIELDS (template_type))), ufield); /* Build the template in the form of a constructor. */ - v = VEC_alloc (constructor_elt, gc, 2); + vec_alloc (v, 2); CONSTRUCTOR_APPEND_ELT (v, TYPE_FIELDS (template_type), lfield); CONSTRUCTOR_APPEND_ELT (v, DECL_CHAIN (TYPE_FIELDS (template_type)), ufield); @@ -3924,7 +3927,7 @@ convert_vms_descriptor64 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog) } /* Build the fat pointer in the form of a constructor. */ - v = VEC_alloc (constructor_elt, gc, 2); + vec_alloc (v, 2); CONSTRUCTOR_APPEND_ELT (v, TYPE_FIELDS (gnu_type), gnu_expr64); CONSTRUCTOR_APPEND_ELT (v, DECL_CHAIN (TYPE_FIELDS (gnu_type)), template_addr); @@ -3966,7 +3969,7 @@ convert_vms_descriptor32 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog) tree template_tree, template_addr, aflags, dimct, t, u; /* See the head comment of build_vms_descriptor. */ int iklass = TREE_INT_CST_LOW (DECL_INITIAL (klass)); - VEC(constructor_elt,gc) *v; + vec<constructor_elt, va_gc> *v; /* Convert POINTER to the pointer-to-array type. */ gnu_expr32 = convert (p_array_type, gnu_expr32); @@ -3976,7 +3979,7 @@ convert_vms_descriptor32 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog) case 1: /* Class S */ case 15: /* Class SB */ /* Build {1, LENGTH} template; LENGTH is the 1st field. */ - v = VEC_alloc (constructor_elt, gc, 2); + vec_alloc (v, 2); t = TYPE_FIELDS (desc_type); t = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE); CONSTRUCTOR_APPEND_ELT (v, min_field, @@ -4048,7 +4051,7 @@ convert_vms_descriptor32 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog) } /* Build the fat pointer in the form of a constructor. */ - v = VEC_alloc (constructor_elt, gc, 2); + vec_alloc (v, 2); CONSTRUCTOR_APPEND_ELT (v, TYPE_FIELDS (gnu_type), gnu_expr32); CONSTRUCTOR_APPEND_ELT (v, DECL_CHAIN (TYPE_FIELDS (gnu_type)), template_addr); @@ -4306,7 +4309,8 @@ convert_to_fat_pointer (tree type, tree expr) tree p_array_type = TREE_TYPE (TYPE_FIELDS (type)); tree etype = TREE_TYPE (expr); tree template_tree; - VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 2); + vec<constructor_elt, va_gc> *v; + vec_alloc (v, 2); /* If EXPR is null, make a fat pointer that contains a null pointer to the array (compare_fat_pointers ensures that this is the full discriminant) @@ -4323,7 +4327,8 @@ convert_to_fat_pointer (tree type, tree expr) { /* The template type can still be dummy at this point so we build an empty constructor. The middle-end will fill it in with zeros. */ - t = build_constructor (template_type, NULL); + t = build_constructor (template_type, + NULL); TREE_CONSTANT (t) = TREE_STATIC (t) = 1; null_bounds = build_unary_op (ADDR_EXPR, NULL_TREE, t); SET_TYPE_NULL_BOUNDS (ptr_template_type, null_bounds); @@ -4425,7 +4430,7 @@ convert (tree type, tree expr) constructor to build the record, unless a variable size is involved. */ else if (code == RECORD_TYPE && TYPE_PADDING_P (type)) { - VEC(constructor_elt,gc) *v; + vec<constructor_elt, va_gc> *v; /* If we previously converted from another type and our type is of variable size, remove the conversion to avoid the need for @@ -4478,7 +4483,7 @@ convert (tree type, tree expr) expr), false); - v = VEC_alloc (constructor_elt, gc, 1); + vec_alloc (v, 1); CONSTRUCTOR_APPEND_ELT (v, TYPE_FIELDS (type), convert (TREE_TYPE (TYPE_FIELDS (type)), expr)); return gnat_build_constructor (type, v); @@ -4495,11 +4500,9 @@ convert (tree type, tree expr) /* If we have just converted to this padded type, just get the inner expression. */ if (TREE_CODE (expr) == CONSTRUCTOR - && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (expr)) - && VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0).index - == TYPE_FIELDS (etype)) - unpadded - = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0).value; + && !vec_safe_is_empty (CONSTRUCTOR_ELTS (expr)) + && (*CONSTRUCTOR_ELTS (expr))[0].index == TYPE_FIELDS (etype)) + unpadded = (*CONSTRUCTOR_ELTS (expr))[0].value; /* Otherwise, build an explicit component reference. */ else @@ -4533,7 +4536,8 @@ convert (tree type, tree expr) if (code == RECORD_TYPE && TYPE_CONTAINS_TEMPLATE_P (type)) { tree obj_type = TREE_TYPE (DECL_CHAIN (TYPE_FIELDS (type))); - VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 2); + vec<constructor_elt, va_gc> *v; + vec_alloc (v, 2); /* If the source already has a template, get a reference to the associated array only, as we are going to rebuild a template @@ -4592,8 +4596,7 @@ convert (tree type, tree expr) { expr = copy_node (expr); TREE_TYPE (expr) = type; - CONSTRUCTOR_ELTS (expr) - = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (expr)); + CONSTRUCTOR_ELTS (expr) = vec_safe_copy (CONSTRUCTOR_ELTS (expr)); return expr; } @@ -4606,9 +4609,10 @@ convert (tree type, tree expr) || tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (etype)))) { - VEC(constructor_elt,gc) *e = CONSTRUCTOR_ELTS (expr); - unsigned HOST_WIDE_INT len = VEC_length (constructor_elt, e); - VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, len); + vec<constructor_elt, va_gc> *e = CONSTRUCTOR_ELTS (expr); + unsigned HOST_WIDE_INT len = vec_safe_length (e); + vec<constructor_elt, va_gc> *v; + vec_alloc (v, len); tree efield = TYPE_FIELDS (etype), field = TYPE_FIELDS (type); unsigned HOST_WIDE_INT idx; tree index, value; @@ -4626,7 +4630,7 @@ convert (tree type, tree expr) if (!SAME_FIELD_P (efield, field)) break; constructor_elt elt = {field, convert (TREE_TYPE (field), value)}; - VEC_quick_push (constructor_elt, v, elt); + v->quick_push (elt); /* If packing has made this field a bitfield and the input value couldn't be emitted statically any more, we need to @@ -4663,9 +4667,9 @@ convert (tree type, tree expr) && gnat_types_compatible_p (TYPE_REPRESENTATIVE_ARRAY (type), etype)) { - VEC(constructor_elt,gc) *e = CONSTRUCTOR_ELTS (expr); - unsigned HOST_WIDE_INT len = VEC_length (constructor_elt, e); - VEC(constructor_elt,gc) *v; + vec<constructor_elt, va_gc> *e = CONSTRUCTOR_ELTS (expr); + unsigned HOST_WIDE_INT len = vec_safe_length (e); + vec<constructor_elt, va_gc> *v; unsigned HOST_WIDE_INT ix; tree value; @@ -4689,11 +4693,11 @@ convert (tree type, tree expr) } /* Otherwise, build a regular vector constructor. */ - v = VEC_alloc (constructor_elt, gc, len); + vec_alloc (v, len); FOR_EACH_CONSTRUCTOR_VALUE (e, ix, value) { constructor_elt elt = {NULL_TREE, value}; - VEC_quick_push (constructor_elt, v, elt); + v->quick_push (elt); } expr = copy_node (expr); TREE_TYPE (expr) = type; @@ -4880,7 +4884,8 @@ convert (tree type, tree expr) case RECORD_TYPE: if (TYPE_JUSTIFIED_MODULAR_P (type) && !AGGREGATE_TYPE_P (etype)) { - VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 1); + vec<constructor_elt, va_gc> *v; + vec_alloc (v, 1); CONSTRUCTOR_APPEND_ELT (v, TYPE_FIELDS (type), convert (TREE_TYPE (TYPE_FIELDS (type)), @@ -5048,9 +5053,7 @@ remove_conversions (tree exp, bool true_address) && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE && TYPE_JUSTIFIED_MODULAR_P (TREE_TYPE (exp))) return - remove_conversions (VEC_index (constructor_elt, - CONSTRUCTOR_ELTS (exp), 0).value, - true); + remove_conversions ((*CONSTRUCTOR_ELTS (exp))[0].value, true); break; case COMPONENT_REF: @@ -5292,7 +5295,8 @@ unchecked_convert (tree type, tree expr, bool notrunc_p) { tree rec_type = make_node (RECORD_TYPE); unsigned HOST_WIDE_INT prec = TREE_INT_CST_LOW (TYPE_RM_SIZE (etype)); - VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 1); + vec<constructor_elt, va_gc> *v; + vec_alloc (v, 1); tree field_type, field; if (TYPE_UNSIGNED (etype)) @@ -5575,7 +5579,7 @@ gnat_write_global_declarations (void) /* If we have declared types as used at the global level, insert them in the global hash table. We use a dummy variable for this purpose. */ - if (!VEC_empty (tree, types_used_by_cur_var_decl)) + if (types_used_by_cur_var_decl && !types_used_by_cur_var_decl->is_empty ()) { struct varpool_node *node; char *label; @@ -5589,9 +5593,9 @@ gnat_write_global_declarations (void) node = varpool_node_for_decl (dummy_global); node->symbol.force_output = 1; - while (!VEC_empty (tree, types_used_by_cur_var_decl)) + while (!types_used_by_cur_var_decl->is_empty ()) { - tree t = VEC_pop (tree, types_used_by_cur_var_decl); + tree t = types_used_by_cur_var_decl->pop (); types_used_by_var_decl_insert (t, dummy_global); } } @@ -5600,7 +5604,7 @@ gnat_write_global_declarations (void) ensures that global types whose compilation hasn't been finalized yet, for example pointers to Taft amendment types, have their compilation finalized in the right context. */ - FOR_EACH_VEC_ELT (tree, global_decls, i, iter) + FOR_EACH_VEC_SAFE_ELT (global_decls, i, iter) if (TREE_CODE (iter) == TYPE_DECL) debug_hooks->global_decl (iter); @@ -5612,7 +5616,7 @@ gnat_write_global_declarations (void) if (!seen_error ()) { timevar_push (TV_SYMOUT); - FOR_EACH_VEC_ELT (tree, global_decls, i, iter) + FOR_EACH_VEC_SAFE_ELT (global_decls, i, iter) if (TREE_CODE (iter) != TYPE_DECL) debug_hooks->global_decl (iter); timevar_pop (TV_SYMOUT); @@ -5641,7 +5645,7 @@ builtin_decl_for (tree name) unsigned i; tree decl; - FOR_EACH_VEC_ELT (tree, builtin_decls, i, decl) + FOR_EACH_VEC_SAFE_ELT (builtin_decls, i, decl) if (DECL_NAME (decl) == name) return decl; diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c index 4578114..4bb16ec 100644 --- a/gcc/ada/gcc-interface/utils2.c +++ b/gcc/ada/gcc-interface/utils2.c @@ -441,7 +441,7 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) /* The constant folder doesn't fold fat pointer types so we do it here. */ if (TREE_CODE (p1) == CONSTRUCTOR) - p1_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 0).value; + p1_array = (*CONSTRUCTOR_ELTS (p1))[0].value; else p1_array = build_component_ref (p1, NULL_TREE, TYPE_FIELDS (TREE_TYPE (p1)), true); @@ -452,7 +452,7 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) null_pointer_node)); if (TREE_CODE (p2) == CONSTRUCTOR) - p2_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 0).value; + p2_array = (*CONSTRUCTOR_ELTS (p2))[0].value; else p2_array = build_component_ref (p2, NULL_TREE, TYPE_FIELDS (TREE_TYPE (p2)), true); @@ -473,14 +473,14 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) = fold_build2_loc (loc, EQ_EXPR, result_type, p1_array, p2_array); if (TREE_CODE (p1) == CONSTRUCTOR) - p1_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 1).value; + p1_bounds = (*CONSTRUCTOR_ELTS (p1))[1].value; else p1_bounds = build_component_ref (p1, NULL_TREE, DECL_CHAIN (TYPE_FIELDS (TREE_TYPE (p1))), true); if (TREE_CODE (p2) == CONSTRUCTOR) - p2_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 1).value; + p2_bounds = (*CONSTRUCTOR_ELTS (p2))[1].value; else p2_bounds = build_component_ref (p2, NULL_TREE, @@ -1334,9 +1334,7 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) a pointer to our type. */ if (TYPE_IS_PADDING_P (type)) { - result = VEC_index (constructor_elt, - CONSTRUCTOR_ELTS (operand), - 0).value; + result = (*CONSTRUCTOR_ELTS (operand))[0].value; result = convert (build_pointer_type (TREE_TYPE (operand)), build_unary_op (ADDR_EXPR, NULL_TREE, result)); break; @@ -1831,7 +1829,7 @@ compare_elmt_bitpos (const PTR rt1, const PTR rt2) /* Return a CONSTRUCTOR of TYPE whose elements are V. */ tree -gnat_build_constructor (tree type, VEC(constructor_elt,gc) *v) +gnat_build_constructor (tree type, vec<constructor_elt, va_gc> *v) { bool allconstant = (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST); bool side_effects = false; @@ -1859,7 +1857,7 @@ gnat_build_constructor (tree type, VEC(constructor_elt,gc) *v) by increasing bit position. This is necessary to ensure the constructor can be output as static data. */ if (allconstant && TREE_CODE (type) == RECORD_TYPE && n_elmts > 1) - VEC_qsort (constructor_elt, v, compare_elmt_bitpos); + v->qsort (compare_elmt_bitpos); result = build_constructor (type, v); TREE_CONSTANT (result) = TREE_STATIC (result) = allconstant; @@ -1989,7 +1987,7 @@ build_simple_component_ref (tree record_variable, tree component, if (TREE_CODE (record_variable) == CONSTRUCTOR && TYPE_CONTAINS_TEMPLATE_P (TREE_TYPE (record_variable))) { - VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (record_variable); + vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (record_variable); unsigned HOST_WIDE_INT idx; tree index, value; FOR_EACH_CONSTRUCTOR_ELT (elts, idx, index, value) @@ -2302,7 +2300,8 @@ build_allocator (tree type, tree init, tree result_type, Entity_Id gnat_proc, If there is no initializing expression, just set the bounds. */ if (init) { - VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 2); + vec<constructor_elt, va_gc> *v; + vec_alloc (v, 2); CONSTRUCTOR_APPEND_ELT (v, TYPE_FIELDS (storage_type), build_template (template_type, type, init)); @@ -2673,12 +2672,10 @@ gnat_stabilize_reference (tree ref, bool force, bool *success) /* Constructors with 1 element are used extensively to formally convert objects to special wrapping types. */ if (TREE_CODE (type) == RECORD_TYPE - && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (ref)) == 1) + && vec_safe_length (CONSTRUCTOR_ELTS (ref)) == 1) { - tree index - = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0).index; - tree value - = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0).value; + tree index = (*CONSTRUCTOR_ELTS (ref))[0].index; + tree value = (*CONSTRUCTOR_ELTS (ref))[0].value; result = build_constructor_single (type, index, gnat_stabilize_reference_1 (value, |