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: https://gcc.gnu.org/svn/gcc/trunk@193595 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 146 insertions, 161 deletions

diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index 6876dd4c5b7..00b88bfe03c 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -233,11 +233,9 @@ pre_expr_d::hash (const value_type *e)
 static unsigned int next_expression_id;
 
 /* Mapping from expression to id number we can use in bitmap sets.  */
-DEF_VEC_P (pre_expr);
-DEF_VEC_ALLOC_P (pre_expr, heap);
-static VEC(pre_expr, heap) *expressions;
+static vec<pre_expr> expressions;
 static hash_table <pre_expr_d> expression_to_id;
-static VEC(unsigned, heap) *name_to_id;
+static vec<unsigned> name_to_id;
 
 /* Allocate an expression id for EXPR.  */
 
@@ -248,18 +246,18 @@ alloc_expression_id (pre_expr expr)
   /* Make sure we won't overflow. */
   gcc_assert (next_expression_id + 1 > next_expression_id);
   expr->id = next_expression_id++;
-  VEC_safe_push (pre_expr, heap, expressions, expr);
+  expressions.safe_push (expr);
   if (expr->kind == NAME)
     {
       unsigned version = SSA_NAME_VERSION (PRE_EXPR_NAME (expr));
-      /* VEC_safe_grow_cleared allocates no headroom.  Avoid frequent
-	 re-allocations by using VEC_reserve upfront.  There is no
-	 VEC_quick_grow_cleared unfortunately.  */
-      unsigned old_len = VEC_length (unsigned, name_to_id);
-      VEC_reserve (unsigned, heap, name_to_id, num_ssa_names - old_len);
-      VEC_safe_grow_cleared (unsigned, heap, name_to_id, num_ssa_names);
-      gcc_assert (VEC_index (unsigned, name_to_id, version) == 0);
-      VEC_replace (unsigned, name_to_id, version, expr->id);
+      /* vec::safe_grow_cleared allocates no headroom.  Avoid frequent
+	 re-allocations by using vec::reserve upfront.  There is no
+	 vec::quick_grow_cleared unfortunately.  */
+      unsigned old_len = name_to_id.length ();
+      name_to_id.reserve (num_ssa_names - old_len);
+      name_to_id.safe_grow_cleared (num_ssa_names);
+      gcc_assert (name_to_id[version] == 0);
+      name_to_id[version] = expr->id;
     }
   else
     {
@@ -286,9 +284,9 @@ lookup_expression_id (const pre_expr expr)
   if (expr->kind == NAME)
     {
       unsigned version = SSA_NAME_VERSION (PRE_EXPR_NAME (expr));
-      if (VEC_length (unsigned, name_to_id) <= version)
+      if (name_to_id.length () <= version)
 	return 0;
-      return VEC_index (unsigned, name_to_id, version);
+      return name_to_id[version];
     }
   else
     {
@@ -316,7 +314,7 @@ get_or_alloc_expression_id (pre_expr expr)
 static inline pre_expr
 expression_for_id (unsigned int id)
 {
-  return VEC_index (pre_expr, expressions, id);
+  return expressions[id];
 }
 
 /* Free the expression id field in all of our expressions,
@@ -325,7 +323,7 @@ expression_for_id (unsigned int id)
 static void
 clear_expression_ids (void)
 {
-  VEC_free (pre_expr, heap, expressions);
+  expressions.release ();
 }
 
 static alloc_pool pre_expr_pool;
@@ -368,7 +366,7 @@ typedef struct bitmap_set
   EXECUTE_IF_SET_IN_BITMAP(&(set)->values, 0, (id), (bi))
 
 /* Mapping from value id to expressions with that value_id.  */
-static VEC(bitmap, heap) *value_expressions;
+static vec<bitmap> value_expressions;
 
 /* Sets that we need to keep track of.  */
 typedef struct bb_bitmap_sets
@@ -583,16 +581,16 @@ add_to_value (unsigned int v, pre_expr e)
 
   gcc_checking_assert (get_expr_value_id (e) == v);
 
-  if (v >= VEC_length (bitmap, value_expressions))
+  if (v >= value_expressions.length ())
     {
-      VEC_safe_grow_cleared (bitmap, heap, value_expressions, v + 1);
+      value_expressions.safe_grow_cleared (v + 1);
     }
 
-  set = VEC_index (bitmap, value_expressions, v);
+  set = value_expressions[v];
   if (!set)
     {
       set = BITMAP_ALLOC (&grand_bitmap_obstack);
-      VEC_replace (bitmap, value_expressions, v, set);
+      value_expressions[v] = set;
     }
 
   bitmap_set_bit (set, get_or_alloc_expression_id (e));
@@ -645,7 +643,7 @@ sccvn_valnum_from_value_id (unsigned int val)
 {
   bitmap_iterator bi;
   unsigned int i;
-  bitmap exprset = VEC_index (bitmap, value_expressions, val);
+  bitmap exprset = value_expressions[val];
   EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
     {
       pre_expr vexpr = expression_for_id (i);
@@ -712,15 +710,15 @@ bitmap_set_free (bitmap_set_t set)
 
 /* Generate an topological-ordered array of bitmap set SET.  */
 
-static VEC(pre_expr, heap) *
+static vec<pre_expr> 
 sorted_array_from_bitmap_set (bitmap_set_t set)
 {
   unsigned int i, j;
   bitmap_iterator bi, bj;
-  VEC(pre_expr, heap) *result;
+  vec<pre_expr> result;
 
   /* Pre-allocate roughly enough space for the array.  */
-  result = VEC_alloc (pre_expr, heap, bitmap_count_bits (&set->values));
+  result.create (bitmap_count_bits (&set->values));
 
   FOR_EACH_VALUE_ID_IN_SET (set, i, bi)
     {
@@ -734,11 +732,11 @@ sorted_array_from_bitmap_set (bitmap_set_t set)
 
 	 If this is somehow a significant lose for some cases, we can
 	 choose which set to walk based on the set size.  */
-      bitmap exprset = VEC_index (bitmap, value_expressions, i);
+      bitmap exprset = value_expressions[i];
       EXECUTE_IF_SET_IN_BITMAP (exprset, 0, j, bj)
 	{
 	  if (bitmap_bit_p (&set->expressions, j))
-	    VEC_safe_push (pre_expr, heap, result, expression_for_id (j));
+	    result.safe_push (expression_for_id (j));
         }
     }
 
@@ -860,7 +858,7 @@ bitmap_set_replace_value (bitmap_set_t set, unsigned int lookfor,
      5-10x faster than walking the bitmap.  If this is somehow a
      significant lose for some cases, we can choose which set to walk
      based on the set size.  */
-  exprset = VEC_index (bitmap, value_expressions, lookfor);
+  exprset = value_expressions[lookfor];
   EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
     {
       if (bitmap_clear_bit (&set->expressions, i))
@@ -947,7 +945,7 @@ print_pre_expr (FILE *outfile, const pre_expr expr)
 	vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
 	fprintf (outfile, "{");
 	for (i = 0;
-	     VEC_iterate (vn_reference_op_s, ref->operands, i, vro);
+	     ref->operands.iterate (i, &vro);
 	     i++)
 	  {
 	    bool closebrace = false;
@@ -977,7 +975,7 @@ print_pre_expr (FILE *outfile, const pre_expr expr)
 	      }
 	    if (closebrace)
 		fprintf (outfile, ">");
-	    if (i != VEC_length (vn_reference_op_s, ref->operands) - 1)
+	    if (i != ref->operands.length () - 1)
 	      fprintf (outfile, ",");
 	  }
 	fprintf (outfile, "}");
@@ -1056,7 +1054,7 @@ debug_bitmap_sets_for (basic_block bb)
 static void
 print_value_expressions (FILE *outfile, unsigned int val)
 {
-  bitmap set = VEC_index (bitmap, value_expressions, val);
+  bitmap set = value_expressions[val];
   if (set)
     {
       bitmap_set x;
@@ -1111,7 +1109,7 @@ get_constant_for_value_id (unsigned int v)
     {
       unsigned int i;
       bitmap_iterator bi;
-      bitmap exprset = VEC_index (bitmap, value_expressions, v);
+      bitmap exprset = value_expressions[v];
 
       EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
 	{
@@ -1262,7 +1260,7 @@ fully_constant_expression (pre_expr e)
    in case the new vuse doesn't change the value id of the OPERANDS.  */
 
 static tree
-translate_vuse_through_block (VEC (vn_reference_op_s, heap) *operands,
+translate_vuse_through_block (vec<vn_reference_op_s> operands,
 			      alias_set_type set, tree type, tree vuse,
 			      basic_block phiblock,
 			      basic_block block, bool *same_valid)
@@ -1393,7 +1391,7 @@ get_representative_for (const pre_expr e)
 	   and pick out an SSA_NAME.  */
 	unsigned int i;
 	bitmap_iterator bi;
-	bitmap exprs = VEC_index (bitmap, value_expressions, value_id);
+	bitmap exprs = value_expressions[value_id];
 	EXECUTE_IF_SET_IN_BITMAP (exprs, 0, i, bi)
 	  {
 	    pre_expr rep = expression_for_id (i);
@@ -1512,9 +1510,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
 	    else
 	      {
 		new_val_id = get_next_value_id ();
-		VEC_safe_grow_cleared (bitmap, heap,
-				       value_expressions,
-				       get_max_value_id() + 1);
+		value_expressions.safe_grow_cleared (get_max_value_id() + 1);
 		nary = vn_nary_op_insert_pieces (newnary->length,
 						 newnary->opcode,
 						 newnary->type,
@@ -1535,17 +1531,18 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
     case REFERENCE:
       {
 	vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
-	VEC (vn_reference_op_s, heap) *operands = ref->operands;
+	vec<vn_reference_op_s> operands = ref->operands;
 	tree vuse = ref->vuse;
 	tree newvuse = vuse;
-	VEC (vn_reference_op_s, heap) *newoperands = NULL;
+	vec<vn_reference_op_s> newoperands
+	    = vec<vn_reference_op_s>();
 	bool changed = false, same_valid = true;
 	unsigned int i, j, n;
 	vn_reference_op_t operand;
 	vn_reference_t newref;
 
 	for (i = 0, j = 0;
-	     VEC_iterate (vn_reference_op_s, operands, i, operand); i++, j++)
+	     operands.iterate (i, &operand); i++, j++)
 	  {
 	    pre_expr opresult;
 	    pre_expr leader;
@@ -1593,12 +1590,11 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
 	      }
 	    if (n != 3)
 	      {
-		if (newoperands)
-		  VEC_free (vn_reference_op_s, heap, newoperands);
+		newoperands.release ();
 		return NULL;
 	      }
-	    if (!newoperands)
-	      newoperands = VEC_copy (vn_reference_op_s, heap, operands);
+	    if (!newoperands.exists ())
+	      newoperands = operands.copy ();
 	    /* We may have changed from an SSA_NAME to a constant */
 	    if (newop.opcode == SSA_NAME && TREE_CODE (op[0]) != SSA_NAME)
 	      newop.opcode = TREE_CODE (op[0]);
@@ -1620,18 +1616,16 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
 		if (off.fits_shwi ())
 		  newop.off = off.low;
 	      }
-	    VEC_replace (vn_reference_op_s, newoperands, j, newop);
+	    newoperands[j] = newop;
 	    /* If it transforms from an SSA_NAME to an address, fold with
 	       a preceding indirect reference.  */
 	    if (j > 0 && op[0] && TREE_CODE (op[0]) == ADDR_EXPR
-		&& VEC_index (vn_reference_op_s,
-			      newoperands, j - 1).opcode == MEM_REF)
+		&& newoperands[j - 1].opcode == MEM_REF)
 	      vn_reference_fold_indirect (&newoperands, &j);
 	  }
-	if (i != VEC_length (vn_reference_op_s, operands))
+	if (i != operands.length ())
 	  {
-	    if (newoperands)
-	      VEC_free (vn_reference_op_s, heap, newoperands);
+	    newoperands.release ();
 	    return NULL;
 	  }
 
@@ -1643,7 +1637,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
 						    &same_valid);
 	    if (newvuse == NULL_TREE)
 	      {
-		VEC_free (vn_reference_op_s, heap, newoperands);
+		newoperands.release ();
 		return NULL;
 	      }
 	  }
@@ -1658,7 +1652,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
 						      newoperands,
 						      &newref, VN_WALK);
 	    if (result)
-	      VEC_free (vn_reference_op_s, heap, newoperands);
+	      newoperands.release ();
 
 	    /* We can always insert constants, so if we have a partial
 	       redundant constant load of another type try to translate it
@@ -1686,7 +1680,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
 	    else if (!result && newref
 		     && !useless_type_conversion_p (ref->type, newref->type))
 	      {
-		VEC_free (vn_reference_op_s, heap, newoperands);
+		newoperands.release ();
 		return NULL;
 	      }
 
@@ -1709,9 +1703,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
 		if (changed || !same_valid)
 		  {
 		    new_val_id = get_next_value_id ();
-		    VEC_safe_grow_cleared (bitmap, heap,
-					   value_expressions,
-					   get_max_value_id() + 1);
+		    value_expressions.safe_grow_cleared(get_max_value_id() + 1);
 		  }
 		else
 		  new_val_id = ref->value_id;
@@ -1719,7 +1711,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
 						     ref->type,
 						     newoperands,
 						     result, new_val_id);
-		newoperands = NULL;
+		newoperands.create (0);
 		PRE_EXPR_REFERENCE (expr) = newref;
 		constant = fully_constant_expression (expr);
 		if (constant != expr)
@@ -1728,7 +1720,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
 	      }
 	    add_to_value (new_val_id, expr);
 	  }
-	VEC_free (vn_reference_op_s, heap, newoperands);
+	newoperands.release ();
 	return expr;
       }
       break;
@@ -1807,7 +1799,7 @@ static void
 phi_translate_set (bitmap_set_t dest, bitmap_set_t set, basic_block pred,
 		   basic_block phiblock)
 {
-  VEC (pre_expr, heap) *exprs;
+  vec<pre_expr> exprs;
   pre_expr expr;
   int i;
 
@@ -1818,7 +1810,7 @@ phi_translate_set (bitmap_set_t dest, bitmap_set_t set, basic_block pred,
     }
 
   exprs = sorted_array_from_bitmap_set (set);
-  FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+  FOR_EACH_VEC_ELT (exprs, i, expr)
     {
       pre_expr translated;
       translated = phi_translate (expr, set, NULL, pred, phiblock);
@@ -1834,7 +1826,7 @@ phi_translate_set (bitmap_set_t dest, bitmap_set_t set, basic_block pred,
       else
 	bitmap_value_insert_into_set (dest, translated);
     }
-  VEC_free (pre_expr, heap, exprs);
+  exprs.release ();
 }
 
 /* Find the leader for a value (i.e., the name representing that
@@ -1849,7 +1841,7 @@ bitmap_find_leader (bitmap_set_t set, unsigned int val)
     {
       unsigned int i;
       bitmap_iterator bi;
-      bitmap exprset = VEC_index (bitmap, value_expressions, val);
+      bitmap exprset = value_expressions[val];
 
       EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
 	{
@@ -1873,7 +1865,7 @@ bitmap_find_leader (bitmap_set_t set, unsigned int val)
 	 choose which set to walk based on which set is smaller.  */
       unsigned int i;
       bitmap_iterator bi;
-      bitmap exprset = VEC_index (bitmap, value_expressions, val);
+      bitmap exprset = value_expressions[val];
 
       EXECUTE_IF_AND_IN_BITMAP (exprset, &set->expressions, 0, i, bi)
 	return expression_for_id (i);
@@ -2007,7 +1999,7 @@ valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, pre_expr expr,
 	vn_reference_op_t vro;
 	unsigned int i;
 
-	FOR_EACH_VEC_ELT (vn_reference_op_s, ref->operands, i, vro)
+	FOR_EACH_VEC_ELT (ref->operands, i, vro)
 	  {
 	    if (!op_valid_in_sets (set1, set2, vro->op0)
 		|| !op_valid_in_sets (set1, set2, vro->op1)
@@ -2030,16 +2022,16 @@ valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, pre_expr expr,
 static void
 dependent_clean (bitmap_set_t set1, bitmap_set_t set2, basic_block block)
 {
-  VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set1);
+  vec<pre_expr> exprs = sorted_array_from_bitmap_set (set1);
   pre_expr expr;
   int i;
 
-  FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+  FOR_EACH_VEC_ELT (exprs, i, expr)
     {
       if (!valid_in_sets (set1, set2, expr, block))
 	bitmap_remove_from_set (set1, expr);
     }
-  VEC_free (pre_expr, heap, exprs);
+  exprs.release ();
 }
 
 /* Clean the set of expressions that are no longer valid in SET.  This
@@ -2049,16 +2041,16 @@ dependent_clean (bitmap_set_t set1, bitmap_set_t set2, basic_block block)
 static void
 clean (bitmap_set_t set, basic_block block)
 {
-  VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set);
+  vec<pre_expr> exprs = sorted_array_from_bitmap_set (set);
   pre_expr expr;
   int i;
 
-  FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+  FOR_EACH_VEC_ELT (exprs, i, expr)
     {
       if (!valid_in_sets (set, NULL, expr, block))
 	bitmap_remove_from_set (set, expr);
     }
-  VEC_free (pre_expr, heap, exprs);
+  exprs.release ();
 }
 
 /* Clean the set of expressions that are no longer valid in SET because
@@ -2198,18 +2190,18 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
      phis to translate through.  */
   else
     {
-      VEC(basic_block, heap) * worklist;
+      vec<basic_block> worklist;
       size_t i;
       basic_block bprime, first = NULL;
 
-      worklist = VEC_alloc (basic_block, heap, EDGE_COUNT (block->succs));
+      worklist.create (EDGE_COUNT (block->succs));
       FOR_EACH_EDGE (e, ei, block->succs)
 	{
 	  if (!first
 	      && BB_VISITED (e->dest))
 	    first = e->dest;
 	  else if (BB_VISITED (e->dest))
-	    VEC_quick_push (basic_block, worklist, e->dest);
+	    worklist.quick_push (e->dest);
 	}
 
       /* Of multiple successors we have to have visited one already.  */
@@ -2219,7 +2211,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
 	  BB_VISITED (block) = 0;
 	  BB_DEFERRED (block) = 1;
 	  changed = true;
-	  VEC_free (basic_block, heap, worklist);
+	  worklist.release ();
 	  goto maybe_dump_sets;
 	}
 
@@ -2228,7 +2220,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
       else
 	bitmap_set_copy (ANTIC_OUT, ANTIC_IN (first));
 
-      FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
+      FOR_EACH_VEC_ELT (worklist, i, bprime)
 	{
 	  if (!gimple_seq_empty_p (phi_nodes (bprime)))
 	    {
@@ -2240,7 +2232,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
 	  else
 	    bitmap_set_and (ANTIC_OUT, ANTIC_IN (bprime));
 	}
-      VEC_free (basic_block, heap, worklist);
+      worklist.release ();
     }
 
   /* Prune expressions that are clobbered in block and thus become
@@ -2362,20 +2354,20 @@ compute_partial_antic_aux (basic_block block,
      them.  */
   else
     {
-      VEC(basic_block, heap) * worklist;
+      vec<basic_block> worklist;
       size_t i;
       basic_block bprime;
 
-      worklist = VEC_alloc (basic_block, heap, EDGE_COUNT (block->succs));
+      worklist.create (EDGE_COUNT (block->succs));
       FOR_EACH_EDGE (e, ei, block->succs)
 	{
 	  if (e->flags & EDGE_DFS_BACK)
 	    continue;
-	  VEC_quick_push (basic_block, worklist, e->dest);
+	  worklist.quick_push (e->dest);
 	}
-      if (VEC_length (basic_block, worklist) > 0)
+      if (worklist.length () > 0)
 	{
-	  FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
+	  FOR_EACH_VEC_ELT (worklist, i, bprime)
 	    {
 	      unsigned int i;
 	      bitmap_iterator bi;
@@ -2398,7 +2390,7 @@ compute_partial_antic_aux (basic_block block,
 						expression_for_id (i));
 	    }
 	}
-      VEC_free (basic_block, heap, worklist);
+      worklist.release ();
     }
 
   /* Prune expressions that are clobbered in block and thus become
@@ -2559,8 +2551,7 @@ static tree
 create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref,
 				  unsigned int *operand, gimple_seq *stmts)
 {
-  vn_reference_op_t currop = &VEC_index (vn_reference_op_s, ref->operands,
-					 *operand);
+  vn_reference_op_t currop = &ref->operands[*operand];
   tree genop;
   ++*operand;
   switch (currop->opcode)
@@ -2576,9 +2567,8 @@ create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref,
 	  fn = find_or_generate_expression (block, currop->op0, stmts);
 	if (currop->op1)
 	  sc = find_or_generate_expression (block, currop->op1, stmts);
-	args = XNEWVEC (tree, VEC_length (vn_reference_op_s,
-					  ref->operands) - 1);
-	while (*operand < VEC_length (vn_reference_op_s, ref->operands))
+	args = XNEWVEC (tree, ref->operands.length () - 1);
+	while (*operand < ref->operands.length ())
 	  {
 	    args[nargs] = create_component_ref_by_pieces_1 (block, ref,
 							    operand, stmts);
@@ -2618,8 +2608,7 @@ create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref,
     case TARGET_MEM_REF:
       {
 	tree genop0 = NULL_TREE, genop1 = NULL_TREE;
-	vn_reference_op_t nextop = &VEC_index (vn_reference_op_s, ref->operands,
-					       ++*operand);
+	vn_reference_op_t nextop = &ref->operands[++*operand];
 	tree baseop = create_component_ref_by_pieces_1 (block, ref, operand,
 							stmts);
 	if (currop->op0)
@@ -2789,7 +2778,7 @@ find_or_generate_expression (basic_block block, tree op, gimple_seq *stmts)
     }
 
   /* It must be a complex expression, so generate it recursively.  */
-  bitmap exprset = VEC_index (bitmap, value_expressions, lookfor);
+  bitmap exprset = value_expressions[lookfor];
   bitmap_iterator bi;
   unsigned int i;
   EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
@@ -2874,7 +2863,7 @@ create_expression_by_pieces (basic_block block, pre_expr expr,
 	  }
 	if (nary->opcode == CONSTRUCTOR)
 	  {
-	    VEC(constructor_elt,gc) *elts = NULL;
+	    vec<constructor_elt, va_gc> *elts = NULL;
 	    for (i = 0; i < nary->length; ++i)
 	      CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE, genop[i]);
 	    folded = build_constructor (nary->type, elts);
@@ -2990,7 +2979,7 @@ static bool
 inhibit_phi_insertion (basic_block bb, pre_expr expr)
 {
   vn_reference_t vr = PRE_EXPR_REFERENCE (expr);
-  VEC (vn_reference_op_s, heap) *ops = vr->operands;
+  vec<vn_reference_op_s> ops = vr->operands;
   vn_reference_op_t op;
   unsigned i;
 
@@ -3002,7 +2991,7 @@ inhibit_phi_insertion (basic_block bb, pre_expr expr)
      memory reference is a simple induction variable.  In other
      cases the vectorizer won't do anything anyway (either it's
      loop invariant or a complicated expression).  */
-  FOR_EACH_VEC_ELT (vn_reference_op_s, ops, i, op)
+  FOR_EACH_VEC_ELT (ops, i, op)
     {
       switch (op->opcode)
 	{
@@ -3048,7 +3037,7 @@ inhibit_phi_insertion (basic_block bb, pre_expr expr)
 
 static bool
 insert_into_preds_of_block (basic_block block, unsigned int exprnum,
-			    VEC(pre_expr, heap) *avail)
+			    vec<pre_expr> avail)
 {
   pre_expr expr = expression_for_id (exprnum);
   pre_expr newphi;
@@ -3089,7 +3078,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
       gimple_seq stmts = NULL;
       tree builtexpr;
       bprime = pred->src;
-      eprime = VEC_index (pre_expr, avail, pred->dest_idx);
+      eprime = avail[pred->dest_idx];
 
       if (eprime->kind != NAME && eprime->kind != CONSTANT)
 	{
@@ -3097,8 +3086,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
 						   &stmts, type);
 	  gcc_assert (!(pred->flags & EDGE_ABNORMAL));
 	  gsi_insert_seq_on_edge (pred, stmts);
-	  VEC_replace (pre_expr, avail, pred->dest_idx,
-		       get_or_alloc_expr_for_name (builtexpr));
+	  avail[pred->dest_idx] = get_or_alloc_expr_for_name (builtexpr);
 	  insertions = true;
 	}
       else if (eprime->kind == CONSTANT)
@@ -3136,13 +3124,13 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
 			    }
 			  gsi_insert_seq_on_edge (pred, stmts);
 			}
-		      VEC_replace (pre_expr, avail, pred->dest_idx,
-				   get_or_alloc_expr_for_name (forcedexpr));
+		      avail[pred->dest_idx]
+			= get_or_alloc_expr_for_name (forcedexpr);
 		    }
 		}
 	      else
-		VEC_replace (pre_expr, avail, pred->dest_idx,
-			     get_or_alloc_expr_for_constant (builtexpr));
+		avail[pred->dest_idx]
+		    = get_or_alloc_expr_for_constant (builtexpr);
 	    }
 	}
       else if (eprime->kind == NAME)
@@ -3181,8 +3169,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
 		    }
 		  gsi_insert_seq_on_edge (pred, stmts);
 		}
-	      VEC_replace (pre_expr, avail, pred->dest_idx,
-			   get_or_alloc_expr_for_name (forcedexpr));
+	      avail[pred->dest_idx] = get_or_alloc_expr_for_name (forcedexpr);
 	    }
 	}
     }
@@ -3207,7 +3194,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
   bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (temp));
   FOR_EACH_EDGE (pred, ei, block->preds)
     {
-      pre_expr ae = VEC_index (pre_expr, avail, pred->dest_idx);
+      pre_expr ae = avail[pred->dest_idx];
       gcc_assert (get_expr_type (ae) == type
 		  || useless_type_conversion_p (type, get_expr_type (ae)));
       if (ae->kind == CONSTANT)
@@ -3273,15 +3260,15 @@ static bool
 do_regular_insertion (basic_block block, basic_block dom)
 {
   bool new_stuff = false;
-  VEC (pre_expr, heap) *exprs;
+  vec<pre_expr> exprs;
   pre_expr expr;
-  VEC (pre_expr, heap) *avail = NULL;
+  vec<pre_expr> avail = vec<pre_expr>();
   int i;
 
   exprs = sorted_array_from_bitmap_set (ANTIC_IN (block));
-  VEC_safe_grow (pre_expr, heap, avail, EDGE_COUNT (block->preds));
+  avail.safe_grow (EDGE_COUNT (block->preds));
 
-  FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+  FOR_EACH_VEC_ELT (exprs, i, expr)
     {
       if (expr->kind != NAME)
 	{
@@ -3329,7 +3316,7 @@ do_regular_insertion (basic_block block, basic_block dom)
 		 rest of the results are.  */
 	      if (eprime == NULL)
 		{
-		  VEC_replace (pre_expr, avail, pred->dest_idx, NULL);
+		  avail[pred->dest_idx] = NULL;
 		  cant_insert = true;
 		  break;
 		}
@@ -3340,12 +3327,12 @@ do_regular_insertion (basic_block block, basic_block dom)
 						 vprime);
 	      if (edoubleprime == NULL)
 		{
-		  VEC_replace (pre_expr, avail, pred->dest_idx, eprime);
+		  avail[pred->dest_idx] = eprime;
 		  all_same = false;
 		}
 	      else
 		{
-		  VEC_replace (pre_expr, avail, pred->dest_idx, edoubleprime);
+		  avail[pred->dest_idx] = edoubleprime;
 		  by_some = true;
 		  /* We want to perform insertions to remove a redundancy on
 		     a path in the CFG we want to optimize for speed.  */
@@ -3400,7 +3387,7 @@ do_regular_insertion (basic_block block, basic_block dom)
 	    {
 	      unsigned int j;
 	      bitmap_iterator bi;
-	      bitmap exprset = VEC_index (bitmap, value_expressions, val);
+	      bitmap exprset = value_expressions[val];
 
 	      unsigned int new_val = get_expr_value_id (edoubleprime);
 	      EXECUTE_IF_SET_IN_BITMAP (exprset, 0, j, bi)
@@ -3426,8 +3413,8 @@ do_regular_insertion (basic_block block, basic_block dom)
 	}
     }
 
-  VEC_free (pre_expr, heap, exprs);
-  VEC_free (pre_expr, heap, avail);
+  exprs.release ();
+  avail.release ();
   return new_stuff;
 }
 
@@ -3443,15 +3430,15 @@ static bool
 do_partial_partial_insertion (basic_block block, basic_block dom)
 {
   bool new_stuff = false;
-  VEC (pre_expr, heap) *exprs;
+  vec<pre_expr> exprs;
   pre_expr expr;
-  VEC (pre_expr, heap) *avail = NULL;
+  vec<pre_expr> avail = vec<pre_expr>();
   int i;
 
   exprs = sorted_array_from_bitmap_set (PA_IN (block));
-  VEC_safe_grow (pre_expr, heap, avail, EDGE_COUNT (block->preds));
+  avail.safe_grow (EDGE_COUNT (block->preds));
 
-  FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+  FOR_EACH_VEC_ELT (exprs, i, expr)
     {
       if (expr->kind != NAME)
 	{
@@ -3493,7 +3480,7 @@ do_partial_partial_insertion (basic_block block, basic_block dom)
 		 rest of the results are.  */
 	      if (eprime == NULL)
 		{
-		  VEC_replace (pre_expr, avail, pred->dest_idx, NULL);
+		  avail[pred->dest_idx] = NULL;
 		  cant_insert = true;
 		  break;
 		}
@@ -3501,7 +3488,7 @@ do_partial_partial_insertion (basic_block block, basic_block dom)
 	      eprime = fully_constant_expression (eprime);
 	      vprime = get_expr_value_id (eprime);
 	      edoubleprime = bitmap_find_leader (AVAIL_OUT (bprime), vprime);
-	      VEC_replace (pre_expr, avail, pred->dest_idx, edoubleprime);
+	      avail[pred->dest_idx] = edoubleprime;
 	      if (edoubleprime == NULL)
 		{
 		  by_all = false;
@@ -3564,8 +3551,8 @@ do_partial_partial_insertion (basic_block block, basic_block dom)
 	}
     }
 
-  VEC_free (pre_expr, heap, exprs);
-  VEC_free (pre_expr, heap, avail);
+  exprs.release ();
+  avail.release ();
   return new_stuff;
 }
 
@@ -3800,7 +3787,8 @@ compute_avail (void)
 	      {
 		vn_reference_t ref;
 		pre_expr result = NULL;
-		VEC(vn_reference_op_s, heap) *ops = NULL;
+		vec<vn_reference_op_s> ops
+		    = vec<vn_reference_op_s>();
 
 		/* We can value number only calls to real functions.  */
 		if (gimple_call_internal_p (stmt))
@@ -3810,7 +3798,7 @@ compute_avail (void)
 		vn_reference_lookup_pieces (gimple_vuse (stmt), 0,
 					    gimple_expr_type (stmt),
 					    ops, &ref, VN_NOWALK);
-		VEC_free (vn_reference_op_s, heap, ops);
+		ops.release ();
 		if (!ref)
 		  continue;
 
@@ -3938,11 +3926,11 @@ compute_avail (void)
 
 
 /* Local state for the eliminate domwalk.  */
-static VEC (gimple, heap) *el_to_remove;
-static VEC (gimple, heap) *el_to_update;
+static vec<gimple> el_to_remove;
+static vec<gimple> el_to_update;
 static unsigned int el_todo;
-static VEC (tree, heap) *el_avail;
-static VEC (tree, heap) *el_avail_stack;
+static vec<tree> el_avail;
+static vec<tree> el_avail_stack;
 
 /* Return a leader for OP that is available at the current point of the
    eliminate domwalk.  */
@@ -3955,8 +3943,8 @@ eliminate_avail (tree op)
     {
       if (SSA_NAME_IS_DEFAULT_DEF (valnum))
 	return valnum;
-      if (VEC_length (tree, el_avail) > SSA_NAME_VERSION (valnum))
-	return VEC_index (tree, el_avail, SSA_NAME_VERSION (valnum));
+      if (el_avail.length () > SSA_NAME_VERSION (valnum))
+	return el_avail[SSA_NAME_VERSION (valnum)];
     }
   else if (is_gimple_min_invariant (valnum))
     return valnum;
@@ -3971,11 +3959,10 @@ eliminate_push_avail (tree op)
   tree valnum = VN_INFO (op)->valnum;
   if (TREE_CODE (valnum) == SSA_NAME)
     {
-      if (VEC_length (tree, el_avail) <= SSA_NAME_VERSION (valnum))
-	VEC_safe_grow_cleared (tree, heap,
-			       el_avail, SSA_NAME_VERSION (valnum) + 1);
-      VEC_replace (tree, el_avail, SSA_NAME_VERSION (valnum), op);
-      VEC_safe_push (tree, heap, el_avail_stack, op);
+      if (el_avail.length () <= SSA_NAME_VERSION (valnum))
+	el_avail.safe_grow_cleared (SSA_NAME_VERSION (valnum) + 1);
+      el_avail[SSA_NAME_VERSION (valnum)] = op;
+      el_avail_stack.safe_push (op);
     }
 }
 
@@ -4024,7 +4011,7 @@ eliminate_bb (dom_walk_data *, basic_block b)
   gimple stmt;
 
   /* Mark new bb.  */
-  VEC_safe_push (tree, heap, el_avail_stack, NULL_TREE);
+  el_avail_stack.safe_push (NULL_TREE);
 
   for (gsi = gsi_start_phis (b); !gsi_end_p (gsi);)
     {
@@ -4082,7 +4069,7 @@ eliminate_bb (dom_walk_data *, basic_block b)
       gsi2 = gsi_after_labels (b);
       gsi_insert_before (&gsi2, stmt, GSI_NEW_STMT);
       /* Queue the copy for eventual removal.  */
-      VEC_safe_push (gimple, heap, el_to_remove, stmt);
+      el_to_remove.safe_push (stmt);
       /* If we inserted this PHI node ourself, it's not an elimination.  */
       if (inserted_exprs
 	  && bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res)))
@@ -4259,7 +4246,7 @@ eliminate_bb (dom_walk_data *, basic_block b)
 		}
 
 	      /* Queue stmt for removal.  */
-	      VEC_safe_push (gimple, heap, el_to_remove, stmt);
+	      el_to_remove.safe_push (stmt);
 	    }
 	}
       /* Visit COND_EXPRs and fold the comparison with the
@@ -4318,7 +4305,7 @@ eliminate_bb (dom_walk_data *, basic_block b)
 		}
 
 	      gimple_call_set_fn (stmt, fn);
-	      VEC_safe_push (gimple, heap, el_to_update, stmt);
+	      el_to_update.safe_push (stmt);
 
 	      /* When changing a call into a noreturn call, cfg cleanup
 		 is needed to fix up the noreturn call.  */
@@ -4360,9 +4347,8 @@ static void
 eliminate_leave_block (dom_walk_data *, basic_block)
 {
   tree entry;
-  while ((entry = VEC_pop (tree, el_avail_stack)) != NULL_TREE)
-    VEC_replace (tree, el_avail,
-		 SSA_NAME_VERSION (VN_INFO (entry)->valnum), NULL_TREE);
+  while ((entry = el_avail_stack.pop ()) != NULL_TREE)
+    el_avail[SSA_NAME_VERSION (VN_INFO (entry)->valnum)] = NULL_TREE;
 }
 
 /* Eliminate fully redundant computations.  */
@@ -4378,11 +4364,11 @@ eliminate (void)
   need_eh_cleanup = BITMAP_ALLOC (NULL);
   need_ab_cleanup = BITMAP_ALLOC (NULL);
 
-  el_to_remove = NULL;
-  el_to_update = NULL;
+  el_to_remove.create (0);
+  el_to_update.create (0);
   el_todo = 0;
-  el_avail = NULL;
-  el_avail_stack = NULL;
+  el_avail.create (0);
+  el_avail_stack.create (0);
 
   walk_data.dom_direction = CDI_DOMINATORS;
   walk_data.initialize_block_local_data = NULL;
@@ -4394,13 +4380,13 @@ eliminate (void)
   walk_dominator_tree (&walk_data, ENTRY_BLOCK_PTR);
   fini_walk_dominator_tree (&walk_data);
 
-  VEC_free (tree, heap, el_avail);
-  VEC_free (tree, heap, el_avail_stack);
+  el_avail.release ();
+  el_avail_stack.release ();
 
   /* We cannot remove stmts during BB walk, especially not release SSA
      names there as this confuses the VN machinery.  The stmts ending
      up in el_to_remove are either stores or simple copies.  */
-  FOR_EACH_VEC_ELT (gimple, el_to_remove, i, stmt)
+  FOR_EACH_VEC_ELT (el_to_remove, i, stmt)
     {
       tree lhs = gimple_assign_lhs (stmt);
       tree rhs = gimple_assign_rhs1 (stmt);
@@ -4437,14 +4423,14 @@ eliminate (void)
 	  release_defs (stmt);
 	}
     }
-  VEC_free (gimple, heap, el_to_remove);
+  el_to_remove.release ();
 
   /* We cannot update call statements with virtual operands during
      SSA walk.  This might remove them which in turn makes our
      VN lattice invalid.  */
-  FOR_EACH_VEC_ELT (gimple, el_to_update, i, stmt)
+  FOR_EACH_VEC_ELT (el_to_update, i, stmt)
     update_stmt (stmt);
-  VEC_free (gimple, heap, el_to_update);
+  el_to_update.release ();
 
   return el_todo;
 }
@@ -4601,12 +4587,11 @@ init_pre (void)
   basic_block bb;
 
   next_expression_id = 1;
-  expressions = NULL;
-  VEC_safe_push (pre_expr, heap, expressions, NULL);
-  value_expressions = VEC_alloc (bitmap, heap, get_max_value_id () + 1);
-  VEC_safe_grow_cleared (bitmap, heap, value_expressions,
-			 get_max_value_id() + 1);
-  name_to_id = NULL;
+  expressions.create (0);
+  expressions.safe_push (NULL);
+  value_expressions.create (get_max_value_id () + 1);
+  value_expressions.safe_grow_cleared (get_max_value_id() + 1);
+  name_to_id.create (0);
 
   inserted_exprs = BITMAP_ALLOC (NULL);
 
@@ -4644,14 +4629,14 @@ static void
 fini_pre ()
 {
   free (postorder);
-  VEC_free (bitmap, heap, value_expressions);
+  value_expressions.release ();
   BITMAP_FREE (inserted_exprs);
   bitmap_obstack_release (&grand_bitmap_obstack);
   free_alloc_pool (bitmap_set_pool);
   free_alloc_pool (pre_expr_pool);
   phi_translate_table.dispose ();
   expression_to_id.dispose ();
-  VEC_free (unsigned, heap, name_to_id);
+  name_to_id.release ();
 
   free_aux_for_blocks ();