This patch rewrites the old VEC macro-based interface into a new one based on the template class 'vec'.

This patch rewrites the old VEC macro-based interface into a new one
based on the template class 'vec'.  The user-visible changes are
described in http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec.

I have tested the patch pretty extensively:

- Regular bootstraps on x86_64, ppc, ia64, sparc and hppa.
- Bootstraps with --enable-checking=release
- Bootstraps with --enable-checking=gc,gcac
- Basic builds on all targets (using contrib/config-list.mk).

We no longer access the vectors via VEC_* macros.  The pattern is
"VEC_operation (T, A, V, args)" becomes "V.operation (args)".

The only thing I could not do is create proper ctors and dtors for the
vec class.  Since these vectors are stored in unions, we
have to keep them as PODs (C++03 does not allow non-PODs in unions).

This means that creation and destruction must be explicit.  There is a
new method vec<type, allocation, layout>::create() and another vec<type,
allocation, layout>::destroy() to allocate the internal vector.

For vectors that must be pointers, there is a family of free functions
that implement the operations that need to tolerate NULL vectors.
These functions all start with the prefix 'vec_safe_'.  See the wiki
page for details.

The gengtype change removes the special handling for VEC() that used
to exist in gengtype. Additionally, it allows gengtype to recognize
templates of more than one argument and introduces the concept of an
undefined type (useful for template arguments that may or may not be
types).

When a TYPE_UNDEFINED is reached, gengtype will ignore it if it
happens inside a type marked with GTY((user)).  Otherwise, it will
emit an error.

Finally, gengtype rejects root types marked GTY((user)) that are not
first class pointers.

2012-11-16  Diego Novillo  <dnovillo@google.com>

	VEC API overhaul (http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec)

	* vec.c (register_overhead): Convert it into
	member function of vec_prefix.
	(release_overhead): Likewise.
	(calculate_allocation): Likewise.
	(vec_heap_free): Remove.
	(vec_gc_o_reserve_1): Remove.
	(vec_heap_o_reserve_1): Remove.
	(vec_stack_o_reserve_1): Remove.
	(vec_stack_o_reserve_exact): Remove.
	(register_stack_vec): New.
	(stack_vec_register_index): New.
	(unregister_stack_vec): New.
	(vec_assert_fail): Remove.
	* vec.h: Conditionally include ggc.h.  Document conditional
	hackery.
	Update top-level documentation.
	(ALONE_VEC_CHECK_INFO): Remove.
	(VEC_CHECK_INFO): Remove.
	(ALONE_VEC_CHECK_DECL): Remove.
	(VEC_CHECK_DECL): Remove.
	(ALONE_VEC_CHECK_PASS): Remove.
	(VEC_CHECK_PASS): Remove.
	(VEC_ASSERT): Remove.
	(vec_prefix): Add friends va_gc, va_gc_atomic, va_heap and
	va_stack.
	Mark fields alloc_ and num_ as protected.
	(struct vec_t): Remove.  Remove all function members.
	(struct vl_embed): Declare.
	(struct vl_ptr): Declare.
	(free): Remove.
	(reserve_exact): Remove.
	(reserve): Remove.
	(safe_splice): Remove.
	(safe_push): Remove.
	(safe_grow): Remove.
	(safe_grow_cleared): Remove.
	(safe_insert): Remove.
	(DEF_VEC_I): Remove.
	(DEF_VEC_ALLOC_I): Remove.
	(DEF_VEC_P): Remove.
	(DEF_VEC_ALLOC_P): Remove.
	(DEF_VEC_O): Remove.
	(DEF_VEC_ALLOC_O): Remove.
	(DEF_VEC_ALLOC_P_STACK): Remove.
	(DEF_VEC_ALLOC_O_STACK): Remove.
	(DEF_VEC_ALLOC_I_STACK): Remove.
	(DEF_VEC_A): Remove.
	(DEF_VEC_ALLOC_A): Remove.
	(vec_stack_p_reserve_exact_1): Remove.
	(vec_stack_o_reserve): Remove.
	(vec_stack_o_reserve_exact): Remove.
	(VEC_length): Remove.
	(VEC_empty): Remove.
	(VEC_address): Remove.
	(vec_address): Remove.
	(VEC_last): Remove.
	(VEC_index): Remove.
	(VEC_iterate): Remove.
	(VEC_embedded_size): Remove.
	(VEC_embedded_init): Remove.
	(VEC_free): Remove.
	(VEC_copy): Remove.
	(VEC_space): Remove.
	(VEC_reserve): Remove.
	(VEC_reserve_exact): Remove.
	(VEC_splice): Remove.
	(VEC_safe_splice): Remove.
	(VEC_quick_push): Remove.
	(VEC_safe_push): Remove.
	(VEC_pop): Remove.
	(VEC_truncate): Remove.
	(VEC_safe_grow): Remove.
	(VEC_replace): Remove.
	(VEC_quick_insert): Remove.
	(VEC_safe_insert): Remove.
	(VEC_ordered_remove): Remove.
	(VEC_unordered_remove): Remove.
	(VEC_block_remove): Remove.
	(VEC_lower_bound): Remove.
	(VEC_alloc): Remove.
	(VEC_qsort): Remove.

	(va_heap): Declare.
	(va_heap::default_layout): New typedef to vl_ptr.
	(va_heap::reserve): New.
	(va_heap::release): New.
	(va_gc): Declare.
	(va_gc::default_layout): New typedef to vl_embed.
	(va_gc::reserve): New.
	(va_gc::release): New.
	(va_gc_atomic): Declare.  Inherit from va_gc.
	(va_stack): Declare.
	(va_stack::default_layout): New typedef to vl_ptr.
	(va_stack::alloc): New.
	(va_stack::reserve): New.
	(va_stack::release): New.
	(register_stack_vec): Declare.
	(stack_vec_register_index): Declare.
	(unregister_stack_vec): Declare.

	(vec<T, A = va_heap, L = typename A::default_layout>): Declare
	empty vec template.
	(vec<T, A, vl_embed>): Partial specialization for embedded
	layout.
	(vec<T, A, vl_embed>::allocated): New.
	(vec<T, A, vl_embed>::length): New.
	(vec<T, A, vl_embed>::is_empty): New.
	(vec<T, A, vl_embed>::address): New.
	(vec<T, A, vl_embed>::operator[]): New.
	(vec<T, A, vl_embed>::last New.
	(vec<T, A, vl_embed>::space): New.
	(vec<T, A, vl_embed>::iterate): New.
	(vec<T, A, vl_embed>::iterate): New.
	(vec<T, A, vl_embed>::copy): New.
	(vec<T, A, vl_embed>::splice): New.
	(vec<T, A, vl_embed>::quick_push New.
	(vec<T, A, vl_embed>::pop New.
	(vec<T, A, vl_embed>::truncate): New.
	(vec<T, A, vl_embed>::quick_insert): New.
	(vec<T, A, vl_embed>::ordered_remove): New.
	(vec<T, A, vl_embed>::unordered_remove): New.
	(vec<T, A, vl_embed>::block_remove): New.
	(vec<T, A, vl_embed>::qsort): New.
	(vec<T, A, vl_embed>::lower_bound): New.
	(vec<T, A, vl_embed>::embedded_size): New.
	(vec<T, A, vl_embed>::embedded_init): New.
	(vec<T, A, vl_embed>::quick_grow): New.
	(vec<T, A, vl_embed>::quick_grow_cleared): New.
	(vec_safe_space): New.
	(vec_safe_length): New.
	(vec_safe_address): New.
	(vec_safe_is_empty): New.
	(vec_safe_reserve): New.
	(vec_safe_reserve_exact): New.
	(vec_alloc): New.
	(vec_free): New.
	(vec_safe_grow): New.
	(vec_safe_grow_cleared): New.
	(vec_safe_iterate): New.
	(vec_safe_push): New.
	(vec_safe_insert): New.
	(vec_safe_truncate): New.
	(vec_safe_copy): New.
	(vec_safe_splice): New.

	(vec<T, A, vl_ptr>): New partial specialization for the space
	efficient layout.
	(vec<T, A, vl_ptr>::exists): New.
	(vec<T, A, vl_ptr>::is_empty): New.
	(vec<T, A, vl_ptr>::length): New.
	(vec<T, A, vl_ptr>::address): New.
	(vec<T, A, vl_ptr>::operator[]): New.
	(vec<T, A, vl_ptr>::operator!=): New.
	(vec<T, A, vl_ptr>::operator==): New.
	(vec<T, A, vl_ptr>::last): New.
	(vec<T, A, vl_ptr>::space): New.
	(vec<T, A, vl_ptr>::iterate): New.
	(vec<T, A, vl_ptr>::copy): New.
	(vec<T, A, vl_ptr>::reserve): New.
	(vec<T, A, vl_ptr>::reserve_exact): New.
	(vec<T, A, vl_ptr>::splice): New.
	(vec<T, A, vl_ptr>::safe_splice): New.
	(vec<T, A, vl_ptr>::quick_push): New.
	(vec<T, A, vl_ptr>::safe_push): New.
	(vec<T, A, vl_ptr>::pop): New.
	(vec<T, A, vl_ptr>::truncate): New.
	(vec<T, A, vl_ptr>::safe_grow): New.
	(vec<T, A, vl_ptr>::safe_grow_cleared): New.
	(vec<T, A, vl_ptr>::quick_grow): New.
	(vec<T, A, vl_ptr>::quick_grow_cleared): New.
	(vec<T, A, vl_ptr>::quick_insert): New.
	(vec<T, A, vl_ptr>::safe_insert): New.
	(vec<T, A, vl_ptr>::ordered_remove): New.
	(vec<T, A, vl_ptr>::unordered_remove): New.
	(vec<T, A, vl_ptr>::block_remove): New.
	(vec<T, A, vl_ptr>::qsort): New.
	(vec<T, A, vl_ptr>::lower_bound): New.
	(vec_stack_alloc): Define.
	(FOR_EACH_VEC_SAFE_ELT): Define.
	* vecir.h: Remove.  Update all users.
	* vecprim.h: Remove.  Update all users.
	Move uchar to coretypes.h.

	* Makefile.in (VEC_H): Add $(GGC_H).
	Remove vecir.h and vecprim.h dependencies everywhere.

2012-11-16  Diego Novillo  <dnovillo@google.com>

	* gengtype-lex.l (VEC): Remove.
	Add characters in the set [\!\>\.-].
	* gengtype-parse.c (token_names): Remove "VEC".
	(require_template_declaration): Remove handling of VEC_TOKEN.
	(type): Likewise.
	Call create_user_defined_type when parsing GTY((user)).
	* gengtype-state.c (type_lineloc): handle TYPE_UNDEFINED.
	(write_state_undefined_type): New.
	(write_state_type): Call write_state_undefined_type for
	TYPE_UNDEFINED.
	(read_state_type): Call read_state_undefined_type for
	TYPE_UNDEFINED.
	* gengtype.c (dbgprint_count_type_at): Handle TYPE_UNDEFINED.
	(create_user_defined_type): Make extern.
	(type_for_name): Factor out of resolve_typedef.
	(create_undefined_type): New
	(resolve_typedef): Call it when we cannot find a previous
	typedef and the type is not a template.
	(find_structure): Accept TYPE_UNDEFINED.
	(set_gc_used_type): Add argument ALLOWED_UNDEFINED_TYPES,
	default to false.
	Emit an error for TYPE_UNDEFINED unless LEVEL is GC_UNUSED or
	ALLOWED_UNDEFINED_TYPES is set.
	Set ALLOWED_UNDEFINED_TYPES to true for TYPE_USER_STRUCT.
	(filter_type_name): Accept templates with more than one
	argument.
	(output_mangled_typename): Handle TYPE_UNDEFINED
	(walk_type): Likewise.
	(write_types_process_field): Likewise.
	(write_func_for_structure): If CHAIN_NEXT is set, ORIG_S
	should not be a user-defined type.
	(write_types_local_user_process_field): Handle TYPE_ARRAY,
	TYPE_NONE and TYPE_UNDEFINED.
	(write_types_local_process_field): Likewise.
	(contains_scalar_p): Return 0 for TYPE_USER_STRUCT.
	(write_root): Reject user-defined types that are not pointers.
	Handle TYPE_NONE, TYPE_UNDEFINED, TYPE_UNION, TYPE_LANG_STRUCT
	and TYPE_PARAM_STRUCT.
	(output_typename): Handle TYPE_NONE, TYPE_UNDEFINED, and
	TYPE_ARRAY.
	(dump_typekind): Handle TYPE_UNDEFINED.
	* gengtype.h (enum typekind): Add TYPE_UNDEFINED.
	(create_user_defined_type): Declare.
	(enum gty_token): Remove VEC_TOKEN.

2012-11-16  Diego Novillo  <dnovillo@google.com>

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

	* coretypes.h (uchar): Define.
	* alias.c: Use new vec API in vec.h.
	* asan.c: Likewise.
	* attribs.c: Likewise.
	* basic-block.h: Likewise.
	* bb-reorder.c: Likewise.
	* builtins.c: Likewise.
	* calls.c: Likewise.
	* cfg.c: Likewise.
	* cfganal.c: Likewise.
	* cfgcleanup.c: Likewise.
	* cfgexpand.c: Likewise.
	* cfghooks.c: Likewise.
	* cfghooks.h: Likewise.
	* cfgloop.c: Likewise.
	* cfgloop.h: Likewise.
	* cfgloopanal.c: Likewise.
	* cfgloopmanip.c: Likewise.
	* cfgrtl.c: Likewise.
	* cgraph.c: Likewise.
	* cgraph.h: Likewise.
	* cgraphclones.c: Likewise.
	* cgraphunit.c: Likewise.
	* combine.c: Likewise.
	* compare-elim.c: Likewise.
	* coverage.c: Likewise.
	* cprop.c: Likewise.
	* data-streamer.h: Likewise.
	* dbxout.c: Likewise.
	* dce.c: Likewise.
	* df-core.c: Likewise.
	* df-problems.c: Likewise.
	* df-scan.c: Likewise.
	* dominance.c: Likewise.
	* domwalk.c: Likewise.
	* domwalk.h: Likewise.
	* dse.c: Likewise.
	* dwarf2cfi.c: Likewise.
	* dwarf2out.c: Likewise.
	* dwarf2out.h: Likewise.
	* emit-rtl.c: Likewise.
	* except.c: Likewise.
	* except.h: Likewise.
	* expr.c: Likewise.
	* expr.h: Likewise.
	* final.c: Likewise.
	* fold-const.c: Likewise.
	* function.c: Likewise.
	* function.h: Likewise.
	* fwprop.c: Likewise.
	* gcc.c: Likewise.
	* gcse.c: Likewise.
	* genattr.c: Likewise.
	* genattrtab.c: Likewise.
	* genautomata.c: Likewise.
	* genextract.c: Likewise.
	* genopinit.c: Likewise
	* ggc-common.c: Likewise.
	* ggc.h: Likewise.
	* gimple-low.c: Likewise.
	* gimple-ssa-strength-reduction.c: Likewise.
	* gimple-streamer-in.c: Likewise.
	* gimple.c: Likewise.
	* gimple.h: Likewise.
	* gimplify.c: Likewise.
	* graph.c: Likewise.
	* graphds.c: Likewise.
	* graphds.h: Likewise.
	* graphite-blocking.c: Likewise.
	* graphite-clast-to-gimple.c: Likewise.
	* graphite-dependences.c: Likewise.
	* graphite-interchange.c: Likewise.
	* graphite-optimize-isl.c: Likewise.
	* graphite-poly.c: Likewise.
	* graphite-poly.h: Likewise.
	* graphite-scop-detection.c: Likewise.
	* graphite-scop-detection.h: Likewise.
	* graphite-sese-to-poly.c: Likewise.
	* graphite.c: Likewise.
	* godump.c: Likewise.
	* haifa-sched.c: Likewise.
	* hw-doloop.c: Likewise.
	* hw-doloop.h: Likewise.
	* ifcvt.c: Likewise.
	* insn-addr.h: Likewise.
	* ipa-cp.c: Likewise.
	* ipa-inline-analysis.c: Likewise.
	* ipa-inline-transform.c: Likewise.
	* ipa-inline.c: Likewise.
	* ipa-inline.h: Likewise.
	* ipa-prop.c: Likewise.
	* ipa-prop.h: Likewise.
	* ipa-pure-const.c: Likewise.
	* ipa-ref-inline.h: Likewise.
	* ipa-ref.c: Likewise.
	* ipa-ref.h: Likewise.
	* ipa-reference.c: Likewise.
	* ipa-split.c: Likewise.
	* ipa-utils.c: Likewise.
	* ipa-utils.h: Likewise.
	* ipa.c: Likewise.
	* ira-build.c: Likewise.
	* ira-color.c: Likewise.
	* ira-emit.c: Likewise.
	* ira-int.h: Likewise.
	* ira.c: Likewise.
	* loop-invariant.c: Likewise.
	* loop-unroll.c: Likewise.
	* lower-subreg.c: Likewise.
	* lra-lives.c: Likewise.
	* lra.c: Likewise.
	* lto-cgraph.c: Likewise.
	* lto-section-out.c: Likewise.
	* lto-streamer-in.c: Likewise.
	* lto-streamer-out.c: Likewise.
	* lto-streamer.h: Likewise.
	* lto-symtab.c: Likewise.
	* mcf.c: Likewise.
	* modulo-sched.c: Likewise.
	* omp-low.c: Likewise.
	* opts-common.c: Likewise.
	* opts-global.c: Likewise.
	* opts.c: Likewise.
	* opts.h: Likewise.
	* passes.c: Likewise.
	* predict.c: Likewise.
	* print-tree.c: Likewise.
	* profile.c: Likewise.
	* profile.h: Likewise.
	* read-rtl.c: Likewise.
	* ree.c: Likewise.
	* reg-stack.c: Likewise.
	* regrename.c: Likewise.
	* regrename.h: Likewise.
	* reload.c: Likewise.
	* reload.h: Likewise.
	* reload1.c: Likewise.
	* rtl.h: Likewise.
	* sched-deps.c: Likewise.
	* sched-int.h: Likewise.
	* sdbout.c: Likewise.
	* sel-sched-dump.c: Likewise.
	* sel-sched-ir.c: Likewise.
	* sel-sched-ir.h: Likewise.
	* sel-sched.c: Likewise.
	* sese.c: Likewise.
	* sese.h: Likewise.
	* statistics.h: Likewise.
	* stmt.c: Likewise.
	* stor-layout.c: Likewise.
	* store-motion.c: Likewise.
	* tlink.c: Likewise.
	* toplev.c: Likewise.
	* trans-mem.c: Likewise.
	* tree-browser.c: Likewise.
	* tree-call-cdce.c: Likewise.
	* tree-cfg.c: Likewise.
	* tree-cfgcleanup.c: Likewise.
	* tree-chrec.c: Likewise.
	* tree-chrec.h: Likewise.
	* tree-complex.c: Likewise.
	* tree-data-ref.c: Likewise.
	* tree-data-ref.h: Likewise.
	* tree-dfa.c: Likewise.
	* tree-diagnostic.c: Likewise.
	* tree-dump.c: Likewise.
	* tree-eh.c: Likewise.
	* tree-emutls.c: Likewise.
	* tree-flow.h: Likewise.
	* tree-if-conv.c: Likewise.
	* tree-inline.c: Likewise.
	* tree-inline.h: Likewise.
	* tree-into-ssa.c: Likewise.
	* tree-iterator.c: Likewise.
	* tree-loop-distribution.c: Likewise.
	* tree-mudflap.c: Likewise.
	* tree-optimize.c: Likewise.
	* tree-outof-ssa.c: Likewise.
	* tree-parloops.c: Likewise.
	* tree-phinodes.c: Likewise.
	* tree-predcom.c: Likewise.
	* tree-pretty-print.c: Likewise.
	* tree-scalar-evolution.c: Likewise.
	* tree-sra.c: Likewise.
	* tree-ssa-address.c: Likewise.
	* tree-ssa-alias.c: Likewise.
	* tree-ssa-ccp.c: Likewise.
	* tree-ssa-coalesce.c: Likewise.
	* tree-ssa-dce.c: Likewise.
	* tree-ssa-dom.c: Likewise.
	* tree-ssa-forwprop.c: Likewise.
	* tree-ssa-live.c: Likewise.
	* tree-ssa-live.h: Likewise.
	* tree-ssa-loop-im.c: Likewise.
	* tree-ssa-loop-ivcanon.c: Likewise.
	* tree-ssa-loop-ivopts.c: Likewise.
	* tree-ssa-loop-manip.c: Likewise.
	* tree-ssa-loop-niter.c: Likewise.
	* tree-ssa-loop-prefetch.c: Likewise.
	* tree-ssa-math-opts.c: Likewise.
	* tree-ssa-operands.c: Likewise.
	* tree-ssa-phiopt.c: Likewise.
	* tree-ssa-phiprop.c: Likewise.
	* tree-ssa-pre.c: Likewise.
	* tree-ssa-propagate.c: Likewise.
	* tree-ssa-reassoc.c: Likewise.
	* tree-ssa-sccvn.c: Likewise.
	* tree-ssa-sccvn.h: Likewise.
	* tree-ssa-strlen.c: Likewise.
	* tree-ssa-structalias.c: Likewise.
	* tree-ssa-tail-merge.c: Likewise.
	* tree-ssa-threadedge.c: Likewise.
	* tree-ssa-threadupdate.c: Likewise.
	* tree-ssa-uncprop.c: Likewise.
	* tree-ssa-uninit.c: Likewise.
	* tree-ssa.c: Likewise.
	* tree-ssanames.c: Likewise.
	* tree-stdarg.c: Likewise.
	* tree-streamer-in.c: Likewise.
	* tree-streamer-out.c: Likewise.
	* tree-streamer.c: Likewise.
	* tree-streamer.h: Likewise.
	* tree-switch-conversion.c: Likewise.
	* tree-vect-data-refs.c: Likewise.
	* tree-vect-generic.c: Likewise.
	* tree-vect-loop-manip.c: Likewise.
	* tree-vect-loop.c: Likewise.
	* tree-vect-patterns.c: Likewise.
	* tree-vect-slp.c: Likewise.
	* tree-vect-stmts.c: Likewise.
	* tree-vectorizer.c: Likewise.
	* tree-vectorizer.h: Likewise.
	* tree-vrp.c: Likewise.
	* tree.c: Likewise.
	* tree.h: Likewise.
	* value-prof.c: Likewise.
	* value-prof.h: Likewise.
	* var-tracking.c: Likewise.
	* varasm.c: Likewise.
	* varpool.c: Likewise.
	* vmsdbgout.c: Likewise.
	* config/bfin/bfin.c: Likewise.
	* config/c6x/c6x.c: Likewise.
	* config/darwin.c: Likewise.
	* config/i386/i386.c: Likewise.
	* config/ia64/ia64.c: Likewise.
	* config/mep/mep.c: Likewise.
	* config/mips/mips.c: Likewise.
	* config/pa/pa.c: Likewise.
	* config/rs6000/rs6000-c.c: Likewise.
	* config/rs6000/rs6000.c: Likewise.
	* config/rx/rx.c: Likewise.
	* config/spu/spu-c.c: Likewise.
	* config/vms/vms.c: Likewise.
	* config/vxworks.c: Likewise.
	* config/epiphany/resolve-sw-modes.c: Likewise.

From-SVN: r193595

6 files changed, 208 insertions, 215 deletions

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 433b6b2..d018354 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,13 @@
+2012-11-16  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.
+
 2012-11-09  Eric Botcazou  <ebotcazou@adacore.com>
 
 	PR other/52438
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,