Patchwork VEC re-write [patch 04/25]

login
register
mail settings
Submitter Diego Novillo
Date Nov. 15, 2012, 9:53 p.m.
Message ID <20121115215329.04E2EC0916@torture.tor.corp.google.com>
Download mbox | patch
Permalink /patch/199430/
State New
Headers show

Comments

Diego Novillo - Nov. 15, 2012, 9:53 p.m.
2012-11-15  Diego Novillo  <dnovillo@google.com>

	Adjust for new vec API (http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec)

	* gcc-interface/decl.c: Use new vec API in vec.h.
	* gcc-interface/gigi.h: Likewise.
	* gcc-interface/trans.c: Likewise.
	* gcc-interface/utils.c: Likewise.
	* gcc-interface/utils2.c: Likewise.

Patch

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,