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, 134 insertions, 144 deletions

diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
index 407520b5f6e..c3b8df801e5 100644
--- a/gcc/tree-ssa-uninit.c
+++ b/gcc/tree-ssa-uninit.c
@@ -241,9 +241,9 @@ find_control_equiv_block (basic_block bb)
 
 static bool
 compute_control_dep_chain (basic_block bb, basic_block dep_bb,
-                           VEC(edge, heap) **cd_chains,
+                           vec<edge> *cd_chains,
                            size_t *num_chains,
-                           VEC(edge, heap) **cur_cd_chain)
+                           vec<edge> *cur_cd_chain)
 {
   edge_iterator ei;
   edge e;
@@ -255,13 +255,13 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
     return false;
 
   /* Could  use a set instead.  */
-  cur_chain_len = VEC_length (edge, *cur_cd_chain);
+  cur_chain_len = cur_cd_chain->length ();
   if (cur_chain_len > MAX_CHAIN_LEN)
     return false;
 
   for (i = 0; i < cur_chain_len; i++)
     {
-      edge e = VEC_index (edge, *cur_cd_chain, i);
+      edge e = (*cur_cd_chain)[i];
       /* cycle detected. */
       if (e->src == bb)
         return false;
@@ -274,7 +274,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
         continue;
 
       cd_bb = e->dest;
-      VEC_safe_push (edge, heap, *cur_cd_chain, e);
+      cur_cd_chain->safe_push (e);
       while (!is_non_loop_exit_postdominating (cd_bb, bb))
         {
           if (cd_bb == dep_bb)
@@ -282,8 +282,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
               /* Found a direct control dependence.  */
               if (*num_chains < MAX_NUM_CHAINS)
                 {
-                  cd_chains[*num_chains]
-                      = VEC_copy (edge, heap, *cur_cd_chain);
+                  cd_chains[*num_chains] = cur_cd_chain->copy ();
                   (*num_chains)++;
                 }
               found_cd_chain = true;
@@ -303,10 +302,10 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
           if (cd_bb == EXIT_BLOCK_PTR)
             break;
         }
-      VEC_pop (edge, *cur_cd_chain);
-      gcc_assert (VEC_length (edge, *cur_cd_chain) == cur_chain_len);
+      cur_cd_chain->pop ();
+      gcc_assert (cur_cd_chain->length () == cur_chain_len);
     }
-  gcc_assert (VEC_length (edge, *cur_cd_chain) == cur_chain_len);
+  gcc_assert (cur_cd_chain->length () == cur_chain_len);
 
   return found_cd_chain;
 }
@@ -317,8 +316,6 @@ typedef struct use_pred_info
   bool invert;
 } *use_pred_info_t;
 
-DEF_VEC_P(use_pred_info_t);
-DEF_VEC_ALLOC_P(use_pred_info_t, heap);
 
 
 /* Converts the chains of control dependence edges into a set of
@@ -333,9 +330,9 @@ DEF_VEC_ALLOC_P(use_pred_info_t, heap);
    *NUM_PREDS is the number of composite predictes.  */
 
 static bool
-convert_control_dep_chain_into_preds (VEC(edge, heap) **dep_chains,
+convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
                                       size_t num_chains,
-                                      VEC(use_pred_info_t, heap) ***preds,
+                                      vec<use_pred_info_t> **preds,
                                       size_t *num_preds)
 {
   bool has_valid_pred = false;
@@ -345,16 +342,16 @@ convert_control_dep_chain_into_preds (VEC(edge, heap) **dep_chains,
 
   /* Now convert the control dep chain into a set
      of predicates.  */
-  *preds = XCNEWVEC (VEC(use_pred_info_t, heap) *,
-                     num_chains);
+  typedef vec<use_pred_info_t> vec_use_pred_info_t_heap;
+  *preds = XCNEWVEC (vec_use_pred_info_t_heap, num_chains);
   *num_preds = num_chains;
 
   for (i = 0; i < num_chains; i++)
     {
-      VEC(edge, heap) *one_cd_chain = dep_chains[i];
+      vec<edge> one_cd_chain = dep_chains[i];
 
       has_valid_pred = false;
-      for (j = 0; j < VEC_length (edge, one_cd_chain); j++)
+      for (j = 0; j < one_cd_chain.length (); j++)
         {
           gimple cond_stmt;
           gimple_stmt_iterator gsi;
@@ -362,7 +359,7 @@ convert_control_dep_chain_into_preds (VEC(edge, heap) **dep_chains,
           use_pred_info_t one_pred;
           edge e;
 
-          e = VEC_index (edge, one_cd_chain, j);
+          e = one_cd_chain[j];
           guard_bb = e->src;
           gsi = gsi_last_bb (guard_bb);
           if (gsi_end_p (gsi))
@@ -404,7 +401,7 @@ convert_control_dep_chain_into_preds (VEC(edge, heap) **dep_chains,
           one_pred = XNEW (struct use_pred_info);
           one_pred->cond = cond_stmt;
           one_pred->invert = !!(e->flags & EDGE_FALSE_VALUE);
-          VEC_safe_push (use_pred_info_t, heap, (*preds)[i], one_pred);
+          (*preds)[i].safe_push (one_pred);
 	  has_valid_pred = true;
         }
 
@@ -420,18 +417,19 @@ convert_control_dep_chain_into_preds (VEC(edge, heap) **dep_chains,
    the phi whose result is used in USE_BB.  */
 
 static bool
-find_predicates (VEC(use_pred_info_t, heap) ***preds,
+find_predicates (vec<use_pred_info_t> **preds,
                  size_t *num_preds,
                  basic_block phi_bb,
                  basic_block use_bb)
 {
   size_t num_chains = 0, i;
-  VEC(edge, heap) **dep_chains = 0;
-  VEC(edge, heap) *cur_chain = 0;
+  vec<edge> *dep_chains = 0;
+  vec<edge> cur_chain = vec<edge>();
   bool has_valid_pred = false;
   basic_block cd_root = 0;
 
-  dep_chains = XCNEWVEC (VEC(edge, heap) *, MAX_NUM_CHAINS);
+  typedef vec<edge> vec_edge_heap;
+  dep_chains = XCNEWVEC (vec_edge_heap, MAX_NUM_CHAINS);
 
   /* First find the closest bb that is control equivalent to PHI_BB
      that also dominates USE_BB.  */
@@ -455,9 +453,9 @@ find_predicates (VEC(use_pred_info_t, heap) ***preds,
                                               preds,
                                               num_preds);
   /* Free individual chain  */
-  VEC_free (edge, heap, cur_chain);
+  cur_chain.release ();
   for (i = 0; i < num_chains; i++)
-      VEC_free (edge, heap, dep_chains[i]);
+    dep_chains[i].release ();
   free (dep_chains);
   return has_valid_pred;
 }
@@ -470,7 +468,7 @@ find_predicates (VEC(use_pred_info_t, heap) ***preds,
 
 static void
 collect_phi_def_edges (gimple phi, basic_block cd_root,
-                       VEC(edge, heap) **edges,
+                       vec<edge> *edges,
                        struct pointer_set_t *visited_phis)
 {
   size_t i, n;
@@ -493,7 +491,7 @@ collect_phi_def_edges (gimple phi, basic_block cd_root,
               fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i);
               print_gimple_stmt (dump_file, phi, 0, 0);
             }
-          VEC_safe_push (edge, heap, *edges, opnd_edge);
+          edges->safe_push (opnd_edge);
         }
       else
         {
@@ -511,7 +509,7 @@ collect_phi_def_edges (gimple phi, basic_block cd_root,
                   fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i);
                   print_gimple_stmt (dump_file, phi, 0, 0);
                 }
-              VEC_safe_push (edge, heap, *edges, opnd_edge);
+              edges->safe_push (opnd_edge);
             }
         }
     }
@@ -522,18 +520,19 @@ collect_phi_def_edges (gimple phi, basic_block cd_root,
    composite predicates pointed to by PREDS.  */
 
 static bool
-find_def_preds (VEC(use_pred_info_t, heap) ***preds,
+find_def_preds (vec<use_pred_info_t> **preds,
                 size_t *num_preds, gimple phi)
 {
   size_t num_chains = 0, i, n;
-  VEC(edge, heap) **dep_chains = 0;
-  VEC(edge, heap) *cur_chain = 0;
-  VEC(edge, heap) *def_edges = 0;
+  vec<edge> *dep_chains = 0;
+  vec<edge> cur_chain = vec<edge>();
+  vec<edge> def_edges = vec<edge>();
   bool has_valid_pred = false;
   basic_block phi_bb, cd_root = 0;
   struct pointer_set_t *visited_phis;
 
-  dep_chains = XCNEWVEC (VEC(edge, heap) *, MAX_NUM_CHAINS);
+  typedef vec<edge> vec_edge_heap;
+  dep_chains = XCNEWVEC (vec_edge_heap, MAX_NUM_CHAINS);
 
   phi_bb = gimple_bb (phi);
   /* First find the closest dominating bb to be
@@ -546,7 +545,7 @@ find_def_preds (VEC(use_pred_info_t, heap) ***preds,
   collect_phi_def_edges (phi, cd_root, &def_edges, visited_phis);
   pointer_set_destroy (visited_phis);
 
-  n = VEC_length (edge, def_edges);
+  n = def_edges.length ();
   if (n == 0)
     return false;
 
@@ -555,14 +554,13 @@ find_def_preds (VEC(use_pred_info_t, heap) ***preds,
       size_t prev_nc, j;
       edge opnd_edge;
 
-      opnd_edge = VEC_index (edge, def_edges, i);
+      opnd_edge = def_edges[i];
       prev_nc = num_chains;
       compute_control_dep_chain (cd_root, opnd_edge->src,
                                  dep_chains, &num_chains,
                                  &cur_chain);
       /* Free individual chain  */
-      VEC_free (edge, heap, cur_chain);
-      cur_chain = 0;
+      cur_chain.release ();
 
       /* Now update the newly added chains with
          the phi operand edge:  */
@@ -573,7 +571,7 @@ find_def_preds (VEC(use_pred_info_t, heap) ***preds,
             num_chains++;
           for (j = prev_nc; j < num_chains; j++)
             {
-              VEC_safe_push (edge, heap, dep_chains[j], opnd_edge);
+              dep_chains[j].safe_push (opnd_edge);
             }
         }
     }
@@ -584,7 +582,7 @@ find_def_preds (VEC(use_pred_info_t, heap) ***preds,
                                               preds,
                                               num_preds);
   for (i = 0; i < num_chains; i++)
-      VEC_free (edge, heap, dep_chains[i]);
+    dep_chains[i].release ();
   free (dep_chains);
   return has_valid_pred;
 }
@@ -593,11 +591,11 @@ find_def_preds (VEC(use_pred_info_t, heap) ***preds,
 
 static void
 dump_predicates (gimple usestmt, size_t num_preds,
-                 VEC(use_pred_info_t, heap) **preds,
+                 vec<use_pred_info_t> *preds,
                  const char* msg)
 {
   size_t i, j;
-  VEC(use_pred_info_t, heap) *one_pred_chain;
+  vec<use_pred_info_t> one_pred_chain;
   fprintf (dump_file, msg);
   print_gimple_stmt (dump_file, usestmt, 0, 0);
   fprintf (dump_file, "is guarded by :\n");
@@ -607,12 +605,12 @@ dump_predicates (gimple usestmt, size_t num_preds,
       size_t np;
 
       one_pred_chain = preds[i];
-      np = VEC_length (use_pred_info_t, one_pred_chain);
+      np = one_pred_chain.length ();
 
       for (j = 0; j < np; j++)
         {
           use_pred_info_t one_pred
-              = VEC_index (use_pred_info_t, one_pred_chain, j);
+              = one_pred_chain[j];
           if (one_pred->invert)
             fprintf (dump_file, " (.NOT.) ");
           print_gimple_stmt (dump_file, one_pred->cond, 0, 0);
@@ -628,14 +626,14 @@ dump_predicates (gimple usestmt, size_t num_preds,
 
 static void
 destroy_predicate_vecs (size_t n,
-                        VEC(use_pred_info_t, heap) ** preds)
+                        vec<use_pred_info_t> * preds)
 {
   size_t i, j;
   for (i = 0; i < n; i++)
     {
-      for (j = 0; j < VEC_length (use_pred_info_t, preds[i]); j++)
-        free (VEC_index (use_pred_info_t, preds[i], j));
-      VEC_free (use_pred_info_t, heap, preds[i]);
+      for (j = 0; j < preds[i].length (); j++)
+        free (preds[i][j]);
+      preds[i].release ();
     }
   free (preds);
 }
@@ -733,7 +731,7 @@ is_value_included_in (tree val, tree boundary, enum tree_code cmpc)
 
 static bool
 find_matching_predicate_in_rest_chains (use_pred_info_t pred,
-                                        VEC(use_pred_info_t, heap) **preds,
+                                        vec<use_pred_info_t> *preds,
                                         size_t num_pred_chains)
 {
   size_t i, j, n;
@@ -745,12 +743,12 @@ find_matching_predicate_in_rest_chains (use_pred_info_t pred,
   for (i = 1; i < num_pred_chains; i++)
     {
       bool found = false;
-      VEC(use_pred_info_t, heap) *one_chain = preds[i];
-      n = VEC_length (use_pred_info_t, one_chain);
+      vec<use_pred_info_t> one_chain = preds[i];
+      n = one_chain.length ();
       for (j = 0; j < n; j++)
         {
           use_pred_info_t pred2
-              = VEC_index (use_pred_info_t, one_chain, j);
+              = one_chain[j];
           /* can relax the condition comparison to not
              use address comparison. However, the most common
              case is that multiple control dependent paths share
@@ -988,7 +986,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (
 static bool
 use_pred_not_overlap_with_undef_path_pred (
     size_t num_preds,
-    VEC(use_pred_info_t, heap) **preds,
+    vec<use_pred_info_t> *preds,
     gimple phi, unsigned uninit_opnds,
     struct pointer_set_t *visited_phis)
 {
@@ -998,7 +996,7 @@ use_pred_not_overlap_with_undef_path_pred (
   enum tree_code cmp_code;
   bool swap_cond = false;
   bool invert = false;
-  VEC(use_pred_info_t, heap) *the_pred_chain;
+  vec<use_pred_info_t> the_pred_chain;
   bitmap visited_flag_phis = NULL;
   bool all_pruned = false;
 
@@ -1007,14 +1005,14 @@ use_pred_not_overlap_with_undef_path_pred (
      a predicate that is a comparison of a flag variable against
      a constant.  */
   the_pred_chain = preds[0];
-  n = VEC_length (use_pred_info_t, the_pred_chain);
+  n = the_pred_chain.length ();
   for (i = 0; i < n; i++)
     {
       gimple cond;
       tree cond_lhs, cond_rhs, flag = 0;
 
       use_pred_info_t the_pred
-          = VEC_index (use_pred_info_t, the_pred_chain, i);
+          = the_pred_chain[i];
 
       cond = the_pred->cond;
       invert = the_pred->invert;
@@ -1089,7 +1087,7 @@ is_and_or_or (enum tree_code tc, tree typ)
 
 typedef struct norm_cond
 {
-  VEC(gimple, heap) *conds;
+  vec<gimple> conds;
   enum tree_code cond_code;
   bool invert;
 } *norm_cond_t;
@@ -1112,7 +1110,7 @@ normalize_cond_1 (gimple cond,
   gc = gimple_code (cond);
   if (gc != GIMPLE_ASSIGN)
     {
-      VEC_safe_push (gimple, heap, norm_cond->conds, cond);
+      norm_cond->conds.safe_push (cond);
       return;
     }
 
@@ -1132,7 +1130,7 @@ normalize_cond_1 (gimple cond,
             SSA_NAME_DEF_STMT (rhs2),
             norm_cond, cond_code);
       else
-        VEC_safe_push (gimple, heap, norm_cond->conds, cond);
+        norm_cond->conds.safe_push (cond);
 
       return;
     }
@@ -1148,7 +1146,7 @@ normalize_cond_1 (gimple cond,
       norm_cond->cond_code = cur_cond_code;
     }
   else
-    VEC_safe_push (gimple, heap, norm_cond->conds, cond);
+    norm_cond->conds.safe_push (cond);
 }
 
 /* See normalize_cond_1 for details. INVERT is a flag to indicate
@@ -1161,7 +1159,7 @@ normalize_cond (gimple cond, norm_cond_t norm_cond, bool invert)
 
   norm_cond->cond_code = ERROR_MARK;
   norm_cond->invert = false;
-  norm_cond->conds = NULL;
+  norm_cond->conds.create (0);
   gcc_assert (gimple_code (cond) == GIMPLE_COND);
   cond_code = gimple_cond_code (cond);
   if (invert)
@@ -1181,17 +1179,17 @@ normalize_cond (gimple cond, norm_cond_t norm_cond, bool invert)
             norm_cond, ERROR_MARK);
       else
         {
-          VEC_safe_push (gimple, heap, norm_cond->conds, cond);
+          norm_cond->conds.safe_push (cond);
           norm_cond->invert = invert;
         }
     }
   else
     {
-      VEC_safe_push (gimple, heap, norm_cond->conds, cond);
+      norm_cond->conds.safe_push (cond);
       norm_cond->invert = invert;
     }
 
-  gcc_assert (VEC_length (gimple, norm_cond->conds) == 1
+  gcc_assert (norm_cond->conds.length () == 1
               || is_and_or_or (norm_cond->cond_code, NULL));
 }
 
@@ -1337,12 +1335,12 @@ is_subset_of_any (gimple cond, bool invert,
                   norm_cond_t norm_cond, bool reverse)
 {
   size_t i;
-  size_t len = VEC_length (gimple, norm_cond->conds);
+  size_t len = norm_cond->conds.length ();
 
   for (i = 0; i < len; i++)
     {
       if (is_gcond_subset_of (cond, invert,
-                              VEC_index (gimple, norm_cond->conds, i),
+                              norm_cond->conds[i],
                               false, reverse))
         return true;
     }
@@ -1361,11 +1359,11 @@ is_or_set_subset_of (norm_cond_t norm_cond1,
                      norm_cond_t norm_cond2)
 {
   size_t i;
-  size_t len = VEC_length (gimple, norm_cond1->conds);
+  size_t len = norm_cond1->conds.length ();
 
   for (i = 0; i < len; i++)
     {
-      if (!is_subset_of_any (VEC_index (gimple, norm_cond1->conds, i),
+      if (!is_subset_of_any (norm_cond1->conds[i],
                              false, norm_cond2, false))
         return false;
     }
@@ -1382,11 +1380,11 @@ is_and_set_subset_of (norm_cond_t norm_cond1,
                       norm_cond_t norm_cond2)
 {
   size_t i;
-  size_t len = VEC_length (gimple, norm_cond2->conds);
+  size_t len = norm_cond2->conds.length ();
 
   for (i = 0; i < len; i++)
     {
-      if (!is_subset_of_any (VEC_index (gimple, norm_cond2->conds, i),
+      if (!is_subset_of_any (norm_cond2->conds[i],
                              false, norm_cond1, true))
         return false;
     }
@@ -1418,10 +1416,10 @@ is_norm_cond_subset_of (norm_cond_t norm_cond1,
       else if (code2 == BIT_IOR_EXPR)
         {
           size_t len1;
-          len1 = VEC_length (gimple, norm_cond1->conds);
+          len1 = norm_cond1->conds.length ();
           for (i = 0; i < len1; i++)
             {
-              gimple cond1 = VEC_index (gimple, norm_cond1->conds, i);
+              gimple cond1 = norm_cond1->conds[i];
               if (is_subset_of_any (cond1, false, norm_cond2, false))
                 return true;
             }
@@ -1430,8 +1428,8 @@ is_norm_cond_subset_of (norm_cond_t norm_cond1,
       else
         {
           gcc_assert (code2 == ERROR_MARK);
-          gcc_assert (VEC_length (gimple, norm_cond2->conds) == 1);
-          return is_subset_of_any (VEC_index (gimple, norm_cond2->conds, 0),
+          gcc_assert (norm_cond2->conds.length () == 1);
+          return is_subset_of_any (norm_cond2->conds[0],
                                    norm_cond2->invert, norm_cond1, true);
         }
     }
@@ -1446,21 +1444,21 @@ is_norm_cond_subset_of (norm_cond_t norm_cond1,
   else
     {
       gcc_assert (code1 == ERROR_MARK);
-      gcc_assert (VEC_length (gimple, norm_cond1->conds) == 1);
+      gcc_assert (norm_cond1->conds.length () == 1);
       /* Conservatively returns false if NORM_COND1 is non-decomposible
          and NORM_COND2 is an AND expression.  */
       if (code2 == BIT_AND_EXPR)
         return false;
 
       if (code2 == BIT_IOR_EXPR)
-        return is_subset_of_any (VEC_index (gimple, norm_cond1->conds, 0),
+        return is_subset_of_any (norm_cond1->conds[0],
                                  norm_cond1->invert, norm_cond2, false);
 
       gcc_assert (code2 == ERROR_MARK);
-      gcc_assert (VEC_length (gimple, norm_cond2->conds) == 1);
-      return is_gcond_subset_of (VEC_index (gimple, norm_cond1->conds, 0),
+      gcc_assert (norm_cond2->conds.length () == 1);
+      return is_gcond_subset_of (norm_cond1->conds[0],
                                  norm_cond1->invert,
-                                 VEC_index (gimple, norm_cond2->conds, 0),
+                                 norm_cond2->conds[0],
                                  norm_cond2->invert, false);
     }
 }
@@ -1502,8 +1500,8 @@ is_pred_expr_subset_of (use_pred_info_t expr1,
   is_subset = is_norm_cond_subset_of (&norm_cond1, &norm_cond2);
 
   /* Free memory  */
-  VEC_free (gimple, heap, norm_cond1.conds);
-  VEC_free (gimple, heap, norm_cond2.conds);
+  norm_cond1.conds.release ();
+  norm_cond2.conds.release ();
   return is_subset ;
 }
 
@@ -1511,23 +1509,23 @@ is_pred_expr_subset_of (use_pred_info_t expr1,
    of that of PRED2. Returns false if it can not be proved so.  */
 
 static bool
-is_pred_chain_subset_of (VEC(use_pred_info_t, heap) *pred1,
-                         VEC(use_pred_info_t, heap) *pred2)
+is_pred_chain_subset_of (vec<use_pred_info_t> pred1,
+                         vec<use_pred_info_t> pred2)
 {
   size_t np1, np2, i1, i2;
 
-  np1 = VEC_length (use_pred_info_t, pred1);
-  np2 = VEC_length (use_pred_info_t, pred2);
+  np1 = pred1.length ();
+  np2 = pred2.length ();
 
   for (i2 = 0; i2 < np2; i2++)
     {
       bool found = false;
       use_pred_info_t info2
-          = VEC_index (use_pred_info_t, pred2, i2);
+          = pred2[i2];
       for (i1 = 0; i1 < np1; i1++)
         {
           use_pred_info_t info1
-              = VEC_index (use_pred_info_t, pred1, i1);
+              = pred1[i1];
           if (is_pred_expr_subset_of (info1, info2))
             {
               found = true;
@@ -1550,8 +1548,8 @@ is_pred_chain_subset_of (VEC(use_pred_info_t, heap) *pred1,
    In other words, the result is conservative.  */
 
 static bool
-is_included_in (VEC(use_pred_info_t, heap) *one_pred,
-                VEC(use_pred_info_t, heap) **preds,
+is_included_in (vec<use_pred_info_t> one_pred,
+                vec<use_pred_info_t> *preds,
                 size_t n)
 {
   size_t i;
@@ -1579,13 +1577,13 @@ is_included_in (VEC(use_pred_info_t, heap) *one_pred,
    emitted.  */
 
 static bool
-is_superset_of (VEC(use_pred_info_t, heap) **preds1,
+is_superset_of (vec<use_pred_info_t> *preds1,
                 size_t n1,
-                VEC(use_pred_info_t, heap) **preds2,
+                vec<use_pred_info_t> *preds2,
                 size_t n2)
 {
   size_t i;
-  VEC(use_pred_info_t, heap) *one_pred_chain;
+  vec<use_pred_info_t> one_pred_chain;
 
   for (i = 0; i < n2; i++)
     {
@@ -1605,18 +1603,16 @@ static int
 pred_chain_length_cmp (const void *p1, const void *p2)
 {
   use_pred_info_t i1, i2;
-  VEC(use_pred_info_t, heap) * const *chain1
-      = (VEC(use_pred_info_t, heap) * const *)p1;
-  VEC(use_pred_info_t, heap) * const *chain2
-      = (VEC(use_pred_info_t, heap) * const *)p2;
+  vec<use_pred_info_t>  const *chain1
+      = (vec<use_pred_info_t>  const *)p1;
+  vec<use_pred_info_t>  const *chain2
+      = (vec<use_pred_info_t>  const *)p2;
 
-  if (VEC_length (use_pred_info_t, *chain1)
-      != VEC_length (use_pred_info_t, *chain2))
-    return (VEC_length (use_pred_info_t, *chain1)
-            - VEC_length (use_pred_info_t, *chain2));
+  if (chain1->length () != chain2->length ())
+    return (chain1->length () - chain2->length ());
 
-  i1 = VEC_index (use_pred_info_t, *chain1, 0);
-  i2 = VEC_index (use_pred_info_t, *chain2, 0);
+  i1 = (*chain1)[0];
+  i2 = (*chain2)[0];
 
   /* Allow predicates with similar prefix come together.  */
   if (!i1->invert && i2->invert)
@@ -1633,11 +1629,11 @@ pred_chain_length_cmp (const void *p1, const void *p2)
    the number of chains. Returns true if normalization happens.  */
 
 static bool
-normalize_preds (VEC(use_pred_info_t, heap) **preds, size_t *n)
+normalize_preds (vec<use_pred_info_t> *preds, size_t *n)
 {
   size_t i, j, ll;
-  VEC(use_pred_info_t, heap) *pred_chain;
-  VEC(use_pred_info_t, heap) *x = 0;
+  vec<use_pred_info_t> pred_chain;
+  vec<use_pred_info_t> x = vec<use_pred_info_t>();
   use_pred_info_t xj = 0, nxj = 0;
 
   if (*n < 2)
@@ -1646,21 +1642,21 @@ normalize_preds (VEC(use_pred_info_t, heap) **preds, size_t *n)
   /* First sort the chains in ascending order of lengths.  */
   qsort (preds, *n, sizeof (void *), pred_chain_length_cmp);
   pred_chain = preds[0];
-  ll = VEC_length (use_pred_info_t, pred_chain);
+  ll = pred_chain.length ();
   if (ll != 1)
    {
      if (ll == 2)
        {
          use_pred_info_t xx, yy, xx2, nyy;
-         VEC(use_pred_info_t, heap) *pred_chain2 = preds[1];
-         if (VEC_length (use_pred_info_t, pred_chain2) != 2)
+         vec<use_pred_info_t> pred_chain2 = preds[1];
+         if (pred_chain2.length () != 2)
            return false;
 
          /* See if simplification x AND y OR x AND !y is possible.  */
-         xx = VEC_index (use_pred_info_t, pred_chain, 0);
-         yy = VEC_index (use_pred_info_t, pred_chain, 1);
-         xx2 = VEC_index (use_pred_info_t, pred_chain2, 0);
-         nyy = VEC_index (use_pred_info_t, pred_chain2, 1);
+         xx = pred_chain[0];
+         yy = pred_chain[1];
+         xx2 = pred_chain2[0];
+         nyy = pred_chain2[1];
          if (gimple_cond_lhs (xx->cond) != gimple_cond_lhs (xx2->cond)
              || gimple_cond_rhs (xx->cond) != gimple_cond_rhs (xx2->cond)
              || gimple_cond_code (xx->cond) != gimple_cond_code (xx2->cond)
@@ -1676,36 +1672,34 @@ normalize_preds (VEC(use_pred_info_t, heap) **preds, size_t *n)
          free (yy);
          free (nyy);
          free (xx2);
-         VEC_free (use_pred_info_t, heap, pred_chain);
-         VEC_free (use_pred_info_t, heap, pred_chain2);
-         pred_chain = 0;
-         VEC_safe_push (use_pred_info_t, heap, pred_chain, xx);
+         pred_chain.release ();
+         pred_chain2.release ();
+         pred_chain.safe_push (xx);
          preds[0] = pred_chain;
          for (i = 1; i < *n - 1; i++)
            preds[i] = preds[i + 1];
 
-         preds[*n - 1] = 0;
+         preds[*n - 1].create (0);
          *n = *n - 1;
        }
      else
        return false;
    }
 
-  VEC_safe_push (use_pred_info_t, heap, x,
-                 VEC_index (use_pred_info_t, pred_chain, 0));
+  x.safe_push (pred_chain[0]);
 
   /* The loop extracts x1, x2, x3, etc from chains
      x1 OR (!x1 AND x2) OR (!x1 AND !x2 AND x3) OR ...  */
   for (i = 1; i < *n; i++)
     {
       pred_chain = preds[i];
-      if (VEC_length (use_pred_info_t, pred_chain) != i + 1)
+      if (pred_chain.length () != i + 1)
         return false;
 
       for (j = 0; j < i; j++)
         {
-          xj = VEC_index (use_pred_info_t, x, j);
-          nxj = VEC_index (use_pred_info_t, pred_chain, j);
+          xj = x[j];
+          nxj = pred_chain[j];
 
           /* Check if nxj is !xj  */
           if (gimple_cond_lhs (xj->cond) != gimple_cond_lhs (nxj->cond)
@@ -1715,32 +1709,29 @@ normalize_preds (VEC(use_pred_info_t, heap) **preds, size_t *n)
             return false;
         }
 
-      VEC_safe_push (use_pred_info_t, heap, x,
-                     VEC_index (use_pred_info_t, pred_chain, i));
+      x.safe_push (pred_chain[i]);
     }
 
   /* Now normalize the pred chains using the extraced x1, x2, x3 etc.  */
   for (j = 0; j < *n; j++)
     {
       use_pred_info_t t;
-      xj = VEC_index (use_pred_info_t, x, j);
+      xj = x[j];
 
       t = XNEW (struct use_pred_info);
       *t = *xj;
 
-      VEC_replace (use_pred_info_t, x, j, t);
+      x[j] = t;
     }
 
   for (i = 0; i < *n; i++)
     {
       pred_chain = preds[i];
-      for (j = 0; j < VEC_length (use_pred_info_t, pred_chain); j++)
-        free (VEC_index (use_pred_info_t, pred_chain, j));
-      VEC_free (use_pred_info_t, heap, pred_chain);
-      pred_chain = 0;
+      for (j = 0; j < pred_chain.length (); j++)
+        free (pred_chain[j]);
+      pred_chain.release ();
       /* A new chain.  */
-      VEC_safe_push (use_pred_info_t, heap, pred_chain,
-                     VEC_index (use_pred_info_t, x, i));
+      pred_chain.safe_push (x[i]);
       preds[i] = pred_chain;
     }
   return true;
@@ -1769,8 +1760,8 @@ is_use_properly_guarded (gimple use_stmt,
                          struct pointer_set_t *visited_phis)
 {
   basic_block phi_bb;
-  VEC(use_pred_info_t, heap) **preds = 0;
-  VEC(use_pred_info_t, heap) **def_preds = 0;
+  vec<use_pred_info_t> *preds = 0;
+  vec<use_pred_info_t> *def_preds = 0;
   size_t num_preds = 0, num_def_preds = 0;
   bool has_valid_preds = false;
   bool is_properly_guarded = false;
@@ -1840,7 +1831,7 @@ is_use_properly_guarded (gimple use_stmt,
 
 static gimple
 find_uninit_use (gimple phi, unsigned uninit_opnds,
-                 VEC(gimple, heap) **worklist,
+                 vec<gimple> *worklist,
 		 struct pointer_set_t *added_to_worklist)
 {
   tree phi_result;
@@ -1898,9 +1889,8 @@ find_uninit_use (gimple phi, unsigned uninit_opnds,
               print_gimple_stmt (dump_file, use_stmt, 0, 0);
             }
 
-          VEC_safe_push (gimple, heap, *worklist, use_stmt);
-          pointer_set_insert (possibly_undefined_names,
-	                      phi_result);
+          worklist->safe_push (use_stmt);
+          pointer_set_insert (possibly_undefined_names, phi_result);
         }
     }
 
@@ -1916,7 +1906,7 @@ find_uninit_use (gimple phi, unsigned uninit_opnds,
    a pointer set tracking if the new phi is added to the worklist or not.  */
 
 static void
-warn_uninitialized_phi (gimple phi, VEC(gimple, heap) **worklist,
+warn_uninitialized_phi (gimple phi, vec<gimple> *worklist,
                         struct pointer_set_t *added_to_worklist)
 {
   unsigned uninit_opnds;
@@ -1964,7 +1954,7 @@ execute_late_warn_uninitialized (void)
 {
   basic_block bb;
   gimple_stmt_iterator gsi;
-  VEC(gimple, heap) *worklist = 0;
+  vec<gimple> worklist = vec<gimple>();
   struct pointer_set_t *added_to_worklist;
 
   calculate_dominance_info (CDI_DOMINATORS);
@@ -1998,7 +1988,7 @@ execute_late_warn_uninitialized (void)
             if (TREE_CODE (op) == SSA_NAME
                 && ssa_undefined_value_p (op))
               {
-                VEC_safe_push (gimple, heap, worklist, phi);
+                worklist.safe_push (phi);
 		pointer_set_insert (added_to_worklist, phi);
                 if (dump_file && (dump_flags & TDF_DETAILS))
                   {
@@ -2010,14 +2000,14 @@ execute_late_warn_uninitialized (void)
           }
       }
 
-  while (VEC_length (gimple, worklist) != 0)
+  while (worklist.length () != 0)
     {
       gimple cur_phi = 0;
-      cur_phi = VEC_pop (gimple, worklist);
+      cur_phi = worklist.pop ();
       warn_uninitialized_phi (cur_phi, &worklist, added_to_worklist);
     }
 
-  VEC_free (gimple, heap, worklist);
+  worklist.release ();
   pointer_set_destroy (added_to_worklist);
   pointer_set_destroy (possibly_undefined_names);
   possibly_undefined_names = NULL;