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.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@193595 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 99 insertions, 116 deletions

diff --git a/gcc/df-scan.c b/gcc/df-scan.c
index 566f2375be5..93a06379b17 100644
--- a/gcc/df-scan.c
+++ b/gcc/df-scan.c
@@ -45,18 +45,9 @@ along with GCC; see the file COPYING3.  If not see
 #include "df.h"
 #include "emit-rtl.h"  /* FIXME: Can go away once crtl is moved to rtl.h.  */
 
-DEF_VEC_P(df_ref);
-DEF_VEC_ALLOC_P_STACK(df_ref);
-
-#define VEC_df_ref_stack_alloc(alloc) VEC_stack_alloc (df_ref, alloc)
 
 typedef struct df_mw_hardreg *df_mw_hardreg_ptr;
 
-DEF_VEC_P(df_mw_hardreg_ptr);
-DEF_VEC_ALLOC_P_STACK(df_mw_hardreg_ptr);
-
-#define VEC_df_mw_hardreg_ptr_stack_alloc(alloc) \
-  VEC_stack_alloc (df_mw_hardreg_ptr, alloc)
 
 #ifndef HAVE_epilogue
 #define HAVE_epilogue 0
@@ -96,10 +87,10 @@ static HARD_REG_SET elim_reg_set;
 
 struct df_collection_rec
 {
-  VEC(df_ref,stack) *def_vec;
-  VEC(df_ref,stack) *use_vec;
-  VEC(df_ref,stack) *eq_use_vec;
-  VEC(df_mw_hardreg_ptr,stack) *mw_vec;
+  vec<df_ref, va_stack> def_vec;
+  vec<df_ref, va_stack> use_vec;
+  vec<df_ref, va_stack> eq_use_vec;
+  vec<df_mw_hardreg_ptr, va_stack> mw_vec;
 };
 
 static df_ref df_null_ref_rec[1];
@@ -1181,19 +1172,19 @@ df_free_collection_rec (struct df_collection_rec *collection_rec)
   df_ref ref;
   struct df_mw_hardreg *mw;
 
-  FOR_EACH_VEC_ELT (df_ref, collection_rec->def_vec, ix, ref)
+  FOR_EACH_VEC_ELT (collection_rec->def_vec, ix, ref)
     df_free_ref (ref);
-  FOR_EACH_VEC_ELT (df_ref, collection_rec->use_vec, ix, ref)
+  FOR_EACH_VEC_ELT (collection_rec->use_vec, ix, ref)
     df_free_ref (ref);
-  FOR_EACH_VEC_ELT (df_ref, collection_rec->eq_use_vec, ix, ref)
+  FOR_EACH_VEC_ELT (collection_rec->eq_use_vec, ix, ref)
     df_free_ref (ref);
-  FOR_EACH_VEC_ELT (df_mw_hardreg_ptr, collection_rec->mw_vec, ix, mw)
+  FOR_EACH_VEC_ELT (collection_rec->mw_vec, ix, mw)
     pool_free (problem_data->mw_reg_pool, mw);
 
-  VEC_free (df_ref, stack, collection_rec->def_vec);
-  VEC_free (df_ref, stack, collection_rec->use_vec);
-  VEC_free (df_ref, stack, collection_rec->eq_use_vec);
-  VEC_free (df_mw_hardreg_ptr, stack, collection_rec->mw_vec);
+  collection_rec->def_vec.release ();
+  collection_rec->use_vec.release ();
+  collection_rec->eq_use_vec.release ();
+  collection_rec->mw_vec.release ();
 }
 
 /* Rescan INSN.  Return TRUE if the rescanning produced any changes.  */
@@ -1245,10 +1236,10 @@ df_insn_rescan (rtx insn)
       return false;
     }
 
-  collection_rec.def_vec = VEC_alloc (df_ref, stack, 128);
-  collection_rec.use_vec = VEC_alloc (df_ref, stack, 32);
-  collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
-  collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
+  vec_stack_alloc (df_ref, collection_rec.def_vec, 128);
+  vec_stack_alloc (df_ref, collection_rec.use_vec, 32);
+  vec_stack_alloc (df_ref, collection_rec.eq_use_vec, 32);
+  vec_stack_alloc (df_mw_hardreg_ptr, collection_rec.mw_vec, 32);
 
   bitmap_clear_bit (&df->insns_to_delete, uid);
   bitmap_clear_bit (&df->insns_to_rescan, uid);
@@ -1287,10 +1278,10 @@ df_insn_rescan (rtx insn)
   if (!DEBUG_INSN_P (insn))
     df_set_bb_dirty (bb);
 
-  VEC_free (df_ref, stack, collection_rec.def_vec);
-  VEC_free (df_ref, stack, collection_rec.use_vec);
-  VEC_free (df_ref, stack, collection_rec.eq_use_vec);
-  VEC_free (df_mw_hardreg_ptr, stack, collection_rec.mw_vec);
+  collection_rec.def_vec.release ();
+  collection_rec.use_vec.release ();
+  collection_rec.eq_use_vec.release ();
+  collection_rec.mw_vec.release ();
 
   return true;
 }
@@ -2198,8 +2189,8 @@ df_notes_rescan (rtx insn)
       unsigned int mw_len;
 
       memset (&collection_rec, 0, sizeof (struct df_collection_rec));
-      collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
-      collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
+      vec_stack_alloc (df_ref, collection_rec.eq_use_vec, 32);
+      vec_stack_alloc (df_mw_hardreg_ptr, collection_rec.mw_vec, 32);
 
       num_deleted = df_mw_hardreg_chain_delete_eq_uses (insn_info);
       df_ref_chain_delete (insn_info->eq_uses);
@@ -2223,7 +2214,7 @@ df_notes_rescan (rtx insn)
 
       /* Find some place to put any new mw_hardregs.  */
       df_canonize_collection_rec (&collection_rec);
-      mw_len = VEC_length (df_mw_hardreg_ptr, collection_rec.mw_vec);
+      mw_len = collection_rec.mw_vec.length ();
       if (mw_len)
 	{
 	  unsigned int count = 0;
@@ -2246,7 +2237,7 @@ df_notes_rescan (rtx insn)
 				count + 1 + mw_len);
 		}
 	      memcpy (&insn_info->mw_hardregs[count],
-		      VEC_address (df_mw_hardreg_ptr, collection_rec.mw_vec),
+		      collection_rec.mw_vec.address (),
 		      mw_len * sizeof (struct df_mw_hardreg *));
 	      insn_info->mw_hardregs[count + mw_len] = NULL;
 	      qsort (insn_info->mw_hardregs, count + mw_len,
@@ -2258,16 +2249,16 @@ df_notes_rescan (rtx insn)
 	      insn_info->mw_hardregs
 		= XNEWVEC (struct df_mw_hardreg*, 1 + mw_len);
 	      memcpy (insn_info->mw_hardregs,
-		      VEC_address (df_mw_hardreg_ptr, collection_rec.mw_vec),
+		      collection_rec.mw_vec.address (),
 		      mw_len * sizeof (struct df_mw_hardreg *));
 	      insn_info->mw_hardregs[mw_len] = NULL;
 	    }
 	}
       /* Get rid of the mw_rec so that df_refs_add_to_chains will
 	 ignore it.  */
-      VEC_free (df_mw_hardreg_ptr, stack, collection_rec.mw_vec);
+      collection_rec.mw_vec.release ();
       df_refs_add_to_chains (&collection_rec, bb, insn);
-      VEC_free (df_ref, stack, collection_rec.eq_use_vec);
+      collection_rec.eq_use_vec.release ();
     }
   else
     df_insn_rescan (insn);
@@ -2367,31 +2358,31 @@ df_ref_compare (const void *r1, const void *r2)
 }
 
 static void
-df_swap_refs (VEC(df_ref,stack) **ref_vec, int i, int j)
+df_swap_refs (vec<df_ref, va_stack> *ref_vec, int i, int j)
 {
-  df_ref tmp = VEC_index (df_ref, *ref_vec, i);
-  VEC_replace (df_ref, *ref_vec, i, VEC_index (df_ref, *ref_vec, j));
-  VEC_replace (df_ref, *ref_vec, j, tmp);
+  df_ref tmp = (*ref_vec)[i];
+  (*ref_vec)[i] = (*ref_vec)[j];
+  (*ref_vec)[j] = tmp;
 }
 
 /* Sort and compress a set of refs.  */
 
 static void
-df_sort_and_compress_refs (VEC(df_ref,stack) **ref_vec)
+df_sort_and_compress_refs (vec<df_ref, va_stack> *ref_vec)
 {
   unsigned int count;
   unsigned int i;
   unsigned int dist = 0;
 
-  count = VEC_length (df_ref, *ref_vec);
+  count = ref_vec->length ();
 
   /* If there are 1 or 0 elements, there is nothing to do.  */
   if (count < 2)
     return;
   else if (count == 2)
     {
-      df_ref r0 = VEC_index (df_ref, *ref_vec, 0);
-      df_ref r1 = VEC_index (df_ref, *ref_vec, 1);
+      df_ref r0 = (*ref_vec)[0];
+      df_ref r1 = (*ref_vec)[1];
       if (df_ref_compare (&r0, &r1) > 0)
         df_swap_refs (ref_vec, 0, 1);
     }
@@ -2399,8 +2390,8 @@ df_sort_and_compress_refs (VEC(df_ref,stack) **ref_vec)
     {
       for (i = 0; i < count - 1; i++)
 	{
-	  df_ref r0 = VEC_index (df_ref, *ref_vec, i);
-	  df_ref r1 = VEC_index (df_ref, *ref_vec, i + 1);
+	  df_ref r0 = (*ref_vec)[i];
+	  df_ref r1 = (*ref_vec)[i + 1];
 	  if (df_ref_compare (&r0, &r1) >= 0)
 	    break;
 	}
@@ -2413,27 +2404,26 @@ df_sort_and_compress_refs (VEC(df_ref,stack) **ref_vec)
          of DF_REF_COMPARE.  */
       if (i == count - 1)
         return;
-      VEC_qsort (df_ref, *ref_vec, df_ref_compare);
+      ref_vec->qsort (df_ref_compare);
     }
 
   for (i=0; i<count-dist; i++)
     {
       /* Find the next ref that is not equal to the current ref.  */
       while (i + dist + 1 < count
-	     && df_ref_equal_p (VEC_index (df_ref, *ref_vec, i),
-				VEC_index (df_ref, *ref_vec, i + dist + 1)))
+	     && df_ref_equal_p ((*ref_vec)[i],
+				(*ref_vec)[i + dist + 1]))
 	{
-	  df_free_ref (VEC_index (df_ref, *ref_vec, i + dist + 1));
+	  df_free_ref ((*ref_vec)[i + dist + 1]);
 	  dist++;
 	}
       /* Copy it down to the next position.  */
       if (dist && i + dist + 1 < count)
-	VEC_replace (df_ref, *ref_vec, i + 1,
-		     VEC_index (df_ref, *ref_vec, i + dist + 1));
+	(*ref_vec)[i + 1] = (*ref_vec)[i + dist + 1];
     }
 
   count -= dist;
-  VEC_truncate (df_ref, *ref_vec, count);
+  ref_vec->truncate (count);
 }
 
 
@@ -2487,7 +2477,7 @@ df_mw_compare (const void *m1, const void *m2)
 /* Sort and compress a set of refs.  */
 
 static void
-df_sort_and_compress_mws (VEC(df_mw_hardreg_ptr,stack) **mw_vec)
+df_sort_and_compress_mws (vec<df_mw_hardreg_ptr, va_stack> *mw_vec)
 {
   unsigned int count;
   struct df_scan_problem_data *problem_data
@@ -2495,45 +2485,40 @@ df_sort_and_compress_mws (VEC(df_mw_hardreg_ptr,stack) **mw_vec)
   unsigned int i;
   unsigned int dist = 0;
 
-  count = VEC_length (df_mw_hardreg_ptr, *mw_vec);
+  count = mw_vec->length ();
   if (count < 2)
     return;
   else if (count == 2)
     {
-      struct df_mw_hardreg *m0 = VEC_index (df_mw_hardreg_ptr, *mw_vec, 0);
-      struct df_mw_hardreg *m1 = VEC_index (df_mw_hardreg_ptr, *mw_vec, 1);
+      struct df_mw_hardreg *m0 = (*mw_vec)[0];
+      struct df_mw_hardreg *m1 = (*mw_vec)[1];
       if (df_mw_compare (&m0, &m1) > 0)
         {
-          struct df_mw_hardreg *tmp = VEC_index (df_mw_hardreg_ptr,
-						 *mw_vec, 0);
-	  VEC_replace (df_mw_hardreg_ptr, *mw_vec, 0,
-		       VEC_index (df_mw_hardreg_ptr, *mw_vec, 1));
-	  VEC_replace (df_mw_hardreg_ptr, *mw_vec, 1, tmp);
+          struct df_mw_hardreg *tmp = (*mw_vec)[0];
+	  (*mw_vec)[0] = (*mw_vec)[1];
+	  (*mw_vec)[1] = tmp;
         }
     }
   else
-    VEC_qsort (df_mw_hardreg_ptr, *mw_vec, df_mw_compare);
+    mw_vec->qsort (df_mw_compare);
 
   for (i=0; i<count-dist; i++)
     {
       /* Find the next ref that is not equal to the current ref.  */
       while (i + dist + 1 < count
-	     && df_mw_equal_p (VEC_index (df_mw_hardreg_ptr, *mw_vec, i),
-			       VEC_index (df_mw_hardreg_ptr, *mw_vec,
-					  i + dist + 1)))
+	     && df_mw_equal_p ((*mw_vec)[i], (*mw_vec)[i + dist + 1]))
 	{
 	  pool_free (problem_data->mw_reg_pool,
-		     VEC_index (df_mw_hardreg_ptr, *mw_vec, i + dist + 1));
+		     (*mw_vec)[i + dist + 1]);
 	  dist++;
 	}
       /* Copy it down to the next position.  */
       if (dist && i + dist + 1 < count)
-	VEC_replace (df_mw_hardreg_ptr, *mw_vec, i + 1,
-		     VEC_index (df_mw_hardreg_ptr, *mw_vec, i + dist + 1));
+	(*mw_vec)[i + 1] = (*mw_vec)[i + dist + 1];
     }
 
   count -= dist;
-  VEC_truncate (df_mw_hardreg_ptr, *mw_vec, count);
+  mw_vec->truncate (count);
 }
 
 
@@ -2603,14 +2588,14 @@ df_install_ref (df_ref this_ref,
 
 static df_ref *
 df_install_refs (basic_block bb,
-		 VEC(df_ref,stack)* old_vec,
+		 vec<df_ref, va_stack> old_vec,
 		 struct df_reg_info **reg_info,
 		 struct df_ref_info *ref_info,
 		 bool is_notes)
 {
   unsigned int count;
 
-  count = VEC_length (df_ref, old_vec);
+  count = old_vec.length ();
   if (count)
     {
       df_ref *new_vec = XNEWVEC (df_ref, count + 1);
@@ -2641,7 +2626,7 @@ df_install_refs (basic_block bb,
       if (add_to_table && df->analyze_subset)
 	add_to_table = bitmap_bit_p (df->blocks_to_analyze, bb->index);
 
-      FOR_EACH_VEC_ELT (df_ref, old_vec, ix, this_ref)
+      FOR_EACH_VEC_ELT (old_vec, ix, this_ref)
 	{
 	  new_vec[ix] = this_ref;
 	  df_install_ref (this_ref, reg_info[DF_REF_REGNO (this_ref)],
@@ -2660,16 +2645,16 @@ df_install_refs (basic_block bb,
    insn.  */
 
 static struct df_mw_hardreg **
-df_install_mws (VEC(df_mw_hardreg_ptr,stack) *old_vec)
+df_install_mws (vec<df_mw_hardreg_ptr, va_stack> old_vec)
 {
   unsigned int count;
 
-  count = VEC_length (df_mw_hardreg_ptr, old_vec);
+  count = old_vec.length ();
   if (count)
     {
       struct df_mw_hardreg **new_vec
 	= XNEWVEC (struct df_mw_hardreg*, count + 1);
-      memcpy (new_vec, VEC_address (df_mw_hardreg_ptr, old_vec),
+      memcpy (new_vec, old_vec.address (),
 	      sizeof (struct df_mw_hardreg*) * count);
       new_vec[count] = NULL;
       return new_vec;
@@ -2692,7 +2677,7 @@ df_refs_add_to_chains (struct df_collection_rec *collection_rec,
       /* If there is a vector in the collection rec, add it to the
 	 insn.  A null rec is a signal that the caller will handle the
 	 chain specially.  */
-      if (collection_rec->def_vec)
+      if (collection_rec->def_vec.exists ())
 	{
 	  df_scan_free_ref_vec (insn_rec->defs);
 	  insn_rec->defs
@@ -2700,7 +2685,7 @@ df_refs_add_to_chains (struct df_collection_rec *collection_rec,
 			       df->def_regs,
 			       &df->def_info, false);
 	}
-      if (collection_rec->use_vec)
+      if (collection_rec->use_vec.exists ())
 	{
 	  df_scan_free_ref_vec (insn_rec->uses);
 	  insn_rec->uses
@@ -2708,7 +2693,7 @@ df_refs_add_to_chains (struct df_collection_rec *collection_rec,
 			       df->use_regs,
 			       &df->use_info, false);
 	}
-      if (collection_rec->eq_use_vec)
+      if (collection_rec->eq_use_vec.exists ())
 	{
 	  df_scan_free_ref_vec (insn_rec->eq_uses);
 	  insn_rec->eq_uses
@@ -2716,7 +2701,7 @@ df_refs_add_to_chains (struct df_collection_rec *collection_rec,
 			       df->eq_use_regs,
 			       &df->use_info, true);
 	}
-      if (collection_rec->mw_vec)
+      if (collection_rec->mw_vec.exists ())
 	{
 	  df_scan_free_mws_vec (insn_rec->mw_hardregs);
 	  insn_rec->mw_hardregs
@@ -2812,11 +2797,11 @@ df_ref_create_structure (enum df_ref_class cl,
   if (collection_rec)
     {
       if (DF_REF_REG_DEF_P (this_ref))
-	VEC_safe_push (df_ref, stack, collection_rec->def_vec, this_ref);
+	collection_rec->def_vec.safe_push (this_ref);
       else if (DF_REF_FLAGS (this_ref) & DF_REF_IN_NOTE)
-	VEC_safe_push (df_ref, stack, collection_rec->eq_use_vec, this_ref);
+	collection_rec->eq_use_vec.safe_push (this_ref);
       else
-	VEC_safe_push (df_ref, stack, collection_rec->use_vec, this_ref);
+	collection_rec->use_vec.safe_push (this_ref);
     }
   else
     df_install_ref_incremental (this_ref);
@@ -2879,8 +2864,7 @@ df_ref_record (enum df_ref_class cl,
 	  hardreg->start_regno = regno;
 	  hardreg->end_regno = endregno - 1;
 	  hardreg->mw_order = df->ref_order++;
-	  VEC_safe_push (df_mw_hardreg_ptr, stack, collection_rec->mw_vec,
-			 hardreg);
+	  collection_rec->mw_vec.safe_push (hardreg);
 	}
 
       for (i = regno; i < endregno; i++)
@@ -3352,7 +3336,7 @@ df_get_conditional_uses (struct df_collection_rec *collection_rec)
   unsigned int ix;
   df_ref ref;
 
-  FOR_EACH_VEC_ELT (df_ref, collection_rec->def_vec, ix, ref)
+  FOR_EACH_VEC_ELT (collection_rec->def_vec, ix, ref)
     {
       if (DF_REF_FLAGS_IS_SET (ref, DF_REF_CONDITIONAL))
         {
@@ -3458,10 +3442,10 @@ df_insn_refs_collect (struct df_collection_rec *collection_rec,
   bool is_cond_exec = (GET_CODE (PATTERN (insn_info->insn)) == COND_EXEC);
 
   /* Clear out the collection record.  */
-  VEC_truncate (df_ref, collection_rec->def_vec, 0);
-  VEC_truncate (df_ref, collection_rec->use_vec, 0);
-  VEC_truncate (df_ref, collection_rec->eq_use_vec, 0);
-  VEC_truncate (df_mw_hardreg_ptr, collection_rec->mw_vec, 0);
+  collection_rec->def_vec.truncate (0);
+  collection_rec->use_vec.truncate (0);
+  collection_rec->eq_use_vec.truncate (0);
+  collection_rec->mw_vec.truncate (0);
 
   /* Process REG_EQUIV/REG_EQUAL notes.  */
   for (note = REG_NOTES (insn_info->insn); note;
@@ -3550,10 +3534,10 @@ df_recompute_luids (basic_block bb)
 static void
 df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb)
 {
-  VEC_truncate (df_ref, collection_rec->def_vec, 0);
-  VEC_truncate (df_ref, collection_rec->use_vec, 0);
-  VEC_truncate (df_ref, collection_rec->eq_use_vec, 0);
-  VEC_truncate (df_mw_hardreg_ptr, collection_rec->mw_vec, 0);
+  collection_rec->def_vec.truncate (0);
+  collection_rec->use_vec.truncate (0);
+  collection_rec->eq_use_vec.truncate (0);
+  collection_rec->mw_vec.truncate (0);
 
   if (bb->index == ENTRY_BLOCK)
     {
@@ -3622,10 +3606,10 @@ df_bb_refs_record (int bb_index, bool scan_insns)
     return;
 
   df_grow_bb_info (df_scan);
-  collection_rec.def_vec = VEC_alloc (df_ref, stack, 128);
-  collection_rec.use_vec = VEC_alloc (df_ref, stack, 32);
-  collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
-  collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
+  vec_stack_alloc (df_ref, collection_rec.def_vec, 128);
+  vec_stack_alloc (df_ref, collection_rec.use_vec, 32);
+  vec_stack_alloc (df_ref, collection_rec.eq_use_vec, 32);
+  vec_stack_alloc (df_mw_hardreg_ptr, collection_rec.mw_vec, 32);
 
   if (scan_insns)
     /* Scan the block an insn at a time from beginning to end.  */
@@ -3649,10 +3633,10 @@ df_bb_refs_record (int bb_index, bool scan_insns)
   df_bb_refs_collect (&collection_rec, bb);
   df_refs_add_to_chains (&collection_rec, bb, NULL);
 
-  VEC_free (df_ref, stack, collection_rec.def_vec);
-  VEC_free (df_ref, stack, collection_rec.use_vec);
-  VEC_free (df_ref, stack, collection_rec.eq_use_vec);
-  VEC_free (df_mw_hardreg_ptr, stack, collection_rec.mw_vec);
+  collection_rec.def_vec.release ();
+  collection_rec.use_vec.release ();
+  collection_rec.eq_use_vec.release ();
+  collection_rec.mw_vec.release ();
 
   /* Now that the block has been processed, set the block as dirty so
      LR and LIVE will get it processed.  */
@@ -3895,12 +3879,12 @@ df_record_entry_block_defs (bitmap entry_block_defs)
 {
   struct df_collection_rec collection_rec;
   memset (&collection_rec, 0, sizeof (struct df_collection_rec));
-  collection_rec.def_vec = VEC_alloc (df_ref, stack, FIRST_PSEUDO_REGISTER);
+  vec_stack_alloc (df_ref, collection_rec.def_vec, FIRST_PSEUDO_REGISTER);
   df_entry_block_defs_collect (&collection_rec, entry_block_defs);
 
   /* Process bb_refs chain */
   df_refs_add_to_chains (&collection_rec, BASIC_BLOCK (ENTRY_BLOCK), NULL);
-  VEC_free (df_ref, stack, collection_rec.def_vec);
+  collection_rec.def_vec.release ();
 }
 
 
@@ -4068,13 +4052,12 @@ df_record_exit_block_uses (bitmap exit_block_uses)
 {
   struct df_collection_rec collection_rec;
   memset (&collection_rec, 0, sizeof (struct df_collection_rec));
-  collection_rec.use_vec = VEC_alloc (df_ref, stack, FIRST_PSEUDO_REGISTER);
-
+  vec_stack_alloc (df_ref, collection_rec.use_vec, FIRST_PSEUDO_REGISTER);
   df_exit_block_uses_collect (&collection_rec, exit_block_uses);
 
   /* Process bb_refs chain */
   df_refs_add_to_chains (&collection_rec, BASIC_BLOCK (EXIT_BLOCK), NULL);
-  VEC_free (df_ref, stack, collection_rec.use_vec);
+  collection_rec.use_vec.release ();
 }
 
 
@@ -4251,7 +4234,7 @@ df_compute_regs_ever_live (bool reset)
 
   df_reg_chain_mark (refs, regno, is_def, is_eq_use)
   df_reg_chain_verify_unmarked (refs)
-  df_refs_verify (VEC(stack,df_ref)*, ref*, bool)
+  df_refs_verify (vec<stack, va_df_ref>, ref*, bool)
   df_mws_verify (mw*, mw*, bool)
   df_insn_refs_verify (collection_rec, bb, insn, bool)
   df_bb_refs_verify (bb, refs, bool)
@@ -4315,13 +4298,13 @@ df_reg_chain_verify_unmarked (df_ref refs)
 /* Verify that NEW_REC and OLD_REC have exactly the same members. */
 
 static bool
-df_refs_verify (VEC(df_ref,stack) *new_rec, df_ref *old_rec,
+df_refs_verify (vec<df_ref, va_stack> new_rec, df_ref *old_rec,
 		bool abort_if_fail)
 {
   unsigned int ix;
   df_ref new_ref;
 
-  FOR_EACH_VEC_ELT (df_ref, new_rec, ix, new_ref)
+  FOR_EACH_VEC_ELT (new_rec, ix, new_ref)
     {
       if (*old_rec == NULL || !df_ref_equal_p (new_ref, *old_rec))
 	{
@@ -4353,14 +4336,14 @@ df_refs_verify (VEC(df_ref,stack) *new_rec, df_ref *old_rec,
 /* Verify that NEW_REC and OLD_REC have exactly the same members. */
 
 static bool
-df_mws_verify (VEC(df_mw_hardreg_ptr,stack) *new_rec,
+df_mws_verify (vec<df_mw_hardreg_ptr, va_stack> new_rec,
 	       struct df_mw_hardreg **old_rec,
 	       bool abort_if_fail)
 {
   unsigned int ix;
   struct df_mw_hardreg *new_reg;
 
-  FOR_EACH_VEC_ELT (df_mw_hardreg_ptr, new_rec, ix, new_reg)
+  FOR_EACH_VEC_ELT (new_rec, ix, new_reg)
     {
       if (*old_rec == NULL || !df_mw_equal_p (new_reg, *old_rec))
 	{
@@ -4438,10 +4421,10 @@ df_bb_verify (basic_block bb)
   struct df_collection_rec collection_rec;
 
   memset (&collection_rec, 0, sizeof (struct df_collection_rec));
-  collection_rec.def_vec = VEC_alloc (df_ref, stack, 128);
-  collection_rec.use_vec = VEC_alloc (df_ref, stack, 32);
-  collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
-  collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
+  vec_stack_alloc (df_ref, collection_rec.def_vec, 128);
+  vec_stack_alloc (df_ref, collection_rec.use_vec, 32);
+  vec_stack_alloc (df_ref, collection_rec.eq_use_vec, 32);
+  vec_stack_alloc (df_mw_hardreg_ptr, collection_rec.mw_vec, 32);
 
   gcc_assert (bb_info);