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

5 files changed, 152 insertions, 154 deletions

diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index cd3a457..e6ef408 100644
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,19 @@
+2012-11-16  Diego Novillo  <dnovillo@google.com>
+
+	Adjust for new vec API (http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec)
+
+	* c-common.c: Use new vec API in vec.h.
+	* c-common.h: Likewise.
+	* c-gimplify.c: Likewise.
+	* c-pragma.c: Likewise.
+	* c-pretty-print.c: Likewise.
+	* c-pretty-print.h: Likewise.
+	* c-semantics.c: Likewise.
+	* c-decl.c: Likewise.
+	* c-parser.c: Likewise.
+	* c-tree.h: Likewise.
+	* c-typeck.c: Likewise.
+
 2012-10-29  Jonathan Wakely  <jwakely.gcc@gmail.com>
 
 	PR c++/54930
diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c
index f031466..b1c88bd 100644
--- a/gcc/c/c-decl.c
+++ b/gcc/c/c-decl.c
@@ -286,8 +286,6 @@ struct GTY(()) c_goto_bindings {
 };
 
 typedef struct c_goto_bindings *c_goto_bindings_p;
-DEF_VEC_P(c_goto_bindings_p);
-DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);
 
 /* The additional information we keep track of for a label binding.
    These fields are updated as scopes are popped.  */
@@ -302,11 +300,11 @@ struct GTY(()) c_label_vars {
      warn if a goto branches to this label from later in the function.
      Decls are added to this list as scopes are popped.  We only add
      the decls that matter.  */
-  VEC(tree,gc) *decls_in_scope;
+  vec<tree, va_gc> *decls_in_scope;
   /* A list of goto statements to this label.  This is only used for
      goto statements seen before the label was defined, so that we can
      issue appropriate warnings for them.  */
-  VEC(c_goto_bindings_p,gc) *gotos;
+  vec<c_goto_bindings_p, va_gc> *gotos;
 };
 
 /* Each c_scope structure describes the complete contents of one
@@ -496,11 +494,9 @@ static bool keep_next_level_flag;
 
 static bool next_is_function_body;
 
-/* A VEC of pointers to c_binding structures.  */
+/* A vector of pointers to c_binding structures.  */
 
 typedef struct c_binding *c_binding_ptr;
-DEF_VEC_P(c_binding_ptr);
-DEF_VEC_ALLOC_P(c_binding_ptr,heap);
 
 /* Information that we keep for a struct or union while it is being
    parsed.  */
@@ -509,15 +505,15 @@ struct c_struct_parse_info
 {
   /* If warn_cxx_compat, a list of types defined within this
      struct.  */
-  VEC(tree,heap) *struct_types;
+  vec<tree> struct_types;
   /* If warn_cxx_compat, a list of field names which have bindings,
      and which are defined in this struct, but which are not defined
      in any enclosing struct.  This is used to clear the in_struct
      field of the c_bindings structure.  */
-  VEC(c_binding_ptr,heap) *fields;
+  vec<c_binding_ptr> fields;
   /* If warn_cxx_compat, a list of typedef names used when defining
      fields in this struct.  */
-  VEC(tree,heap) *typedefs_seen;
+  vec<tree> typedefs_seen;
 };
 
 /* Information for the struct or union currently being parsed, or
@@ -1019,16 +1015,14 @@ update_label_decls (struct c_scope *scope)
 			     of B1, if any.  Save it to issue a
 			     warning if needed.  */
 			  if (decl_jump_unsafe (b1->decl))
-			    VEC_safe_push (tree, gc,
-					   label_vars->decls_in_scope,
-					   b1->decl);
+			    vec_safe_push(label_vars->decls_in_scope, b1->decl);
 			}
 		    }
 		}
 
 	      /* Update the bindings of any goto statements associated
 		 with this label.  */
-	      FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+	      FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
 		update_spot_bindings (scope, &g->goto_bindings);
 	    }
 	}
@@ -1375,7 +1369,7 @@ c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
 	    continue;
 	  label_vars = b->u.label;
 	  ++label_vars->label_bindings.stmt_exprs;
-	  FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+	  FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
 	    ++g->goto_bindings.stmt_exprs;
 	}
     }
@@ -1413,7 +1407,7 @@ c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
 	      label_vars->label_bindings.left_stmt_expr = true;
 	      label_vars->label_bindings.stmt_exprs = 0;
 	    }
-	  FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+	  FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
 	    {
 	      --g->goto_bindings.stmt_exprs;
 	      if (g->goto_bindings.stmt_exprs < 0)
@@ -3056,7 +3050,7 @@ make_label (location_t location, tree name, bool defining,
   label_vars->shadowed = NULL;
   set_spot_bindings (&label_vars->label_bindings, defining);
   label_vars->decls_in_scope = make_tree_vector ();
-  label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
+  label_vars->gotos = NULL;
   *p_label_vars = label_vars;
 
   return label;
@@ -3153,7 +3147,7 @@ lookup_label_for_goto (location_t loc, tree name)
       g = ggc_alloc_c_goto_bindings ();
       g->loc = loc;
       set_spot_bindings (&g->goto_bindings, true);
-      VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
+      vec_safe_push (label_vars->gotos, g);
       return label;
     }
 
@@ -3165,7 +3159,7 @@ lookup_label_for_goto (location_t loc, tree name)
        ...
        goto lab;
      Issue a warning or error.  */
-  FOR_EACH_VEC_ELT (tree, label_vars->decls_in_scope, ix, decl)
+  FOR_EACH_VEC_SAFE_ELT (label_vars->decls_in_scope, ix, decl)
     warn_about_goto (loc, label, decl);
 
   if (label_vars->label_bindings.left_stmt_expr)
@@ -3217,7 +3211,7 @@ check_earlier_gotos (tree label, struct c_label_vars* label_vars)
   unsigned int ix;
   struct c_goto_bindings *g;
 
-  FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+  FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
     {
       struct c_binding *b;
       struct c_scope *scope;
@@ -3267,7 +3261,7 @@ check_earlier_gotos (tree label, struct c_label_vars* label_vars)
 
   /* Now that the label is defined, we will issue warnings about
      subsequent gotos to this label when we see them.  */
-  VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
+  vec_safe_truncate (label_vars->gotos, 0);
   label_vars->gotos = NULL;
 }
 
@@ -3939,10 +3933,10 @@ add_flexible_array_elts_to_size (tree decl, tree init)
 {
   tree elt, type;
 
-  if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
+  if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
     return;
 
-  elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init)).value;
+  elt = CONSTRUCTOR_ELTS (init)->last ().value;
   type = TREE_TYPE (elt);
   if (TREE_CODE (type) == ARRAY_TYPE
       && TYPE_SIZE (type) == NULL_TREE
@@ -4509,15 +4503,15 @@ finish_decl (tree decl, location_t init_loc, tree init,
 	  tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
 	  tree cleanup_decl = lookup_name (cleanup_id);
 	  tree cleanup;
-	  VEC(tree,gc) *vec;
+	  vec<tree, va_gc> *v;
 
 	  /* Build "cleanup(&decl)" for the destructor.  */
 	  cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
-	  vec = VEC_alloc (tree, gc, 1);
-	  VEC_quick_push (tree, vec, cleanup);
+	  vec_alloc (v, 1);
+	  v->quick_push (cleanup);
 	  cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
-	      				     cleanup_decl, vec, NULL);
-	  VEC_free (tree, gc, vec);
+	      				     cleanup_decl, v, NULL);
+	  vec_free (v);
 
 	  /* Don't warn about decl unused; the cleanup uses it.  */
 	  TREE_USED (decl) = 1;
@@ -5656,7 +5650,7 @@ grokdeclarator (const struct c_declarator *declarator,
 	      c_arg_tag *tag;
 	      unsigned ix;
 
-	      FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
+	      FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag)
 		TYPE_CONTEXT (tag->type) = type;
 	    }
 	    break;
@@ -6398,7 +6392,7 @@ get_parm_info (bool ellipsis, tree expr)
   struct c_arg_info *arg_info = build_arg_info ();
 
   tree parms    = 0;
-  VEC(c_arg_tag,gc) *tags = NULL;
+  vec<c_arg_tag, va_gc> *tags = NULL;
   tree types    = 0;
   tree others   = 0;
 
@@ -6523,7 +6517,7 @@ get_parm_info (bool ellipsis, tree expr)
 
 	  tag.id = b->id;
 	  tag.type = decl;
-	  VEC_safe_push (c_arg_tag, gc, tags, tag);
+	  vec_safe_push (tags, tag);
 	  break;
 
 	case CONST_DECL:
@@ -6735,9 +6729,9 @@ start_struct (location_t loc, enum tree_code code, tree name,
 
   *enclosing_struct_parse_info = struct_parse_info;
   struct_parse_info = XNEW (struct c_struct_parse_info);
-  struct_parse_info->struct_types = VEC_alloc (tree, heap, 0);
-  struct_parse_info->fields = VEC_alloc (c_binding_ptr, heap, 0);
-  struct_parse_info->typedefs_seen = VEC_alloc (tree, heap, 0);
+  struct_parse_info->struct_types.create (0);
+  struct_parse_info->fields.create (0);
+  struct_parse_info->typedefs_seen.create (0);
 
   /* FIXME: This will issue a warning for a use of a type defined
      within a statement expr used within sizeof, et. al.  This is not
@@ -6847,8 +6841,7 @@ grokfield (location_t loc,
 	     to be cleared when this struct is finished.  */
 	  if (!b->in_struct)
 	    {
-	      VEC_safe_push (c_binding_ptr, heap,
-			     struct_parse_info->fields, b);
+	      struct_parse_info->fields.safe_push (b);
 	      b->in_struct = 1;
 	    }
 	}
@@ -7028,7 +7021,7 @@ warn_cxx_compat_finish_struct (tree fieldlist)
      because the flag is used to issue visibility warnings, and we
      only want to issue those warnings if the type is referenced
      outside of the struct declaration.  */
-  FOR_EACH_VEC_ELT (tree, struct_parse_info->struct_types, ix, x)
+  FOR_EACH_VEC_ELT (struct_parse_info->struct_types, ix, x)
     C_TYPE_DEFINED_IN_STRUCT (x) = 1;
 
   /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
@@ -7037,14 +7030,14 @@ warn_cxx_compat_finish_struct (tree fieldlist)
      not parse in C++, because the C++ lookup rules say that the
      typedef name would be looked up in the context of the struct, and
      would thus be the field rather than the typedef.  */
-  if (!VEC_empty (tree, struct_parse_info->typedefs_seen)
+  if (!struct_parse_info->typedefs_seen.is_empty ()
       && fieldlist != NULL_TREE)
     {
       /* Use a pointer_set using the name of the typedef.  We can use
 	 a pointer_set because identifiers are interned.  */
       struct pointer_set_t *tset = pointer_set_create ();
 
-      FOR_EACH_VEC_ELT (tree, struct_parse_info->typedefs_seen, ix, x)
+      FOR_EACH_VEC_ELT (struct_parse_info->typedefs_seen, ix, x)
 	pointer_set_insert (tset, DECL_NAME (x));
 
       for (x = fieldlist; x != NULL_TREE; x = DECL_CHAIN (x))
@@ -7066,7 +7059,7 @@ warn_cxx_compat_finish_struct (tree fieldlist)
 
   /* For each field which has a binding and which was not defined in
      an enclosing struct, clear the in_struct field.  */
-  FOR_EACH_VEC_ELT (c_binding_ptr, struct_parse_info->fields, ix, b)
+  FOR_EACH_VEC_ELT (struct_parse_info->fields, ix, b)
     b->in_struct = 0;
 }
 
@@ -7353,9 +7346,9 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
   if (warn_cxx_compat)
     warn_cxx_compat_finish_struct (fieldlist);
 
-  VEC_free (tree, heap, struct_parse_info->struct_types);
-  VEC_free (c_binding_ptr, heap, struct_parse_info->fields);
-  VEC_free (tree, heap, struct_parse_info->typedefs_seen);
+  struct_parse_info->struct_types.release ();
+  struct_parse_info->fields.release ();
+  struct_parse_info->typedefs_seen.release ();
   XDELETE (struct_parse_info);
 
   struct_parse_info = enclosing_struct_parse_info;
@@ -7365,7 +7358,7 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
   if (warn_cxx_compat
       && struct_parse_info != NULL
       && !in_sizeof && !in_typeof && !in_alignof)
-    VEC_safe_push (tree, heap, struct_parse_info->struct_types, t);
+    struct_parse_info->struct_types.safe_push (t);
 
   return t;
 }
@@ -7583,7 +7576,7 @@ finish_enum (tree enumtype, tree values, tree attributes)
   if (warn_cxx_compat
       && struct_parse_info != NULL
       && !in_sizeof && !in_typeof && !in_alignof)
-    VEC_safe_push (tree, heap, struct_parse_info->struct_types, enumtype);
+    struct_parse_info->struct_types.safe_push (enumtype);
 
   return enumtype;
 }
@@ -7981,7 +7974,7 @@ store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
     }
 
   /* And all the tag declarations.  */
-  FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
+  FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag)
     if (tag->id)
       bind (tag->id, tag->type, current_scope,
 	    /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
@@ -8598,8 +8591,7 @@ c_push_function_context (void)
     cfun->language = p = ggc_alloc_cleared_language_function ();
 
   p->base.x_stmt_tree = c_stmt_tree;
-  c_stmt_tree.x_cur_stmt_list
-    = VEC_copy (tree, gc, c_stmt_tree.x_cur_stmt_list);
+  c_stmt_tree.x_cur_stmt_list = vec_safe_copy (c_stmt_tree.x_cur_stmt_list);
   p->x_break_label = c_break_label;
   p->x_cont_label = c_cont_label;
   p->x_switch_stack = c_switch_stack;
@@ -9538,7 +9530,7 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
 	  /* If we are parsing a struct, record that a struct field
 	     used a typedef.  */
 	  if (warn_cxx_compat && struct_parse_info != NULL)
-	    VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
+	    struct_parse_info->typedefs_seen.safe_push (type);
 	}
     }
   else if (TREE_CODE (type) == IDENTIFIER_NODE)
@@ -10040,7 +10032,7 @@ collect_all_refs (const char *source_file)
   tree t;
   unsigned i;
 
-  FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+  FOR_EACH_VEC_ELT (*all_translation_units, i, t)
     collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t)), source_file);
 
   collect_ada_nodes (BLOCK_VARS (ext_block), source_file);
@@ -10056,7 +10048,7 @@ for_each_global_decl (void (*callback) (tree decl))
   tree decl;
   unsigned i;
 
-  FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+  FOR_EACH_VEC_ELT (*all_translation_units, i, t)
     { 
       decls = DECL_INITIAL (t);
       for (decl = BLOCK_VARS (decls); decl; decl = TREE_CHAIN (decl))
@@ -10116,7 +10108,7 @@ c_write_global_declarations (void)
 
   /* Process all file scopes in this compilation, and the external_scope,
      through wrapup_global_declarations and check_global_declarations.  */
-  FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+  FOR_EACH_VEC_ELT (*all_translation_units, i, t)
     c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
   c_write_global_declarations_1 (BLOCK_VARS (ext_block));
 
@@ -10135,7 +10127,7 @@ c_write_global_declarations (void)
   if (!seen_error ())
     {
       timevar_push (TV_SYMOUT);
-      FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+      FOR_EACH_VEC_ELT (*all_translation_units, i, t)
 	c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
       c_write_global_declarations_2 (BLOCK_VARS (ext_block));
       timevar_pop (TV_SYMOUT);
diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
index bfa98af..d85bff0 100644
--- a/gcc/c/c-parser.c
+++ b/gcc/c/c-parser.c
@@ -1178,9 +1178,9 @@ static struct c_expr c_parser_transaction_expression (c_parser *, enum rid);
 static tree c_parser_transaction_cancel (c_parser *);
 static struct c_expr c_parser_expression (c_parser *);
 static struct c_expr c_parser_expression_conv (c_parser *);
-static VEC(tree,gc) *c_parser_expr_list (c_parser *, bool, bool,
-					 VEC(tree,gc) **, location_t *,
-					 tree *);
+static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool,
+					     vec<tree, va_gc> **, location_t *,
+					     tree *);
 static void c_parser_omp_construct (c_parser *);
 static void c_parser_omp_threadprivate (c_parser *);
 static void c_parser_omp_barrier (c_parser *);
@@ -3540,7 +3540,7 @@ c_parser_attributes (c_parser *parser)
 	     || c_parser_next_token_is (parser, CPP_KEYWORD))
 	{
 	  tree attr, attr_name, attr_args;
-	  VEC(tree,gc) *expr_list;
+	  vec<tree, va_gc> *expr_list;
 	  if (c_parser_next_token_is (parser, CPP_COMMA))
 	    {
 	      c_parser_consume_token (parser);
@@ -6123,10 +6123,10 @@ c_parser_alignof_expression (c_parser *parser)
    stores the arguments in CEXPR_LIST.  */
 static bool
 c_parser_get_builtin_args (c_parser *parser, const char *bname,
-			   VEC(c_expr_t,gc) **ret_cexpr_list)
+			   vec<c_expr_t, va_gc> **ret_cexpr_list)
 {
   location_t loc = c_parser_peek_token (parser)->location;
-  VEC (c_expr_t,gc) *cexpr_list;
+  vec<c_expr_t, va_gc> *cexpr_list;
   c_expr_t expr;
 
   *ret_cexpr_list = NULL;
@@ -6145,7 +6145,7 @@ c_parser_get_builtin_args (c_parser *parser, const char *bname,
     }
 
   expr = c_parser_expr_no_commas (parser, NULL);
-  cexpr_list = VEC_alloc (c_expr_t, gc, 1);
+  vec_alloc (cexpr_list, 1);
   C_EXPR_APPEND (cexpr_list, expr);
   while (c_parser_next_token_is (parser, CPP_COMMA))
     {
@@ -6511,7 +6511,7 @@ c_parser_postfix_expression (c_parser *parser)
 	  break;
 	case RID_CHOOSE_EXPR:
 	  {
-	    VEC (c_expr_t, gc) *cexpr_list;
+	    vec<c_expr_t, va_gc> *cexpr_list;
 	    c_expr_t *e1_p, *e2_p, *e3_p;
 	    tree c;
 
@@ -6524,7 +6524,7 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    if (VEC_length (c_expr_t, cexpr_list) != 3)
+	    if (vec_safe_length (cexpr_list) != 3)
 	      {
 		error_at (loc, "wrong number of arguments to "
 			       "%<__builtin_choose_expr%>");
@@ -6532,9 +6532,9 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    e1_p = &VEC_index (c_expr_t, cexpr_list, 0);
-	    e2_p = &VEC_index (c_expr_t, cexpr_list, 1);
-	    e3_p = &VEC_index (c_expr_t, cexpr_list, 2);
+	    e1_p = &(*cexpr_list)[0];
+	    e2_p = &(*cexpr_list)[1];
+	    e3_p = &(*cexpr_list)[2];
 
 	    c = e1_p->value;
 	    mark_exp_read (e2_p->value);
@@ -6594,7 +6594,7 @@ c_parser_postfix_expression (c_parser *parser)
 	  break;
 	case RID_BUILTIN_COMPLEX:
 	  {
-	    VEC(c_expr_t, gc) *cexpr_list;
+	    vec<c_expr_t, va_gc> *cexpr_list;
 	    c_expr_t *e1_p, *e2_p;
 
 	    c_parser_consume_token (parser);
@@ -6606,7 +6606,7 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    if (VEC_length (c_expr_t, cexpr_list) != 2)
+	    if (vec_safe_length (cexpr_list) != 2)
 	      {
 		error_at (loc, "wrong number of arguments to "
 			       "%<__builtin_complex%>");
@@ -6614,8 +6614,8 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    e1_p = &VEC_index (c_expr_t, cexpr_list, 0);
-	    e2_p = &VEC_index (c_expr_t, cexpr_list, 1);
+	    e1_p = &(*cexpr_list)[0];
+	    e2_p = &(*cexpr_list)[1];
 
 	    mark_exp_read (e1_p->value);
 	    if (TREE_CODE (e1_p->value) == EXCESS_PRECISION_EXPR)
@@ -6655,7 +6655,7 @@ c_parser_postfix_expression (c_parser *parser)
 	  }
 	case RID_BUILTIN_SHUFFLE:
 	  {
-	    VEC(c_expr_t,gc) *cexpr_list;
+	    vec<c_expr_t, va_gc> *cexpr_list;
 	    unsigned int i;
 	    c_expr_t *p;
 
@@ -6668,21 +6668,21 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    FOR_EACH_VEC_ELT (c_expr_t, cexpr_list, i, p)
+	    FOR_EACH_VEC_SAFE_ELT (cexpr_list, i, p)
 	      mark_exp_read (p->value);
 
-	    if (VEC_length (c_expr_t, cexpr_list) == 2)
+	    if (vec_safe_length (cexpr_list) == 2)
 	      expr.value =
 		c_build_vec_perm_expr
-		  (loc, VEC_index (c_expr_t, cexpr_list, 0).value,
-		   NULL_TREE, VEC_index (c_expr_t, cexpr_list, 1).value);
+		  (loc, (*cexpr_list)[0].value,
+		   NULL_TREE, (*cexpr_list)[1].value);
 
-	    else if (VEC_length (c_expr_t, cexpr_list) == 3)
+	    else if (vec_safe_length (cexpr_list) == 3)
 	      expr.value =
 		c_build_vec_perm_expr
-		  (loc, VEC_index (c_expr_t, cexpr_list, 0).value,
-		   VEC_index (c_expr_t, cexpr_list, 1).value,
-		   VEC_index (c_expr_t, cexpr_list, 2).value);
+		  (loc, (*cexpr_list)[0].value,
+		   (*cexpr_list)[1].value,
+		   (*cexpr_list)[2].value);
 	    else
 	      {
 		error_at (loc, "wrong number of arguments to "
@@ -6872,8 +6872,8 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
   location_t sizeof_arg_loc[3];
   tree sizeof_arg[3];
   unsigned int i;
-  VEC(tree,gc) *exprlist;
-  VEC(tree,gc) *origtypes;
+  vec<tree, va_gc> *exprlist;
+  vec<tree, va_gc> *origtypes;
   while (true)
     {
       location_t op_loc = c_parser_peek_token (parser)->location;
@@ -6922,7 +6922,7 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
 	      && DECL_FUNCTION_CODE (orig_expr.value) == BUILT_IN_CONSTANT_P)
 	    expr.original_code = C_MAYBE_CONST_EXPR;
 	  expr.original_type = NULL;
-	  if (exprlist != NULL)
+	  if (exprlist)
 	    {
 	      release_tree_vector (exprlist);
 	      release_tree_vector (origtypes);
@@ -7069,13 +7069,13 @@ c_parser_expression_conv (c_parser *parser)
      nonempty-expr-list , assignment-expression
 */
 
-static VEC(tree,gc) *
+static vec<tree, va_gc> *
 c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
-		    VEC(tree,gc) **p_orig_types, location_t *sizeof_arg_loc,
-		    tree *sizeof_arg)
+		    vec<tree, va_gc> **p_orig_types,
+		    location_t *sizeof_arg_loc, tree *sizeof_arg)
 {
-  VEC(tree,gc) *ret;
-  VEC(tree,gc) *orig_types;
+  vec<tree, va_gc> *ret;
+  vec<tree, va_gc> *orig_types;
   struct c_expr expr;
   location_t loc = c_parser_peek_token (parser)->location;
   location_t cur_sizeof_arg_loc = UNKNOWN_LOCATION;
@@ -7095,9 +7095,9 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
     expr = default_function_array_read_conversion (loc, expr);
   if (fold_p)
     expr.value = c_fully_fold (expr.value, false, NULL);
-  VEC_quick_push (tree, ret, expr.value);
-  if (orig_types != NULL)
-    VEC_quick_push (tree, orig_types, expr.original_type);
+  ret->quick_push (expr.value);
+  if (orig_types)
+    orig_types->quick_push (expr.original_type);
   if (sizeof_arg != NULL
       && cur_sizeof_arg_loc != UNKNOWN_LOCATION
       && expr.original_code == SIZEOF_EXPR)
@@ -7119,9 +7119,9 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
 	expr = default_function_array_read_conversion (loc, expr);
       if (fold_p)
 	expr.value = c_fully_fold (expr.value, false, NULL);
-      VEC_safe_push (tree, gc, ret, expr.value);
-      if (orig_types != NULL)
-	VEC_safe_push (tree, gc, orig_types, expr.original_type);
+      vec_safe_push (ret, expr.value);
+      if (orig_types)
+	vec_safe_push (orig_types, expr.original_type);
       if (++idx < 3
 	  && sizeof_arg != NULL
 	  && cur_sizeof_arg_loc != UNKNOWN_LOCATION
@@ -7131,7 +7131,7 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
 	  sizeof_arg_loc[idx] = cur_sizeof_arg_loc;
 	}
     }
-  if (orig_types != NULL)
+  if (orig_types)
     *p_orig_types = orig_types;
   return ret;
 }
@@ -8209,13 +8209,13 @@ static tree
 c_parser_objc_keywordexpr (c_parser *parser)
 {
   tree ret;
-  VEC(tree,gc) *expr_list = c_parser_expr_list (parser, true, true,
+  vec<tree, va_gc> *expr_list = c_parser_expr_list (parser, true, true,
 						NULL, NULL, NULL);
-  if (VEC_length (tree, expr_list) == 1)
+  if (vec_safe_length (expr_list) == 1)
     {
       /* Just return the expression, remove a level of
 	 indirection.  */
-      ret = VEC_index (tree, expr_list, 0);
+      ret = (*expr_list)[0];
     }
   else
     {
@@ -9923,7 +9923,7 @@ c_parser_omp_for_loop (location_t loc,
   bool fail = false, open_brace_parsed = false;
   int i, collapse = 1, nbraces = 0;
   location_t for_loc;
-  VEC(tree,gc) *for_block = make_tree_vector ();
+  vec<tree, va_gc> *for_block = make_tree_vector ();
 
   for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
     if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
@@ -9955,7 +9955,7 @@ c_parser_omp_for_loop (location_t loc,
       if (c_parser_next_tokens_start_declaration (parser))
 	{
 	  if (i > 0)
-	    VEC_safe_push (tree, gc, for_block, c_begin_compound_stmt (true));
+	    vec_safe_push (for_block, c_begin_compound_stmt (true));
 	  c_parser_declaration_or_fndef (parser, true, true, true, true, true, NULL);
 	  decl = check_for_loop_decls (for_loc, flag_isoc99);
 	  if (decl == NULL)
@@ -10186,12 +10186,12 @@ c_parser_omp_for_loop (location_t loc,
       ret = stmt;
     }
 pop_scopes:
-  while (!VEC_empty (tree, for_block))
+  while (!for_block->is_empty ())
     {
       /* FIXME diagnostics: LOC below should be the actual location of
 	 this particular for block.  We need to build a list of
 	 locations to go along with FOR_BLOCK.  */
-      stmt = c_end_compound_stmt (loc, VEC_pop (tree, for_block), true);
+      stmt = c_end_compound_stmt (loc, for_block->pop (), true);
       add_stmt (stmt);
     }
   release_tree_vector (for_block);
diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index 17fc719..531cc7c 100644
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -135,15 +135,12 @@ struct c_expr
 typedef struct c_expr c_expr_t;
 
 /* A varray of c_expr_t.  */
-DEF_VEC_O (c_expr_t);
-DEF_VEC_ALLOC_O (c_expr_t, gc);
-DEF_VEC_ALLOC_O (c_expr_t, heap);
 
 /* Append a new c_expr_t element to V.  */
 #define C_EXPR_APPEND(V, ELEM) \
   do { \
     c_expr_t __elem = (ELEM); \
-    VEC_safe_push (c_expr_t, gc, V, __elem); \
+    vec_safe_push (V, __elem); \
   } while (0)
 
 /* A kind of type specifier.  Note that this information is currently
@@ -363,15 +360,13 @@ typedef struct c_arg_tag_d {
   tree type;
 } c_arg_tag;
 
-DEF_VEC_O(c_arg_tag);
-DEF_VEC_ALLOC_O(c_arg_tag,gc);
 
 /* Information about the parameters in a function declarator.  */
 struct c_arg_info {
   /* A list of parameter decls.  */
   tree parms;
   /* A list of structure, union and enum tags defined.  */
-  VEC(c_arg_tag,gc) *tags;
+  vec<c_arg_tag, va_gc> *tags;
   /* A list of argument types to go in the FUNCTION_TYPE.  */
   tree types;
   /* A list of non-parameter decls (notably enumeration constants)
diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index cf63355..2032f66 100644
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -80,8 +80,8 @@ static int function_types_compatible_p (const_tree, const_tree, bool *,
 					bool *);
 static int type_lists_compatible_p (const_tree, const_tree, bool *, bool *);
 static tree lookup_field (tree, tree);
-static int convert_arguments (tree, VEC(tree,gc) *, VEC(tree,gc) *, tree,
-			      tree);
+static int convert_arguments (tree, vec<tree, va_gc> *, vec<tree, va_gc> *,
+			      tree, tree);
 static tree pointer_diff (location_t, tree, tree);
 static tree convert_for_assignment (location_t, tree, tree, tree,
 				    enum impl_conv, bool, tree, tree, int);
@@ -2662,14 +2662,14 @@ c_expr_sizeof_type (location_t loc, struct c_type_name *t)
 tree
 build_function_call (location_t loc, tree function, tree params)
 {
-  VEC(tree,gc) *vec;
+  vec<tree, va_gc> *v;
   tree ret;
 
-  vec = VEC_alloc (tree, gc, list_length (params));
+  vec_alloc (v, list_length (params));
   for (; params; params = TREE_CHAIN (params))
-    VEC_quick_push (tree, vec, TREE_VALUE (params));
-  ret = build_function_call_vec (loc, function, vec, NULL);
-  VEC_free (tree, gc, vec);
+    v->quick_push (TREE_VALUE (params));
+  ret = build_function_call_vec (loc, function, v, NULL);
+  vec_free (v);
   return ret;
 }
 
@@ -2690,8 +2690,9 @@ static void inform_declaration (tree decl)
    PARAMS.  */
 
 tree
-build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
-			 VEC(tree,gc) *origtypes)
+build_function_call_vec (location_t loc, tree function,
+			 vec<tree, va_gc> *params,
+			 vec<tree, va_gc> *origtypes)
 {
   tree fntype, fundecl = 0;
   tree name = NULL_TREE, result;
@@ -2729,9 +2730,8 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
 
   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
      expressions, like those used for ObjC messenger dispatches.  */
-  if (!VEC_empty (tree, params))
-    function = objc_rewrite_function_call (function,
-					   VEC_index (tree, params, 0));
+  if (params && !params->is_empty ())
+    function = objc_rewrite_function_call (function, (*params)[0]);
 
   function = c_fully_fold (function, false, NULL);
 
@@ -2800,8 +2800,7 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
       /* Before the abort, allow the function arguments to exit or
 	 call longjmp.  */
       for (i = 0; i < nargs; i++)
-	trap = build2 (COMPOUND_EXPR, void_type_node,
-		       VEC_index (tree, params, i), trap);
+	trap = build2 (COMPOUND_EXPR, void_type_node, (*params)[i], trap);
 
       if (VOID_TYPE_P (return_type))
 	{
@@ -2816,7 +2815,8 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
 
 	  if (AGGREGATE_TYPE_P (return_type))
 	    rhs = build_compound_literal (loc, return_type,
-					  build_constructor (return_type, 0),
+					  build_constructor (return_type,
+					    NULL),
 					  false);
 	  else
 	    rhs = build_zero_cst (return_type);
@@ -2826,7 +2826,7 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
 	}
     }
 
-  argarray = VEC_address (tree, params);
+  argarray = vec_safe_address (params);
 
   /* Check that arguments to builtin functions match the expectations.  */
   if (fundecl
@@ -2886,8 +2886,8 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
    failure.  */
 
 static int
-convert_arguments (tree typelist, VEC(tree,gc) *values,
-		   VEC(tree,gc) *origtypes, tree function, tree fundecl)
+convert_arguments (tree typelist, vec<tree, va_gc> *values,
+		   vec<tree, va_gc> *origtypes, tree function, tree fundecl)
 {
   tree typetail, val;
   unsigned int parmnum;
@@ -2934,7 +2934,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
      converted arguments.  */
 
   for (typetail = typelist, parmnum = 0;
-       VEC_iterate (tree, values, parmnum, val);
+       values && values->iterate (parmnum, &val);
        ++parmnum)
     {
       tree type = typetail ? TREE_VALUE (typetail) : 0;
@@ -3127,9 +3127,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
 		 sake of better warnings from convert_and_check.  */
 	      if (excess_precision)
 		val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
-	      origtype = (origtypes == NULL
-			  ? NULL_TREE
-			  : VEC_index (tree, origtypes, parmnum));
+	      origtype = (!origtypes) ? NULL_TREE : (*origtypes)[parmnum];
 	      parmval = convert_for_assignment (input_location, type, val,
 						origtype, ic_argpass, npc,
 						fundecl, function,
@@ -3173,7 +3171,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
 	/* Convert `short' and `char' to full-size `int'.  */
 	parmval = default_conversion (val);
 
-      VEC_replace (tree, values, parmnum, parmval);
+      (*values)[parmnum] = parmval;
       if (parmval == error_mark_node)
 	error_args = true;
 
@@ -3181,7 +3179,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
 	typetail = TREE_CHAIN (typetail);
     }
 
-  gcc_assert (parmnum == VEC_length (tree, values));
+  gcc_assert (parmnum == vec_safe_length (values));
 
   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
     {
@@ -6341,7 +6339,7 @@ static tree constructor_bit_index;
 /* If we are saving up the elements rather than allocating them,
    this is the list of elements so far (in reverse order,
    most recent first).  */
-static VEC(constructor_elt,gc) *constructor_elements;
+static vec<constructor_elt, va_gc> *constructor_elements;
 
 /* 1 if constructor should be incrementally stored into a constructor chain,
    0 if all the elements should be kept in AVL tree.  */
@@ -6417,7 +6415,7 @@ struct constructor_stack
   tree unfilled_index;
   tree unfilled_fields;
   tree bit_index;
-  VEC(constructor_elt,gc) *elements;
+  vec<constructor_elt, va_gc> *elements;
   struct init_node *pending_elts;
   int offset;
   int depth;
@@ -6462,7 +6460,7 @@ struct initializer_stack
   tree decl;
   struct constructor_stack *constructor_stack;
   struct constructor_range_stack *constructor_range_stack;
-  VEC(constructor_elt,gc) *elements;
+  vec<constructor_elt, va_gc> *elements;
   struct spelling *spelling;
   struct spelling *spelling_base;
   int spelling_size;
@@ -6611,7 +6609,7 @@ really_start_incremental_init (tree type)
   constructor_simple = 1;
   constructor_nonconst = 0;
   constructor_depth = SPELLING_DEPTH ();
-  constructor_elements = 0;
+  constructor_elements = NULL;
   constructor_pending_elts = 0;
   constructor_type = type;
   constructor_incremental = 1;
@@ -6757,7 +6755,7 @@ push_init_level (int implicit, struct obstack * braced_init_obstack)
   constructor_simple = 1;
   constructor_nonconst = 0;
   constructor_depth = SPELLING_DEPTH ();
-  constructor_elements = 0;
+  constructor_elements = NULL;
   constructor_incremental = 1;
   constructor_designated = 0;
   constructor_pending_elts = 0;
@@ -6807,7 +6805,7 @@ push_init_level (int implicit, struct obstack * braced_init_obstack)
       constructor_simple = TREE_STATIC (value);
       constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
       constructor_elements = CONSTRUCTOR_ELTS (value);
-      if (!VEC_empty (constructor_elt, constructor_elements)
+      if (!vec_safe_is_empty (constructor_elements)
 	  && (TREE_CODE (constructor_type) == RECORD_TYPE
 	      || TREE_CODE (constructor_type) == ARRAY_TYPE))
 	set_nonincremental_init (braced_init_obstack);
@@ -6957,9 +6955,8 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack)
       && constructor_unfilled_fields)
     {
 	bool constructor_zeroinit =
-	 (VEC_length (constructor_elt, constructor_elements) == 1
-	  && integer_zerop
-	      (VEC_index (constructor_elt, constructor_elements, 0).value));
+	 (vec_safe_length (constructor_elements) == 1
+	  && integer_zerop ((*constructor_elements)[0].value));
 
 	/* Do not warn for flexible array members or zero-length arrays.  */
 	while (constructor_unfilled_fields
@@ -6997,19 +6994,19 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack)
     {
       /* A nonincremental scalar initializer--just return
 	 the element, after verifying there is just one.  */
-      if (VEC_empty (constructor_elt,constructor_elements))
+      if (vec_safe_is_empty (constructor_elements))
 	{
 	  if (!constructor_erroneous)
 	    error_init ("empty scalar initializer");
 	  ret.value = error_mark_node;
 	}
-      else if (VEC_length (constructor_elt,constructor_elements) != 1)
+      else if (vec_safe_length (constructor_elements) != 1)
 	{
 	  error_init ("extra elements in scalar initializer");
-	  ret.value = VEC_index (constructor_elt,constructor_elements,0).value;
+	  ret.value = (*constructor_elements)[0].value;
 	}
       else
-	ret.value = VEC_index (constructor_elt,constructor_elements,0).value;
+	ret.value = (*constructor_elements)[0].value;
     }
   else
     {
@@ -7534,7 +7531,7 @@ set_nonincremental_init (struct obstack * braced_init_obstack)
       add_pending_init (index, value, NULL_TREE, true,
 			braced_init_obstack);
     }
-  constructor_elements = 0;
+  constructor_elements = NULL;
   if (TREE_CODE (constructor_type) == RECORD_TYPE)
     {
       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
@@ -7679,10 +7676,9 @@ find_init_member (tree field, struct obstack * braced_init_obstack)
     }
   else if (TREE_CODE (constructor_type) == UNION_TYPE)
     {
-      if (!VEC_empty (constructor_elt, constructor_elements)
-	  && (VEC_last (constructor_elt, constructor_elements).index
-	      == field))
-	return VEC_last (constructor_elt, constructor_elements).value;
+      if (!vec_safe_is_empty (constructor_elements)
+	  && (constructor_elements->last ().index == field))
+	return constructor_elements->last ().value;
     }
   return 0;
 }
@@ -7859,12 +7855,11 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type,
       return;
     }
   else if (TREE_CODE (constructor_type) == UNION_TYPE
-	   && !VEC_empty (constructor_elt, constructor_elements))
+	   && !vec_safe_is_empty (constructor_elements))
     {
       if (!implicit)
 	{
-	  if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
-					   constructor_elements).value))
+	  if (TREE_SIDE_EFFECTS (constructor_elements->last ().value))
 	    warning_init (0,
 			  "initialized field with side-effects overwritten");
 	  else if (warn_override_init)
@@ -7872,14 +7867,14 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type,
 	}
 
       /* We can have just one union field set.  */
-      constructor_elements = 0;
+      constructor_elements = NULL;
     }
 
   /* Otherwise, output this element either to
      constructor_elements or to the assembler file.  */
 
   constructor_elt celt = {field, value};
-  VEC_safe_push (constructor_elt, gc, constructor_elements, celt);
+  vec_safe_push (constructor_elements, celt);
 
   /* Advance the variable that indicates sequential elements output.  */
   if (TREE_CODE (constructor_type) == ARRAY_TYPE)