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

1 files changed, 78 insertions, 75 deletions

diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 0919d9f..8d555f8 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -231,9 +231,10 @@ pop_gimplify_context (gimple body)
 {
   struct gimplify_ctx *c = gimplify_ctxp;
 
-  gcc_assert (c && (c->bind_expr_stack == NULL
-		    || VEC_empty (gimple, c->bind_expr_stack)));
-  VEC_free (gimple, heap, c->bind_expr_stack);
+  gcc_assert (c
+              && (!c->bind_expr_stack.exists ()
+		  || c->bind_expr_stack.is_empty ()));
+  c->bind_expr_stack.release ();
   gimplify_ctxp = c->prev_context;
 
   if (body)
@@ -250,9 +251,8 @@ pop_gimplify_context (gimple body)
 static void
 gimple_push_bind_expr (gimple gimple_bind)
 {
-  if (gimplify_ctxp->bind_expr_stack == NULL)
-    gimplify_ctxp->bind_expr_stack = VEC_alloc (gimple, heap, 8);
-  VEC_safe_push (gimple, heap, gimplify_ctxp->bind_expr_stack, gimple_bind);
+  gimplify_ctxp->bind_expr_stack.reserve (8);
+  gimplify_ctxp->bind_expr_stack.safe_push (gimple_bind);
 }
 
 /* Pop the first element off the stack of bindings.  */
@@ -260,7 +260,7 @@ gimple_push_bind_expr (gimple gimple_bind)
 static void
 gimple_pop_bind_expr (void)
 {
-  VEC_pop (gimple, gimplify_ctxp->bind_expr_stack);
+  gimplify_ctxp->bind_expr_stack.pop ();
 }
 
 /* Return the first element of the stack of bindings.  */
@@ -268,12 +268,12 @@ gimple_pop_bind_expr (void)
 gimple
 gimple_current_bind_expr (void)
 {
-  return VEC_last (gimple, gimplify_ctxp->bind_expr_stack);
+  return gimplify_ctxp->bind_expr_stack.last ();
 }
 
 /* Return the stack of bindings created during gimplification.  */
 
-VEC(gimple, heap) *
+vec<gimple> 
 gimple_bind_expr_stack (void)
 {
   return gimplify_ctxp->bind_expr_stack;
@@ -1258,7 +1258,8 @@ gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
 	  && !is_gimple_reg (t)
 	  && flag_stack_reuse != SR_NONE)
 	{
-	  tree clobber = build_constructor (TREE_TYPE (t), NULL);
+	  tree clobber = build_constructor (TREE_TYPE (t),
+					    NULL);
 	  TREE_THIS_VOLATILE (clobber) = 1;
 	  gimplify_seq_add_stmt (&cleanup, gimple_build_assign (t, clobber));
 	}
@@ -1569,9 +1570,9 @@ compare_case_labels (const void *p1, const void *p2)
 /* Sort the case labels in LABEL_VEC in place in ascending order.  */
 
 void
-sort_case_labels (VEC(tree,heap)* label_vec)
+sort_case_labels (vec<tree> label_vec)
 {
-  VEC_qsort (tree, label_vec, compare_case_labels);
+  label_vec.qsort (compare_case_labels);
 }
 
 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
@@ -1594,7 +1595,7 @@ sort_case_labels (VEC(tree,heap)* label_vec)
    found or not.  */
 
 void
-preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels,
+preprocess_case_label_vec_for_gimple (vec<tree> labels,
 				      tree index_type,
 				      tree *default_casep)
 {
@@ -1605,9 +1606,9 @@ preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels,
   i = 0;
   min_value = TYPE_MIN_VALUE (index_type);
   max_value = TYPE_MAX_VALUE (index_type);
-  while (i < VEC_length (tree, labels))
+  while (i < labels.length ())
     {
-      tree elt = VEC_index (tree, labels, i);
+      tree elt = labels[i];
       tree low = CASE_LOW (elt);
       tree high = CASE_HIGH (elt);
       bool remove_element = FALSE;
@@ -1696,13 +1697,13 @@ preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels,
 	}
 
       if (remove_element)
-	VEC_ordered_remove (tree, labels, i);
+	labels.ordered_remove (i);
       else
 	i++;
     }
   len = i;
 
-  if (!VEC_empty (tree, labels))
+  if (!labels.is_empty ())
     sort_case_labels (labels);
 
   if (default_casep && !default_case)
@@ -1714,20 +1715,20 @@ preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels,
       if (len
 	  && TYPE_MIN_VALUE (index_type)
 	  && TYPE_MAX_VALUE (index_type)
-	  && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
+	  && tree_int_cst_equal (CASE_LOW (labels[0]),
 				 TYPE_MIN_VALUE (index_type)))
 	{
-	  tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
+	  tree low, high = CASE_HIGH (labels[len - 1]);
 	  if (!high)
-	    high = CASE_LOW (VEC_index (tree, labels, len - 1));
+	    high = CASE_LOW (labels[len - 1]);
 	  if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
 	    {
 	      for (i = 1; i < len; i++)
 		{
-		  high = CASE_LOW (VEC_index (tree, labels, i));
-		  low = CASE_HIGH (VEC_index (tree, labels, i - 1));
+		  high = CASE_LOW (labels[i]);
+		  low = CASE_HIGH (labels[i - 1]);
 		  if (!low)
-		    low = CASE_LOW (VEC_index (tree, labels, i - 1));
+		    low = CASE_LOW (labels[i - 1]);
 		  if ((TREE_INT_CST_LOW (low) + 1
 		       != TREE_INT_CST_LOW (high))
 		      || (TREE_INT_CST_HIGH (low)
@@ -1737,7 +1738,7 @@ preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels,
 		}
 	      if (i == len)
 		{
-		  tree label = CASE_LABEL (VEC_index (tree, labels, 0));
+		  tree label = CASE_LABEL (labels[0]);
 		  default_case = build_case_label (NULL_TREE, NULL_TREE,
 						   label);
 		}
@@ -1769,8 +1770,8 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
 
   if (SWITCH_BODY (switch_expr))
     {
-      VEC (tree,heap) *labels;
-      VEC (tree,heap) *saved_labels;
+      vec<tree> labels;
+      vec<tree> saved_labels;
       tree default_case = NULL_TREE;
       gimple gimple_switch;
 
@@ -1781,7 +1782,7 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
       /* Save old labels, get new ones from body, then restore the old
          labels.  Save all the things from the switch body to append after.  */
       saved_labels = gimplify_ctxp->case_labels;
-      gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
+      gimplify_ctxp->case_labels.create (8);
 
       gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
       labels = gimplify_ctxp->case_labels;
@@ -1805,7 +1806,7 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
 					   default_case, labels);
       gimplify_seq_add_stmt (pre_p, gimple_switch);
       gimplify_seq_add_seq (pre_p, switch_body_seq);
-      VEC_free(tree, heap, labels);
+      labels.release ();
     }
   else
     gcc_assert (SWITCH_LABELS (switch_expr));
@@ -1825,11 +1826,11 @@ gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
      #pragma omp parallel.  At least in the C front end, we don't
      detect such invalid branches until after gimplification.  */
   for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
-    if (ctxp->case_labels)
+    if (ctxp->case_labels.exists ())
       break;
 
   gimple_label = gimple_build_label (CASE_LABEL (*expr_p));
-  VEC_safe_push (tree, heap, ctxp->case_labels, *expr_p);
+  ctxp->case_labels.safe_push (*expr_p);
   gimplify_seq_add_stmt (pre_p, gimple_label);
 
   return GS_ALL_DONE;
@@ -2129,7 +2130,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 			fallback_t fallback)
 {
   tree *p;
-  VEC(tree,heap) *expr_stack;
+  vec<tree> expr_stack;
   enum gimplify_status ret = GS_ALL_DONE, tret;
   int i;
   location_t loc = EXPR_LOCATION (*expr_p);
@@ -2137,7 +2138,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 
   /* Create a stack of the subexpressions so later we can walk them in
      order from inner to outer.  */
-  expr_stack = VEC_alloc (tree, heap, 10);
+  expr_stack.create (10);
 
   /* We can handle anything that get_inner_reference can deal with.  */
   for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
@@ -2157,10 +2158,10 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
       else
 	break;
 
-      VEC_safe_push (tree, heap, expr_stack, *p);
+      expr_stack.safe_push (*p);
     }
 
-  gcc_assert (VEC_length (tree, expr_stack));
+  gcc_assert (expr_stack.length ());
 
   /* Now EXPR_STACK is a stack of pointers to all the refs we've
      walked through and P points to the innermost expression.
@@ -2174,9 +2175,9 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
      So we do this in three steps.  First we deal with the annotations
      for any variables in the components, then we gimplify the base,
      then we gimplify any indices, from left to right.  */
-  for (i = VEC_length (tree, expr_stack) - 1; i >= 0; i--)
+  for (i = expr_stack.length () - 1; i >= 0; i--)
     {
-      tree t = VEC_index (tree, expr_stack, i);
+      tree t = expr_stack[i];
 
       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
 	{
@@ -2269,9 +2270,9 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 
   /* And finally, the indices and operands of ARRAY_REF.  During this
      loop we also remove any useless conversions.  */
-  for (; VEC_length (tree, expr_stack) > 0; )
+  for (; expr_stack.length () > 0; )
     {
-      tree t = VEC_pop (tree, expr_stack);
+      tree t = expr_stack.pop ();
 
       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
 	{
@@ -2299,7 +2300,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
       canonicalize_component_ref (expr_p);
     }
 
-  VEC_free (tree, heap, expr_stack);
+  expr_stack.release ();
 
   gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
 
@@ -3461,7 +3462,7 @@ gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
     from = TREE_OPERAND (from, 0);
 
   gcc_assert (TREE_CODE (from) == CONSTRUCTOR
-	      && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
+	      && vec_safe_is_empty (CONSTRUCTOR_ELTS (from)));
 
   /* Now proceed.  */
   to = TREE_OPERAND (*expr_p, 0);
@@ -3572,9 +3573,9 @@ gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
     {
       unsigned HOST_WIDE_INT ix;
       constructor_elt *ce;
-      VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
+      vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (*expr_p);
 
-      FOR_EACH_VEC_ELT (constructor_elt, v, ix, ce)
+      FOR_EACH_VEC_SAFE_ELT (v, ix, ce)
 	gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
 
       return;
@@ -3634,7 +3635,7 @@ gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
    Note that we never have to deal with SAVE_EXPRs here, because this has
    already been taken care of for us, in gimplify_init_ctor_preeval().  */
 
-static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
+static void gimplify_init_ctor_eval (tree, vec<constructor_elt, va_gc> *,
 				     gimple_seq *, bool);
 
 static void
@@ -3720,7 +3721,7 @@ zero_sized_type (const_tree type)
    zeroed first.  */
 
 static void
-gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
+gimplify_init_ctor_eval (tree object, vec<constructor_elt, va_gc> *elts,
 			 gimple_seq *pre_p, bool cleared)
 {
   tree array_elt_type = NULL;
@@ -3876,12 +3877,12 @@ static tree
 optimize_compound_literals_in_ctor (tree orig_ctor)
 {
   tree ctor = orig_ctor;
-  VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
-  unsigned int idx, num = VEC_length (constructor_elt, elts);
+  vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ctor);
+  unsigned int idx, num = vec_safe_length (elts);
 
   for (idx = 0; idx < num; idx++)
     {
-      tree value = VEC_index (constructor_elt, elts, idx).value;
+      tree value = (*elts)[idx].value;
       tree newval = value;
       if (TREE_CODE (value) == CONSTRUCTOR)
 	newval = optimize_compound_literals_in_ctor (value);
@@ -3903,10 +3904,10 @@ optimize_compound_literals_in_ctor (tree orig_ctor)
       if (ctor == orig_ctor)
 	{
 	  ctor = copy_node (orig_ctor);
-	  CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
+	  CONSTRUCTOR_ELTS (ctor) = vec_safe_copy (elts);
 	  elts = CONSTRUCTOR_ELTS (ctor);
 	}
-      VEC_index (constructor_elt, elts, idx).value = newval;
+      (*elts)[idx].value = newval;
     }
   return ctor;
 }
@@ -3930,7 +3931,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 {
   tree object, ctor, type;
   enum gimplify_status ret;
-  VEC(constructor_elt,gc) *elts;
+  vec<constructor_elt, va_gc> *elts;
 
   gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
 
@@ -3963,7 +3964,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	/* Aggregate types must lower constructors to initialization of
 	   individual elements.  The exception is that a CONSTRUCTOR node
 	   with no elements indicates zero-initialization of the whole.  */
-	if (VEC_empty (constructor_elt, elts))
+	if (vec_safe_is_empty (elts))
 	  {
 	    if (notify_temp_creation)
 	      return GS_OK;
@@ -4099,7 +4100,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	if (TREE_THIS_VOLATILE (object)
 	    && !TREE_ADDRESSABLE (type)
 	    && num_nonzero_elements > 0
-	    && VEC_length (constructor_elt, elts) > 1)
+	    && vec_safe_length (elts) > 1)
 	  {
 	    tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type), NULL);
 	    TREE_OPERAND (*expr_p, 0) = temp;
@@ -4156,9 +4157,9 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	  return GS_OK;
 
 	/* Extract the real and imaginary parts out of the ctor.  */
-	gcc_assert (VEC_length (constructor_elt, elts) == 2);
-	r = VEC_index (constructor_elt, elts, 0).value;
-	i = VEC_index (constructor_elt, elts, 1).value;
+	gcc_assert (elts->length () == 2);
+	r = (*elts)[0].value;
+	i = (*elts)[1].value;
 	if (r == NULL || i == NULL)
 	  {
 	    tree zero = build_zero_cst (TREE_TYPE (type));
@@ -4230,7 +4231,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 
 	/* Vector types use CONSTRUCTOR all the way through gimple
 	  compilation as a general initializer.  */
-	FOR_EACH_VEC_ELT (constructor_elt, elts, ix, ce)
+	FOR_EACH_VEC_SAFE_ELT (elts, ix, ce)
 	  {
 	    enum gimplify_status tret;
 	    tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
@@ -5223,17 +5224,20 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
   bool allows_mem, allows_reg, is_inout;
   enum gimplify_status ret, tret;
   gimple stmt;
-  VEC(tree, gc) *inputs;
-  VEC(tree, gc) *outputs;
-  VEC(tree, gc) *clobbers;
-  VEC(tree, gc) *labels;
+  vec<tree, va_gc> *inputs;
+  vec<tree, va_gc> *outputs;
+  vec<tree, va_gc> *clobbers;
+  vec<tree, va_gc> *labels;
   tree link_next;
 
   expr = *expr_p;
   noutputs = list_length (ASM_OUTPUTS (expr));
   oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
 
-  inputs = outputs = clobbers = labels = NULL;
+  inputs = NULL;
+  outputs = NULL;
+  clobbers = NULL;
+  labels = NULL;
 
   ret = GS_ALL_DONE;
   link_next = NULL_TREE;
@@ -5271,7 +5275,7 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
 	  ret = tret;
 	}
 
-      VEC_safe_push (tree, gc, outputs, link);
+      vec_safe_push (outputs, link);
       TREE_CHAIN (link) = NULL_TREE;
 
       if (is_inout)
@@ -5418,14 +5422,14 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
 	}
 
       TREE_CHAIN (link) = NULL_TREE;
-      VEC_safe_push (tree, gc, inputs, link);
+      vec_safe_push (inputs, link);
     }
 
   for (link = ASM_CLOBBERS (expr); link; ++i, link = TREE_CHAIN (link))
-    VEC_safe_push (tree, gc, clobbers, link);
+    vec_safe_push (clobbers, link);
 
   for (link = ASM_LABELS (expr); link; ++i, link = TREE_CHAIN (link))
-    VEC_safe_push (tree, gc, labels, link);
+    vec_safe_push (labels, link);
 
   /* Do not add ASMs with errors to the gimple IL stream.  */
   if (ret != GS_ERROR)
@@ -5658,7 +5662,8 @@ gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
 	  && needs_to_live_in_memory (temp)
 	  && flag_stack_reuse == SR_ALL)
 	{
-	  tree clobber = build_constructor (TREE_TYPE (temp), NULL);
+	  tree clobber = build_constructor (TREE_TYPE (temp),
+					    NULL);
 	  TREE_THIS_VOLATILE (clobber) = true;
 	  clobber = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, clobber);
 	  if (cleanup)
@@ -8254,38 +8259,36 @@ gimplify_body (tree fndecl, bool do_parms)
 }
 
 typedef char *char_p; /* For DEF_VEC_P.  */
-DEF_VEC_P(char_p);
-DEF_VEC_ALLOC_P(char_p,heap);
 
 /* Return whether we should exclude FNDECL from instrumentation.  */
 
 static bool
 flag_instrument_functions_exclude_p (tree fndecl)
 {
-  VEC(char_p,heap) *vec;
+  vec<char_p> *v;
 
-  vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_functions;
-  if (VEC_length (char_p, vec) > 0)
+  v = (vec<char_p> *) flag_instrument_functions_exclude_functions;
+  if (v && v->length () > 0)
     {
       const char *name;
       int i;
       char *s;
 
       name = lang_hooks.decl_printable_name (fndecl, 0);
-      FOR_EACH_VEC_ELT (char_p, vec, i, s)
+      FOR_EACH_VEC_ELT (*v, i, s)
 	if (strstr (name, s) != NULL)
 	  return true;
     }
 
-  vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_files;
-  if (VEC_length (char_p, vec) > 0)
+  v = (vec<char_p> *) flag_instrument_functions_exclude_files;
+  if (v && v->length () > 0)
     {
       const char *name;
       int i;
       char *s;
 
       name = DECL_SOURCE_FILE (fndecl);
-      FOR_EACH_VEC_ELT (char_p, vec, i, s)
+      FOR_EACH_VEC_ELT (*v, i, s)
 	if (strstr (name, s) != NULL)
 	  return true;
     }