This patch rewrites the old VEC macro-based interface into a new one based on the template class 'vec'.

This patch rewrites the old VEC macro-based interface into a new one
based on the template class 'vec'.  The user-visible changes are
described in http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec.

I have tested the patch pretty extensively:

- Regular bootstraps on x86_64, ppc, ia64, sparc and hppa.
- Bootstraps with --enable-checking=release
- Bootstraps with --enable-checking=gc,gcac
- Basic builds on all targets (using contrib/config-list.mk).

We no longer access the vectors via VEC_* macros.  The pattern is
"VEC_operation (T, A, V, args)" becomes "V.operation (args)".

The only thing I could not do is create proper ctors and dtors for the
vec class.  Since these vectors are stored in unions, we
have to keep them as PODs (C++03 does not allow non-PODs in unions).

This means that creation and destruction must be explicit.  There is a
new method vec<type, allocation, layout>::create() and another vec<type,
allocation, layout>::destroy() to allocate the internal vector.

For vectors that must be pointers, there is a family of free functions
that implement the operations that need to tolerate NULL vectors.
These functions all start with the prefix 'vec_safe_'.  See the wiki
page for details.

The gengtype change removes the special handling for VEC() that used
to exist in gengtype. Additionally, it allows gengtype to recognize
templates of more than one argument and introduces the concept of an
undefined type (useful for template arguments that may or may not be
types).

When a TYPE_UNDEFINED is reached, gengtype will ignore it if it
happens inside a type marked with GTY((user)).  Otherwise, it will
emit an error.

Finally, gengtype rejects root types marked GTY((user)) that are not
first class pointers.

2012-11-16  Diego Novillo  <dnovillo@google.com>

	VEC API overhaul (http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec)

	* vec.c (register_overhead): Convert it into
	member function of vec_prefix.
	(release_overhead): Likewise.
	(calculate_allocation): Likewise.
	(vec_heap_free): Remove.
	(vec_gc_o_reserve_1): Remove.
	(vec_heap_o_reserve_1): Remove.
	(vec_stack_o_reserve_1): Remove.
	(vec_stack_o_reserve_exact): Remove.
	(register_stack_vec): New.
	(stack_vec_register_index): New.
	(unregister_stack_vec): New.
	(vec_assert_fail): Remove.
	* vec.h: Conditionally include ggc.h.  Document conditional
	hackery.
	Update top-level documentation.
	(ALONE_VEC_CHECK_INFO): Remove.
	(VEC_CHECK_INFO): Remove.
	(ALONE_VEC_CHECK_DECL): Remove.
	(VEC_CHECK_DECL): Remove.
	(ALONE_VEC_CHECK_PASS): Remove.
	(VEC_CHECK_PASS): Remove.
	(VEC_ASSERT): Remove.
	(vec_prefix): Add friends va_gc, va_gc_atomic, va_heap and
	va_stack.
	Mark fields alloc_ and num_ as protected.
	(struct vec_t): Remove.  Remove all function members.
	(struct vl_embed): Declare.
	(struct vl_ptr): Declare.
	(free): Remove.
	(reserve_exact): Remove.
	(reserve): Remove.
	(safe_splice): Remove.
	(safe_push): Remove.
	(safe_grow): Remove.
	(safe_grow_cleared): Remove.
	(safe_insert): Remove.
	(DEF_VEC_I): Remove.
	(DEF_VEC_ALLOC_I): Remove.
	(DEF_VEC_P): Remove.
	(DEF_VEC_ALLOC_P): Remove.
	(DEF_VEC_O): Remove.
	(DEF_VEC_ALLOC_O): Remove.
	(DEF_VEC_ALLOC_P_STACK): Remove.
	(DEF_VEC_ALLOC_O_STACK): Remove.
	(DEF_VEC_ALLOC_I_STACK): Remove.
	(DEF_VEC_A): Remove.
	(DEF_VEC_ALLOC_A): Remove.
	(vec_stack_p_reserve_exact_1): Remove.
	(vec_stack_o_reserve): Remove.
	(vec_stack_o_reserve_exact): Remove.
	(VEC_length): Remove.
	(VEC_empty): Remove.
	(VEC_address): Remove.
	(vec_address): Remove.
	(VEC_last): Remove.
	(VEC_index): Remove.
	(VEC_iterate): Remove.
	(VEC_embedded_size): Remove.
	(VEC_embedded_init): Remove.
	(VEC_free): Remove.
	(VEC_copy): Remove.
	(VEC_space): Remove.
	(VEC_reserve): Remove.
	(VEC_reserve_exact): Remove.
	(VEC_splice): Remove.
	(VEC_safe_splice): Remove.
	(VEC_quick_push): Remove.
	(VEC_safe_push): Remove.
	(VEC_pop): Remove.
	(VEC_truncate): Remove.
	(VEC_safe_grow): Remove.
	(VEC_replace): Remove.
	(VEC_quick_insert): Remove.
	(VEC_safe_insert): Remove.
	(VEC_ordered_remove): Remove.
	(VEC_unordered_remove): Remove.
	(VEC_block_remove): Remove.
	(VEC_lower_bound): Remove.
	(VEC_alloc): Remove.
	(VEC_qsort): Remove.

	(va_heap): Declare.
	(va_heap::default_layout): New typedef to vl_ptr.
	(va_heap::reserve): New.
	(va_heap::release): New.
	(va_gc): Declare.
	(va_gc::default_layout): New typedef to vl_embed.
	(va_gc::reserve): New.
	(va_gc::release): New.
	(va_gc_atomic): Declare.  Inherit from va_gc.
	(va_stack): Declare.
	(va_stack::default_layout): New typedef to vl_ptr.
	(va_stack::alloc): New.
	(va_stack::reserve): New.
	(va_stack::release): New.
	(register_stack_vec): Declare.
	(stack_vec_register_index): Declare.
	(unregister_stack_vec): Declare.

	(vec<T, A = va_heap, L = typename A::default_layout>): Declare
	empty vec template.
	(vec<T, A, vl_embed>): Partial specialization for embedded
	layout.
	(vec<T, A, vl_embed>::allocated): New.
	(vec<T, A, vl_embed>::length): New.
	(vec<T, A, vl_embed>::is_empty): New.
	(vec<T, A, vl_embed>::address): New.
	(vec<T, A, vl_embed>::operator[]): New.
	(vec<T, A, vl_embed>::last New.
	(vec<T, A, vl_embed>::space): New.
	(vec<T, A, vl_embed>::iterate): New.
	(vec<T, A, vl_embed>::iterate): New.
	(vec<T, A, vl_embed>::copy): New.
	(vec<T, A, vl_embed>::splice): New.
	(vec<T, A, vl_embed>::quick_push New.
	(vec<T, A, vl_embed>::pop New.
	(vec<T, A, vl_embed>::truncate): New.
	(vec<T, A, vl_embed>::quick_insert): New.
	(vec<T, A, vl_embed>::ordered_remove): New.
	(vec<T, A, vl_embed>::unordered_remove): New.
	(vec<T, A, vl_embed>::block_remove): New.
	(vec<T, A, vl_embed>::qsort): New.
	(vec<T, A, vl_embed>::lower_bound): New.
	(vec<T, A, vl_embed>::embedded_size): New.
	(vec<T, A, vl_embed>::embedded_init): New.
	(vec<T, A, vl_embed>::quick_grow): New.
	(vec<T, A, vl_embed>::quick_grow_cleared): New.
	(vec_safe_space): New.
	(vec_safe_length): New.
	(vec_safe_address): New.
	(vec_safe_is_empty): New.
	(vec_safe_reserve): New.
	(vec_safe_reserve_exact): New.
	(vec_alloc): New.
	(vec_free): New.
	(vec_safe_grow): New.
	(vec_safe_grow_cleared): New.
	(vec_safe_iterate): New.
	(vec_safe_push): New.
	(vec_safe_insert): New.
	(vec_safe_truncate): New.
	(vec_safe_copy): New.
	(vec_safe_splice): New.

	(vec<T, A, vl_ptr>): New partial specialization for the space
	efficient layout.
	(vec<T, A, vl_ptr>::exists): New.
	(vec<T, A, vl_ptr>::is_empty): New.
	(vec<T, A, vl_ptr>::length): New.
	(vec<T, A, vl_ptr>::address): New.
	(vec<T, A, vl_ptr>::operator[]): New.
	(vec<T, A, vl_ptr>::operator!=): New.
	(vec<T, A, vl_ptr>::operator==): New.
	(vec<T, A, vl_ptr>::last): New.
	(vec<T, A, vl_ptr>::space): New.
	(vec<T, A, vl_ptr>::iterate): New.
	(vec<T, A, vl_ptr>::copy): New.
	(vec<T, A, vl_ptr>::reserve): New.
	(vec<T, A, vl_ptr>::reserve_exact): New.
	(vec<T, A, vl_ptr>::splice): New.
	(vec<T, A, vl_ptr>::safe_splice): New.
	(vec<T, A, vl_ptr>::quick_push): New.
	(vec<T, A, vl_ptr>::safe_push): New.
	(vec<T, A, vl_ptr>::pop): New.
	(vec<T, A, vl_ptr>::truncate): New.
	(vec<T, A, vl_ptr>::safe_grow): New.
	(vec<T, A, vl_ptr>::safe_grow_cleared): New.
	(vec<T, A, vl_ptr>::quick_grow): New.
	(vec<T, A, vl_ptr>::quick_grow_cleared): New.
	(vec<T, A, vl_ptr>::quick_insert): New.
	(vec<T, A, vl_ptr>::safe_insert): New.
	(vec<T, A, vl_ptr>::ordered_remove): New.
	(vec<T, A, vl_ptr>::unordered_remove): New.
	(vec<T, A, vl_ptr>::block_remove): New.
	(vec<T, A, vl_ptr>::qsort): New.
	(vec<T, A, vl_ptr>::lower_bound): New.
	(vec_stack_alloc): Define.
	(FOR_EACH_VEC_SAFE_ELT): Define.
	* vecir.h: Remove.  Update all users.
	* vecprim.h: Remove.  Update all users.
	Move uchar to coretypes.h.

	* Makefile.in (VEC_H): Add $(GGC_H).
	Remove vecir.h and vecprim.h dependencies everywhere.

2012-11-16  Diego Novillo  <dnovillo@google.com>

	* gengtype-lex.l (VEC): Remove.
	Add characters in the set [\!\>\.-].
	* gengtype-parse.c (token_names): Remove "VEC".
	(require_template_declaration): Remove handling of VEC_TOKEN.
	(type): Likewise.
	Call create_user_defined_type when parsing GTY((user)).
	* gengtype-state.c (type_lineloc): handle TYPE_UNDEFINED.
	(write_state_undefined_type): New.
	(write_state_type): Call write_state_undefined_type for
	TYPE_UNDEFINED.
	(read_state_type): Call read_state_undefined_type for
	TYPE_UNDEFINED.
	* gengtype.c (dbgprint_count_type_at): Handle TYPE_UNDEFINED.
	(create_user_defined_type): Make extern.
	(type_for_name): Factor out of resolve_typedef.
	(create_undefined_type): New
	(resolve_typedef): Call it when we cannot find a previous
	typedef and the type is not a template.
	(find_structure): Accept TYPE_UNDEFINED.
	(set_gc_used_type): Add argument ALLOWED_UNDEFINED_TYPES,
	default to false.
	Emit an error for TYPE_UNDEFINED unless LEVEL is GC_UNUSED or
	ALLOWED_UNDEFINED_TYPES is set.
	Set ALLOWED_UNDEFINED_TYPES to true for TYPE_USER_STRUCT.
	(filter_type_name): Accept templates with more than one
	argument.
	(output_mangled_typename): Handle TYPE_UNDEFINED
	(walk_type): Likewise.
	(write_types_process_field): Likewise.
	(write_func_for_structure): If CHAIN_NEXT is set, ORIG_S
	should not be a user-defined type.
	(write_types_local_user_process_field): Handle TYPE_ARRAY,
	TYPE_NONE and TYPE_UNDEFINED.
	(write_types_local_process_field): Likewise.
	(contains_scalar_p): Return 0 for TYPE_USER_STRUCT.
	(write_root): Reject user-defined types that are not pointers.
	Handle TYPE_NONE, TYPE_UNDEFINED, TYPE_UNION, TYPE_LANG_STRUCT
	and TYPE_PARAM_STRUCT.
	(output_typename): Handle TYPE_NONE, TYPE_UNDEFINED, and
	TYPE_ARRAY.
	(dump_typekind): Handle TYPE_UNDEFINED.
	* gengtype.h (enum typekind): Add TYPE_UNDEFINED.
	(create_user_defined_type): Declare.
	(enum gty_token): Remove VEC_TOKEN.

2012-11-16  Diego Novillo  <dnovillo@google.com>

	Adjust for new vec API (http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec)

	* coretypes.h (uchar): Define.
	* alias.c: Use new vec API in vec.h.
	* asan.c: Likewise.
	* attribs.c: Likewise.
	* basic-block.h: Likewise.
	* bb-reorder.c: Likewise.
	* builtins.c: Likewise.
	* calls.c: Likewise.
	* cfg.c: Likewise.
	* cfganal.c: Likewise.
	* cfgcleanup.c: Likewise.
	* cfgexpand.c: Likewise.
	* cfghooks.c: Likewise.
	* cfghooks.h: Likewise.
	* cfgloop.c: Likewise.
	* cfgloop.h: Likewise.
	* cfgloopanal.c: Likewise.
	* cfgloopmanip.c: Likewise.
	* cfgrtl.c: Likewise.
	* cgraph.c: Likewise.
	* cgraph.h: Likewise.
	* cgraphclones.c: Likewise.
	* cgraphunit.c: Likewise.
	* combine.c: Likewise.
	* compare-elim.c: Likewise.
	* coverage.c: Likewise.
	* cprop.c: Likewise.
	* data-streamer.h: Likewise.
	* dbxout.c: Likewise.
	* dce.c: Likewise.
	* df-core.c: Likewise.
	* df-problems.c: Likewise.
	* df-scan.c: Likewise.
	* dominance.c: Likewise.
	* domwalk.c: Likewise.
	* domwalk.h: Likewise.
	* dse.c: Likewise.
	* dwarf2cfi.c: Likewise.
	* dwarf2out.c: Likewise.
	* dwarf2out.h: Likewise.
	* emit-rtl.c: Likewise.
	* except.c: Likewise.
	* except.h: Likewise.
	* expr.c: Likewise.
	* expr.h: Likewise.
	* final.c: Likewise.
	* fold-const.c: Likewise.
	* function.c: Likewise.
	* function.h: Likewise.
	* fwprop.c: Likewise.
	* gcc.c: Likewise.
	* gcse.c: Likewise.
	* genattr.c: Likewise.
	* genattrtab.c: Likewise.
	* genautomata.c: Likewise.
	* genextract.c: Likewise.
	* genopinit.c: Likewise
	* ggc-common.c: Likewise.
	* ggc.h: Likewise.
	* gimple-low.c: Likewise.
	* gimple-ssa-strength-reduction.c: Likewise.
	* gimple-streamer-in.c: Likewise.
	* gimple.c: Likewise.
	* gimple.h: Likewise.
	* gimplify.c: Likewise.
	* graph.c: Likewise.
	* graphds.c: Likewise.
	* graphds.h: Likewise.
	* graphite-blocking.c: Likewise.
	* graphite-clast-to-gimple.c: Likewise.
	* graphite-dependences.c: Likewise.
	* graphite-interchange.c: Likewise.
	* graphite-optimize-isl.c: Likewise.
	* graphite-poly.c: Likewise.
	* graphite-poly.h: Likewise.
	* graphite-scop-detection.c: Likewise.
	* graphite-scop-detection.h: Likewise.
	* graphite-sese-to-poly.c: Likewise.
	* graphite.c: Likewise.
	* godump.c: Likewise.
	* haifa-sched.c: Likewise.
	* hw-doloop.c: Likewise.
	* hw-doloop.h: Likewise.
	* ifcvt.c: Likewise.
	* insn-addr.h: Likewise.
	* ipa-cp.c: Likewise.
	* ipa-inline-analysis.c: Likewise.
	* ipa-inline-transform.c: Likewise.
	* ipa-inline.c: Likewise.
	* ipa-inline.h: Likewise.
	* ipa-prop.c: Likewise.
	* ipa-prop.h: Likewise.
	* ipa-pure-const.c: Likewise.
	* ipa-ref-inline.h: Likewise.
	* ipa-ref.c: Likewise.
	* ipa-ref.h: Likewise.
	* ipa-reference.c: Likewise.
	* ipa-split.c: Likewise.
	* ipa-utils.c: Likewise.
	* ipa-utils.h: Likewise.
	* ipa.c: Likewise.
	* ira-build.c: Likewise.
	* ira-color.c: Likewise.
	* ira-emit.c: Likewise.
	* ira-int.h: Likewise.
	* ira.c: Likewise.
	* loop-invariant.c: Likewise.
	* loop-unroll.c: Likewise.
	* lower-subreg.c: Likewise.
	* lra-lives.c: Likewise.
	* lra.c: Likewise.
	* lto-cgraph.c: Likewise.
	* lto-section-out.c: Likewise.
	* lto-streamer-in.c: Likewise.
	* lto-streamer-out.c: Likewise.
	* lto-streamer.h: Likewise.
	* lto-symtab.c: Likewise.
	* mcf.c: Likewise.
	* modulo-sched.c: Likewise.
	* omp-low.c: Likewise.
	* opts-common.c: Likewise.
	* opts-global.c: Likewise.
	* opts.c: Likewise.
	* opts.h: Likewise.
	* passes.c: Likewise.
	* predict.c: Likewise.
	* print-tree.c: Likewise.
	* profile.c: Likewise.
	* profile.h: Likewise.
	* read-rtl.c: Likewise.
	* ree.c: Likewise.
	* reg-stack.c: Likewise.
	* regrename.c: Likewise.
	* regrename.h: Likewise.
	* reload.c: Likewise.
	* reload.h: Likewise.
	* reload1.c: Likewise.
	* rtl.h: Likewise.
	* sched-deps.c: Likewise.
	* sched-int.h: Likewise.
	* sdbout.c: Likewise.
	* sel-sched-dump.c: Likewise.
	* sel-sched-ir.c: Likewise.
	* sel-sched-ir.h: Likewise.
	* sel-sched.c: Likewise.
	* sese.c: Likewise.
	* sese.h: Likewise.
	* statistics.h: Likewise.
	* stmt.c: Likewise.
	* stor-layout.c: Likewise.
	* store-motion.c: Likewise.
	* tlink.c: Likewise.
	* toplev.c: Likewise.
	* trans-mem.c: Likewise.
	* tree-browser.c: Likewise.
	* tree-call-cdce.c: Likewise.
	* tree-cfg.c: Likewise.
	* tree-cfgcleanup.c: Likewise.
	* tree-chrec.c: Likewise.
	* tree-chrec.h: Likewise.
	* tree-complex.c: Likewise.
	* tree-data-ref.c: Likewise.
	* tree-data-ref.h: Likewise.
	* tree-dfa.c: Likewise.
	* tree-diagnostic.c: Likewise.
	* tree-dump.c: Likewise.
	* tree-eh.c: Likewise.
	* tree-emutls.c: Likewise.
	* tree-flow.h: Likewise.
	* tree-if-conv.c: Likewise.
	* tree-inline.c: Likewise.
	* tree-inline.h: Likewise.
	* tree-into-ssa.c: Likewise.
	* tree-iterator.c: Likewise.
	* tree-loop-distribution.c: Likewise.
	* tree-mudflap.c: Likewise.
	* tree-optimize.c: Likewise.
	* tree-outof-ssa.c: Likewise.
	* tree-parloops.c: Likewise.
	* tree-phinodes.c: Likewise.
	* tree-predcom.c: Likewise.
	* tree-pretty-print.c: Likewise.
	* tree-scalar-evolution.c: Likewise.
	* tree-sra.c: Likewise.
	* tree-ssa-address.c: Likewise.
	* tree-ssa-alias.c: Likewise.
	* tree-ssa-ccp.c: Likewise.
	* tree-ssa-coalesce.c: Likewise.
	* tree-ssa-dce.c: Likewise.
	* tree-ssa-dom.c: Likewise.
	* tree-ssa-forwprop.c: Likewise.
	* tree-ssa-live.c: Likewise.
	* tree-ssa-live.h: Likewise.
	* tree-ssa-loop-im.c: Likewise.
	* tree-ssa-loop-ivcanon.c: Likewise.
	* tree-ssa-loop-ivopts.c: Likewise.
	* tree-ssa-loop-manip.c: Likewise.
	* tree-ssa-loop-niter.c: Likewise.
	* tree-ssa-loop-prefetch.c: Likewise.
	* tree-ssa-math-opts.c: Likewise.
	* tree-ssa-operands.c: Likewise.
	* tree-ssa-phiopt.c: Likewise.
	* tree-ssa-phiprop.c: Likewise.
	* tree-ssa-pre.c: Likewise.
	* tree-ssa-propagate.c: Likewise.
	* tree-ssa-reassoc.c: Likewise.
	* tree-ssa-sccvn.c: Likewise.
	* tree-ssa-sccvn.h: Likewise.
	* tree-ssa-strlen.c: Likewise.
	* tree-ssa-structalias.c: Likewise.
	* tree-ssa-tail-merge.c: Likewise.
	* tree-ssa-threadedge.c: Likewise.
	* tree-ssa-threadupdate.c: Likewise.
	* tree-ssa-uncprop.c: Likewise.
	* tree-ssa-uninit.c: Likewise.
	* tree-ssa.c: Likewise.
	* tree-ssanames.c: Likewise.
	* tree-stdarg.c: Likewise.
	* tree-streamer-in.c: Likewise.
	* tree-streamer-out.c: Likewise.
	* tree-streamer.c: Likewise.
	* tree-streamer.h: Likewise.
	* tree-switch-conversion.c: Likewise.
	* tree-vect-data-refs.c: Likewise.
	* tree-vect-generic.c: Likewise.
	* tree-vect-loop-manip.c: Likewise.
	* tree-vect-loop.c: Likewise.
	* tree-vect-patterns.c: Likewise.
	* tree-vect-slp.c: Likewise.
	* tree-vect-stmts.c: Likewise.
	* tree-vectorizer.c: Likewise.
	* tree-vectorizer.h: Likewise.
	* tree-vrp.c: Likewise.
	* tree.c: Likewise.
	* tree.h: Likewise.
	* value-prof.c: Likewise.
	* value-prof.h: Likewise.
	* var-tracking.c: Likewise.
	* varasm.c: Likewise.
	* varpool.c: Likewise.
	* vmsdbgout.c: Likewise.
	* config/bfin/bfin.c: Likewise.
	* config/c6x/c6x.c: Likewise.
	* config/darwin.c: Likewise.
	* config/i386/i386.c: Likewise.
	* config/ia64/ia64.c: Likewise.
	* config/mep/mep.c: Likewise.
	* config/mips/mips.c: Likewise.
	* config/pa/pa.c: Likewise.
	* config/rs6000/rs6000-c.c: Likewise.
	* config/rs6000/rs6000.c: Likewise.
	* config/rx/rx.c: Likewise.
	* config/spu/spu-c.c: Likewise.
	* config/vms/vms.c: Likewise.
	* config/vxworks.c: Likewise.
	* config/epiphany/resolve-sw-modes.c: Likewise.

From-SVN: r193595

1 files changed, 167 insertions, 184 deletions

diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index 3503c64..471b8e6 100644
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -444,8 +444,6 @@ get_rank (tree e)
   return 0;
 }
 
-DEF_VEC_P(operand_entry_t);
-DEF_VEC_ALLOC_P(operand_entry_t, heap);
 
 /* We want integer ones to end up last no matter what, since they are
    the ones we can do the most with.  */
@@ -508,7 +506,7 @@ sort_by_operand_rank (const void *pa, const void *pb)
 /* Add an operand entry to *OPS for the tree operand OP.  */
 
 static void
-add_to_ops_vec (VEC(operand_entry_t, heap) **ops, tree op)
+add_to_ops_vec (vec<operand_entry_t> *ops, tree op)
 {
   operand_entry_t oe = (operand_entry_t) pool_alloc (operand_entry_pool);
 
@@ -516,14 +514,14 @@ add_to_ops_vec (VEC(operand_entry_t, heap) **ops, tree op)
   oe->rank = get_rank (op);
   oe->id = next_operand_entry_id++;
   oe->count = 1;
-  VEC_safe_push (operand_entry_t, heap, *ops, oe);
+  ops->safe_push (oe);
 }
 
 /* Add an operand entry to *OPS for the tree operand OP with repeat
    count REPEAT.  */
 
 static void
-add_repeat_to_ops_vec (VEC(operand_entry_t, heap) **ops, tree op,
+add_repeat_to_ops_vec (vec<operand_entry_t> *ops, tree op,
 		       HOST_WIDE_INT repeat)
 {
   operand_entry_t oe = (operand_entry_t) pool_alloc (operand_entry_pool);
@@ -532,7 +530,7 @@ add_repeat_to_ops_vec (VEC(operand_entry_t, heap) **ops, tree op,
   oe->rank = get_rank (op);
   oe->id = next_operand_entry_id++;
   oe->count = repeat;
-  VEC_safe_push (operand_entry_t, heap, *ops, oe);
+  ops->safe_push (oe);
 
   reassociate_stats.pows_encountered++;
 }
@@ -582,7 +580,7 @@ get_unary_op (tree name, enum tree_code opcode)
 
 static bool
 eliminate_duplicate_pair (enum tree_code opcode,
-			  VEC (operand_entry_t, heap) **ops,
+			  vec<operand_entry_t> *ops,
 			  bool *all_done,
 			  unsigned int i,
 			  operand_entry_t curr,
@@ -612,7 +610,7 @@ eliminate_duplicate_pair (enum tree_code opcode,
 	      print_generic_stmt (dump_file, last->op, 0);
 	    }
 
-	  VEC_ordered_remove (operand_entry_t, *ops, i);
+	  ops->ordered_remove (i);
 	  reassociate_stats.ops_eliminated ++;
 
 	  return true;
@@ -629,17 +627,16 @@ eliminate_duplicate_pair (enum tree_code opcode,
 
 	  reassociate_stats.ops_eliminated += 2;
 
-	  if (VEC_length (operand_entry_t, *ops) == 2)
+	  if (ops->length () == 2)
 	    {
-	      VEC_free (operand_entry_t, heap, *ops);
-	      *ops = NULL;
+	      ops->create (0);
 	      add_to_ops_vec (ops, build_zero_cst (TREE_TYPE (last->op)));
 	      *all_done = true;
 	    }
 	  else
 	    {
-	      VEC_ordered_remove (operand_entry_t, *ops, i-1);
-	      VEC_ordered_remove (operand_entry_t, *ops, i-1);
+	      ops->ordered_remove (i-1);
+	      ops->ordered_remove (i-1);
 	    }
 
 	  return true;
@@ -651,7 +648,7 @@ eliminate_duplicate_pair (enum tree_code opcode,
   return false;
 }
 
-static VEC(tree, heap) *plus_negates;
+static vec<tree> plus_negates;
 
 /* If OPCODE is PLUS_EXPR, CURR->OP is a negate expression or a bitwise not
    expression, look in OPS for a corresponding positive operation to cancel
@@ -661,7 +658,7 @@ static VEC(tree, heap) *plus_negates;
 
 static bool
 eliminate_plus_minus_pair (enum tree_code opcode,
-			   VEC (operand_entry_t, heap) **ops,
+			   vec<operand_entry_t> *ops,
 			   unsigned int currindex,
 			   operand_entry_t curr)
 {
@@ -683,7 +680,7 @@ eliminate_plus_minus_pair (enum tree_code opcode,
      one, we can stop.  */
 
   for (i = currindex + 1;
-       VEC_iterate (operand_entry_t, *ops, i, oe)
+       ops->iterate (i, &oe)
        && oe->rank >= curr->rank - 1 ;
        i++)
     {
@@ -699,9 +696,9 @@ eliminate_plus_minus_pair (enum tree_code opcode,
 	      fprintf (dump_file, " -> 0\n");
 	    }
 
-	  VEC_ordered_remove (operand_entry_t, *ops, i);
+	  ops->ordered_remove (i);
 	  add_to_ops_vec (ops, build_zero_cst (TREE_TYPE (oe->op)));
-	  VEC_ordered_remove (operand_entry_t, *ops, currindex);
+	  ops->ordered_remove (currindex);
 	  reassociate_stats.ops_eliminated ++;
 
 	  return true;
@@ -719,9 +716,9 @@ eliminate_plus_minus_pair (enum tree_code opcode,
 	      fprintf (dump_file, " -> -1\n");
 	    }
 
-	  VEC_ordered_remove (operand_entry_t, *ops, i);
+	  ops->ordered_remove (i);
 	  add_to_ops_vec (ops, build_int_cst_type (op_type, -1));
-	  VEC_ordered_remove (operand_entry_t, *ops, currindex);
+	  ops->ordered_remove (currindex);
 	  reassociate_stats.ops_eliminated ++;
 
 	  return true;
@@ -731,7 +728,7 @@ eliminate_plus_minus_pair (enum tree_code opcode,
   /* CURR->OP is a negate expr in a plus expr: save it for later
      inspection in repropagate_negates().  */
   if (negateop != NULL_TREE)
-    VEC_safe_push (tree, heap, plus_negates, curr->op);
+    plus_negates.safe_push (curr->op);
 
   return false;
 }
@@ -744,7 +741,7 @@ eliminate_plus_minus_pair (enum tree_code opcode,
 
 static bool
 eliminate_not_pairs (enum tree_code opcode,
-		     VEC (operand_entry_t, heap) **ops,
+		     vec<operand_entry_t> *ops,
 		     unsigned int currindex,
 		     operand_entry_t curr)
 {
@@ -765,7 +762,7 @@ eliminate_not_pairs (enum tree_code opcode,
      one, we can stop.  */
 
   for (i = currindex + 1;
-       VEC_iterate (operand_entry_t, *ops, i, oe)
+       ops->iterate (i, &oe)
        && oe->rank >= curr->rank - 1;
        i++)
     {
@@ -792,11 +789,9 @@ eliminate_not_pairs (enum tree_code opcode,
 	    oe->op = build_low_bits_mask (TREE_TYPE (oe->op),
 					  TYPE_PRECISION (TREE_TYPE (oe->op)));
 
-	  reassociate_stats.ops_eliminated
-	    += VEC_length (operand_entry_t, *ops) - 1;
-	  VEC_free (operand_entry_t, heap, *ops);
-	  *ops = NULL;
-	  VEC_safe_push (operand_entry_t, heap, *ops, oe);
+	  reassociate_stats.ops_eliminated += ops->length () - 1;
+	  ops->truncate (0);
+	  ops->quick_push (oe);
 	  return true;
 	}
     }
@@ -813,9 +808,9 @@ eliminate_not_pairs (enum tree_code opcode,
 
 static void
 eliminate_using_constants (enum tree_code opcode,
-			   VEC(operand_entry_t, heap) **ops)
+			   vec<operand_entry_t> *ops)
 {
-  operand_entry_t oelast = VEC_last (operand_entry_t, *ops);
+  operand_entry_t oelast = ops->last ();
   tree type = TREE_TYPE (oelast->op);
 
   if (oelast->rank == 0
@@ -826,27 +821,25 @@ eliminate_using_constants (enum tree_code opcode,
 	case BIT_AND_EXPR:
 	  if (integer_zerop (oelast->op))
 	    {
-	      if (VEC_length (operand_entry_t, *ops) != 1)
+	      if (ops->length () != 1)
 		{
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    fprintf (dump_file, "Found & 0, removing all other ops\n");
 
-		  reassociate_stats.ops_eliminated
-		    += VEC_length (operand_entry_t, *ops) - 1;
+		  reassociate_stats.ops_eliminated += ops->length () - 1;
 
-		  VEC_free (operand_entry_t, heap, *ops);
-		  *ops = NULL;
-		  VEC_safe_push (operand_entry_t, heap, *ops, oelast);
+		  ops->truncate (0);
+		  ops->quick_push (oelast);
 		  return;
 		}
 	    }
 	  else if (integer_all_onesp (oelast->op))
 	    {
-	      if (VEC_length (operand_entry_t, *ops) != 1)
+	      if (ops->length () != 1)
 		{
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    fprintf (dump_file, "Found & -1, removing\n");
-		  VEC_pop (operand_entry_t, *ops);
+		  ops->pop ();
 		  reassociate_stats.ops_eliminated++;
 		}
 	    }
@@ -854,27 +847,25 @@ eliminate_using_constants (enum tree_code opcode,
 	case BIT_IOR_EXPR:
 	  if (integer_all_onesp (oelast->op))
 	    {
-	      if (VEC_length (operand_entry_t, *ops) != 1)
+	      if (ops->length () != 1)
 		{
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    fprintf (dump_file, "Found | -1, removing all other ops\n");
 
-		  reassociate_stats.ops_eliminated
-		    += VEC_length (operand_entry_t, *ops) - 1;
+		  reassociate_stats.ops_eliminated += ops->length () - 1;
 
-		  VEC_free (operand_entry_t, heap, *ops);
-		  *ops = NULL;
-		  VEC_safe_push (operand_entry_t, heap, *ops, oelast);
+		  ops->truncate (0);
+		  ops->quick_push (oelast);
 		  return;
 		}
 	    }
 	  else if (integer_zerop (oelast->op))
 	    {
-	      if (VEC_length (operand_entry_t, *ops) != 1)
+	      if (ops->length () != 1)
 		{
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    fprintf (dump_file, "Found | 0, removing\n");
-		  VEC_pop (operand_entry_t, *ops);
+		  ops->pop ();
 		  reassociate_stats.ops_eliminated++;
 		}
 	    }
@@ -886,16 +877,14 @@ eliminate_using_constants (enum tree_code opcode,
 		  && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
 		  && real_zerop (oelast->op)))
 	    {
-	      if (VEC_length (operand_entry_t, *ops) != 1)
+	      if (ops->length () != 1)
 		{
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    fprintf (dump_file, "Found * 0, removing all other ops\n");
 
-		  reassociate_stats.ops_eliminated
-		    += VEC_length (operand_entry_t, *ops) - 1;
-		  VEC_free (operand_entry_t, heap, *ops);
-		  *ops = NULL;
-		  VEC_safe_push (operand_entry_t, heap, *ops, oelast);
+		  reassociate_stats.ops_eliminated += ops->length () - 1;
+		  ops->truncate (1);
+		  ops->quick_push (oelast);
 		  return;
 		}
 	    }
@@ -904,11 +893,11 @@ eliminate_using_constants (enum tree_code opcode,
 		       && !HONOR_SNANS (TYPE_MODE (type))
 		       && real_onep (oelast->op)))
 	    {
-	      if (VEC_length (operand_entry_t, *ops) != 1)
+	      if (ops->length () != 1)
 		{
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    fprintf (dump_file, "Found * 1, removing\n");
-		  VEC_pop (operand_entry_t, *ops);
+		  ops->pop ();
 		  reassociate_stats.ops_eliminated++;
 		  return;
 		}
@@ -923,11 +912,11 @@ eliminate_using_constants (enum tree_code opcode,
 		  && fold_real_zero_addition_p (type, oelast->op,
 						opcode == MINUS_EXPR)))
 	    {
-	      if (VEC_length (operand_entry_t, *ops) != 1)
+	      if (ops->length () != 1)
 		{
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    fprintf (dump_file, "Found [|^+] 0, removing\n");
-		  VEC_pop (operand_entry_t, *ops);
+		  ops->pop ();
 		  reassociate_stats.ops_eliminated++;
 		  return;
 		}
@@ -940,7 +929,7 @@ eliminate_using_constants (enum tree_code opcode,
 }
 
 
-static void linearize_expr_tree (VEC(operand_entry_t, heap) **, gimple,
+static void linearize_expr_tree (vec<operand_entry_t> *, gimple,
 				 bool, bool);
 
 /* Structure for tracking and counting operands.  */
@@ -951,18 +940,16 @@ typedef struct oecount_s {
   tree op;
 } oecount;
 
-DEF_VEC_O(oecount);
-DEF_VEC_ALLOC_O(oecount,heap);
 
 /* The heap for the oecount hashtable and the sorted list of operands.  */
-static VEC (oecount, heap) *cvec;
+static vec<oecount> cvec;
 
 /* Hash function for oecount.  */
 
 static hashval_t
 oecount_hash (const void *p)
 {
-  const oecount *c = &VEC_index (oecount, cvec, (size_t)p - 42);
+  const oecount *c = &cvec[(size_t)p - 42];
   return htab_hash_pointer (c->op) ^ (hashval_t)c->oecode;
 }
 
@@ -971,8 +958,8 @@ oecount_hash (const void *p)
 static int
 oecount_eq (const void *p1, const void *p2)
 {
-  const oecount *c1 = &VEC_index (oecount, cvec, (size_t)p1 - 42);
-  const oecount *c2 = &VEC_index (oecount, cvec, (size_t)p2 - 42);
+  const oecount *c1 = &cvec[(size_t)p1 - 42];
+  const oecount *c2 = &cvec[(size_t)p2 - 42];
   return (c1->oecode == c2->oecode
 	  && c1->op == c2->op);
 }
@@ -1263,15 +1250,15 @@ build_and_add_sum (tree type, tree op1, tree op2, enum tree_code opcode)
 
 static bool
 undistribute_ops_list (enum tree_code opcode,
-		       VEC (operand_entry_t, heap) **ops, struct loop *loop)
+		       vec<operand_entry_t> *ops, struct loop *loop)
 {
-  unsigned int length = VEC_length (operand_entry_t, *ops);
+  unsigned int length = ops->length ();
   operand_entry_t oe1;
   unsigned i, j;
   sbitmap candidates, candidates2;
   unsigned nr_candidates, nr_candidates2;
   sbitmap_iterator sbi0;
-  VEC (operand_entry_t, heap) **subops;
+  vec<operand_entry_t> *subops;
   htab_t ctable;
   bool changed = false;
   int next_oecount_id = 0;
@@ -1284,7 +1271,7 @@ undistribute_ops_list (enum tree_code opcode,
   candidates = sbitmap_alloc (length);
   bitmap_clear (candidates);
   nr_candidates = 0;
-  FOR_EACH_VEC_ELT (operand_entry_t, *ops, i, oe1)
+  FOR_EACH_VEC_ELT (*ops, i, oe1)
     {
       enum tree_code dcode;
       gimple oe1def;
@@ -1314,28 +1301,29 @@ undistribute_ops_list (enum tree_code opcode,
     {
       fprintf (dump_file, "searching for un-distribute opportunities ");
       print_generic_expr (dump_file,
-	VEC_index (operand_entry_t, *ops,
-		   bitmap_first_set_bit (candidates))->op, 0);
+	(*ops)[bitmap_first_set_bit (candidates)]->op, 0);
       fprintf (dump_file, " %d\n", nr_candidates);
     }
 
   /* Build linearized sub-operand lists and the counting table.  */
-  cvec = NULL;
+  cvec.create (0);
   ctable = htab_create (15, oecount_hash, oecount_eq, NULL);
-  subops = XCNEWVEC (VEC (operand_entry_t, heap) *,
-		     VEC_length (operand_entry_t, *ops));
+  /* ??? Macro arguments cannot have multi-argument template types in
+     them.  This typedef is needed to workaround that limitation.  */
+  typedef vec<operand_entry_t> vec_operand_entry_t_heap;
+  subops = XCNEWVEC (vec_operand_entry_t_heap, ops->length ());
   EXECUTE_IF_SET_IN_BITMAP (candidates, 0, i, sbi0)
     {
       gimple oedef;
       enum tree_code oecode;
       unsigned j;
 
-      oedef = SSA_NAME_DEF_STMT (VEC_index (operand_entry_t, *ops, i)->op);
+      oedef = SSA_NAME_DEF_STMT ((*ops)[i]->op);
       oecode = gimple_assign_rhs_code (oedef);
       linearize_expr_tree (&subops[i], oedef,
 			   associative_tree_code (oecode), false);
 
-      FOR_EACH_VEC_ELT (operand_entry_t, subops[i], j, oe1)
+      FOR_EACH_VEC_ELT (subops[i], j, oe1)
 	{
 	  oecount c;
 	  void **slot;
@@ -1344,8 +1332,8 @@ undistribute_ops_list (enum tree_code opcode,
 	  c.cnt = 1;
 	  c.id = next_oecount_id++;
 	  c.op = oe1->op;
-	  VEC_safe_push (oecount, heap, cvec, c);
-	  idx = VEC_length (oecount, cvec) + 41;
+	  cvec.safe_push (c);
+	  idx = cvec.length () + 41;
 	  slot = htab_find_slot (ctable, (void *)idx, INSERT);
 	  if (!*slot)
 	    {
@@ -1353,21 +1341,21 @@ undistribute_ops_list (enum tree_code opcode,
 	    }
 	  else
 	    {
-	      VEC_pop (oecount, cvec);
-	      VEC_index (oecount, cvec, (size_t)*slot - 42).cnt++;
+	      cvec.pop ();
+	      cvec[(size_t)*slot - 42].cnt++;
 	    }
 	}
     }
   htab_delete (ctable);
 
   /* Sort the counting table.  */
-  VEC_qsort (oecount, cvec, oecount_cmp);
+  cvec.qsort (oecount_cmp);
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
       oecount *c;
       fprintf (dump_file, "Candidates:\n");
-      FOR_EACH_VEC_ELT (oecount, cvec, j, c)
+      FOR_EACH_VEC_ELT (cvec, j, c)
 	{
 	  fprintf (dump_file, "  %u %s: ", c->cnt,
 		   c->oecode == MULT_EXPR
@@ -1379,9 +1367,9 @@ undistribute_ops_list (enum tree_code opcode,
 
   /* Process the (operand, code) pairs in order of most occurence.  */
   candidates2 = sbitmap_alloc (length);
-  while (!VEC_empty (oecount, cvec))
+  while (!cvec.is_empty ())
     {
-      oecount *c = &VEC_last (oecount, cvec);
+      oecount *c = &cvec.last ();
       if (c->cnt < 2)
 	break;
 
@@ -1394,7 +1382,7 @@ undistribute_ops_list (enum tree_code opcode,
 	  gimple oedef;
 	  enum tree_code oecode;
 	  unsigned j;
-	  tree op = VEC_index (operand_entry_t, *ops, i)->op;
+	  tree op = (*ops)[i]->op;
 
 	  /* If we undistributed in this chain already this may be
 	     a constant.  */
@@ -1406,7 +1394,7 @@ undistribute_ops_list (enum tree_code opcode,
 	  if (oecode != c->oecode)
 	    continue;
 
-	  FOR_EACH_VEC_ELT (operand_entry_t, subops[i], j, oe1)
+	  FOR_EACH_VEC_ELT (subops[i], j, oe1)
 	    {
 	      if (oe1->op == c->op)
 		{
@@ -1424,7 +1412,7 @@ undistribute_ops_list (enum tree_code opcode,
 	  int first = bitmap_first_set_bit (candidates2);
 
 	  /* Build the new addition chain.  */
-	  oe1 = VEC_index (operand_entry_t, *ops, first);
+	  oe1 = (*ops)[first];
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    {
 	      fprintf (dump_file, "Building (");
@@ -1434,7 +1422,7 @@ undistribute_ops_list (enum tree_code opcode,
 	  EXECUTE_IF_SET_IN_BITMAP (candidates2, first+1, i, sbi0)
 	    {
 	      gimple sum;
-	      oe2 = VEC_index (operand_entry_t, *ops, i);
+	      oe2 = (*ops)[i];
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		{
 		  fprintf (dump_file, " + ");
@@ -1462,18 +1450,18 @@ undistribute_ops_list (enum tree_code opcode,
 	     undistribution with this op.  */
 	  oe1->op = gimple_assign_lhs (prod);
 	  oe1->rank = get_rank (oe1->op);
-	  VEC_free (operand_entry_t, heap, subops[first]);
+	  subops[first].release ();
 
 	  changed = true;
 	}
 
-      VEC_pop (oecount, cvec);
+      cvec.pop ();
     }
 
-  for (i = 0; i < VEC_length (operand_entry_t, *ops); ++i)
-    VEC_free (operand_entry_t, heap, subops[i]);
+  for (i = 0; i < ops->length (); ++i)
+    subops[i].release ();
   free (subops);
-  VEC_free (oecount, heap, cvec);
+  cvec.release ();
   sbitmap_free (candidates);
   sbitmap_free (candidates2);
 
@@ -1487,7 +1475,7 @@ undistribute_ops_list (enum tree_code opcode,
 
 static bool
 eliminate_redundant_comparison (enum tree_code opcode,
-				VEC (operand_entry_t, heap) **ops,
+				vec<operand_entry_t> *ops,
 				unsigned int currindex,
 				operand_entry_t curr)
 {
@@ -1513,9 +1501,7 @@ eliminate_redundant_comparison (enum tree_code opcode,
   op2 = gimple_assign_rhs2 (def1);
 
   /* Now look for a similar comparison in the remaining OPS.  */
-  for (i = currindex + 1;
-       VEC_iterate (operand_entry_t, *ops, i, oe);
-       i++)
+  for (i = currindex + 1; ops->iterate (i, &oe); i++)
     {
       tree t;
 
@@ -1575,7 +1561,7 @@ eliminate_redundant_comparison (enum tree_code opcode,
 
       /* Now we can delete oe, as it has been subsumed by the new combined
          expression t.  */
-      VEC_ordered_remove (operand_entry_t, *ops, i);
+      ops->ordered_remove (i);
       reassociate_stats.ops_eliminated ++;
 
       /* If t is the same as curr->op, we're done.  Otherwise we must
@@ -1584,7 +1570,7 @@ eliminate_redundant_comparison (enum tree_code opcode,
 	 the current entry.  */
       if (TREE_CODE (t) == INTEGER_CST)
 	{
-	  VEC_ordered_remove (operand_entry_t, *ops, currindex);
+	  ops->ordered_remove (currindex);
 	  add_to_ops_vec (ops, t);
 	}
       else if (!operand_equal_p (t, curr->op, 0))
@@ -1614,9 +1600,9 @@ eliminate_redundant_comparison (enum tree_code opcode,
 
 static void
 optimize_ops_list (enum tree_code opcode,
-		   VEC (operand_entry_t, heap) **ops)
+		   vec<operand_entry_t> *ops)
 {
-  unsigned int length = VEC_length (operand_entry_t, *ops);
+  unsigned int length = ops->length ();
   unsigned int i;
   operand_entry_t oe;
   operand_entry_t oelast = NULL;
@@ -1625,13 +1611,13 @@ optimize_ops_list (enum tree_code opcode,
   if (length == 1)
     return;
 
-  oelast = VEC_last (operand_entry_t, *ops);
+  oelast = ops->last ();
 
   /* If the last two are constants, pop the constants off, merge them
      and try the next two.  */
   if (oelast->rank == 0 && is_gimple_min_invariant (oelast->op))
     {
-      operand_entry_t oelm1 = VEC_index (operand_entry_t, *ops, length - 2);
+      operand_entry_t oelm1 = (*ops)[length - 2];
 
       if (oelm1->rank == 0
 	  && is_gimple_min_invariant (oelm1->op)
@@ -1646,8 +1632,8 @@ optimize_ops_list (enum tree_code opcode,
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		fprintf (dump_file, "Merging constants\n");
 
-	      VEC_pop (operand_entry_t, *ops);
-	      VEC_pop (operand_entry_t, *ops);
+	      ops->pop ();
+	      ops->pop ();
 
 	      add_to_ops_vec (ops, folded);
 	      reassociate_stats.constants_eliminated++;
@@ -1661,7 +1647,7 @@ optimize_ops_list (enum tree_code opcode,
   eliminate_using_constants (opcode, ops);
   oelast = NULL;
 
-  for (i = 0; VEC_iterate (operand_entry_t, *ops, i, oe);)
+  for (i = 0; ops->iterate (i, &oe);)
     {
       bool done = false;
 
@@ -1681,8 +1667,8 @@ optimize_ops_list (enum tree_code opcode,
       i++;
     }
 
-  length  = VEC_length (operand_entry_t, *ops);
-  oelast = VEC_last (operand_entry_t, *ops);
+  length = ops->length ();
+  oelast = ops->last ();
 
   if (iterate)
     optimize_ops_list (opcode, ops);
@@ -1940,10 +1926,10 @@ range_entry_cmp (const void *a, const void *b)
 static bool
 update_range_test (struct range_entry *range, struct range_entry *otherrange,
 		   unsigned int count, enum tree_code opcode,
-		   VEC (operand_entry_t, heap) **ops, tree exp, bool in_p,
+		   vec<operand_entry_t> *ops, tree exp, bool in_p,
 		   tree low, tree high, bool strict_overflow_p)
 {
-  operand_entry_t oe = VEC_index (oeprand_entry_t, *ops, range->idx);
+  operand_entry_t oe = (*ops)[range->idx];
   tree op = oe->op;
   gimple stmt = op ? SSA_NAME_DEF_STMT (op) : last_stmt (BASIC_BLOCK (oe->id));
   location_t loc = gimple_location (stmt);
@@ -2030,7 +2016,7 @@ update_range_test (struct range_entry *range, struct range_entry *otherrange,
 
   for (range = otherrange; range < otherrange + count; range++)
     {
-      oe = VEC_index (oeprand_entry_t, *ops, range->idx);
+      oe = (*ops)[range->idx];
       /* Now change all the other range test immediate uses, so that
 	 those tests will be optimized away.  */
       if (opcode == ERROR_MARK)
@@ -2124,9 +2110,9 @@ update_range_test (struct range_entry *range, struct range_entry *otherrange,
 
 static void
 optimize_range_tests (enum tree_code opcode,
-		      VEC (operand_entry_t, heap) **ops)
+		      vec<operand_entry_t> *ops)
 {
-  unsigned int length = VEC_length (operand_entry_t, *ops), i, j, first;
+  unsigned int length = ops->length (), i, j, first;
   operand_entry_t oe;
   struct range_entry *ranges;
   bool any_changes = false;
@@ -2137,7 +2123,7 @@ optimize_range_tests (enum tree_code opcode,
   ranges = XNEWVEC (struct range_entry, length);
   for (i = 0; i < length; i++)
     {
-      oe = VEC_index (operand_entry_t, *ops, i);
+      oe = (*ops)[i];
       ranges[i].idx = i;
       init_range_entry (ranges + i, oe->op,
 			oe->op ? NULL : last_stmt (BASIC_BLOCK (oe->id)));
@@ -2264,15 +2250,15 @@ optimize_range_tests (enum tree_code opcode,
   if (any_changes && opcode != ERROR_MARK)
     {
       j = 0;
-      FOR_EACH_VEC_ELT (operand_entry_t, *ops, i, oe)
+      FOR_EACH_VEC_ELT (*ops, i, oe)
 	{
 	  if (oe->op == error_mark_node)
 	    continue;
 	  else if (i != j)
-	    VEC_replace (operand_entry_t, *ops, j, oe);
+	    (*ops)[j] = oe;
 	  j++;
 	}
-      VEC_truncate (operand_entry_t, *ops, j);
+      ops->truncate (j);
     }
 
   XDELETEVEC (ranges);
@@ -2493,7 +2479,7 @@ no_side_effect_bb (basic_block bb)
    return true and fill in *OPS recursively.  */
 
 static bool
-get_ops (tree var, enum tree_code code, VEC(operand_entry_t, heap) **ops,
+get_ops (tree var, enum tree_code code, vec<operand_entry_t> *ops,
 	 struct loop *loop)
 {
   gimple stmt = SSA_NAME_DEF_STMT (var);
@@ -2517,7 +2503,7 @@ get_ops (tree var, enum tree_code code, VEC(operand_entry_t, heap) **ops,
 	oe->rank = code;
 	oe->id = 0;
 	oe->count = 1;
-	VEC_safe_push (operand_entry_t, heap, *ops, oe);
+	ops->safe_push (oe);
       }
   return true;
 }
@@ -2533,7 +2519,7 @@ maybe_optimize_range_tests (gimple stmt)
   basic_block bb;
   edge_iterator ei;
   edge e;
-  VEC(operand_entry_t, heap) *ops = NULL;
+  vec<operand_entry_t> ops = vec<operand_entry_t>();
 
   /* Consider only basic blocks that end with GIMPLE_COND or
      a cast statement satisfying final_range_test_p.  All
@@ -2691,7 +2677,7 @@ maybe_optimize_range_tests (gimple stmt)
 	      oe->rank = code;
 	      oe->id = 0;
 	      oe->count = 1;
-	      VEC_safe_push (operand_entry_t, heap, ops, oe);
+	      ops.safe_push (oe);
 	    }
 	  continue;
 	}
@@ -2724,14 +2710,14 @@ maybe_optimize_range_tests (gimple stmt)
 	     is.  */
 	  oe->id = bb->index;
 	  oe->count = 1;
-	  VEC_safe_push (operand_entry_t, heap, ops, oe);
+	  ops.safe_push (oe);
 	}
       if (bb == first_bb)
 	break;
     }
-  if (VEC_length (operand_entry_t, ops) > 1)
+  if (ops.length () > 1)
     optimize_range_tests (ERROR_MARK, &ops);
-  VEC_free (operand_entry_t, heap, ops);
+  ops.release ();
 }
 
 /* Return true if OPERAND is defined by a PHI node which uses the LHS
@@ -2808,14 +2794,14 @@ remove_visited_stmt_chain (tree var)
    cases, but it is unlikely to be worth it.  */
 
 static void
-swap_ops_for_binary_stmt (VEC(operand_entry_t, heap) * ops,
+swap_ops_for_binary_stmt (vec<operand_entry_t> ops,
 			  unsigned int opindex, gimple stmt)
 {
   operand_entry_t oe1, oe2, oe3;
 
-  oe1 = VEC_index (operand_entry_t, ops, opindex);
-  oe2 = VEC_index (operand_entry_t, ops, opindex + 1);
-  oe3 = VEC_index (operand_entry_t, ops, opindex + 2);
+  oe1 = ops[opindex];
+  oe2 = ops[opindex + 1];
+  oe3 = ops[opindex + 2];
 
   if ((oe1->rank == oe2->rank
        && oe2->rank != oe3->rank)
@@ -2849,7 +2835,7 @@ swap_ops_for_binary_stmt (VEC(operand_entry_t, heap) * ops,
 
 static void
 rewrite_expr_tree (gimple stmt, unsigned int opindex,
-		   VEC(operand_entry_t, heap) * ops, bool moved)
+		   vec<operand_entry_t> ops, bool moved)
 {
   tree rhs1 = gimple_assign_rhs1 (stmt);
   tree rhs2 = gimple_assign_rhs2 (stmt);
@@ -2857,7 +2843,7 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
 
   /* If we have three operands left, then we want to make sure the ones
      that get the double binary op are chosen wisely.  */
-  if (opindex + 3 == VEC_length (operand_entry_t, ops))
+  if (opindex + 3 == ops.length ())
     swap_ops_for_binary_stmt (ops, opindex, stmt);
 
   /* The final recursion case for this function is that you have
@@ -2865,12 +2851,12 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
      If we had one exactly one op in the entire list to start with, we
      would have never called this function, and the tail recursion
      rewrites them one at a time.  */
-  if (opindex + 2 == VEC_length (operand_entry_t, ops))
+  if (opindex + 2 == ops.length ())
     {
       operand_entry_t oe1, oe2;
 
-      oe1 = VEC_index (operand_entry_t, ops, opindex);
-      oe2 = VEC_index (operand_entry_t, ops, opindex + 1);
+      oe1 = ops[opindex];
+      oe2 = ops[opindex + 1];
 
       if (rhs1 != oe1->op || rhs2 != oe2->op)
 	{
@@ -2896,10 +2882,10 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
     }
 
   /* If we hit here, we should have 3 or more ops left.  */
-  gcc_assert (opindex + 2 < VEC_length (operand_entry_t, ops));
+  gcc_assert (opindex + 2 < ops.length ());
 
   /* Rewrite the next operator.  */
-  oe = VEC_index (operand_entry_t, ops, opindex);
+  oe = ops[opindex];
 
   if (oe->op != rhs2)
     {
@@ -2910,7 +2896,7 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
 	  unsigned int count;
 
 	  gsinow = gsi_for_stmt (stmt);
-	  count = VEC_length (operand_entry_t, ops) - opindex - 2;
+	  count = ops.length () - opindex - 2;
 	  while (count-- != 0)
 	    {
 	      stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt1));
@@ -3021,10 +3007,10 @@ get_reassociation_width (int ops_num, enum tree_code opc,
 
 static void
 rewrite_expr_tree_parallel (gimple stmt, int width,
-			    VEC(operand_entry_t, heap) * ops)
+			    vec<operand_entry_t>  ops)
 {
   enum tree_code opcode = gimple_assign_rhs_code (stmt);
-  int op_num = VEC_length (operand_entry_t, ops);
+  int op_num = ops.length ();
   int stmt_num = op_num - 1;
   gimple *stmts = XALLOCAVEC (gimple, stmt_num);
   int op_index = op_num - 1;
@@ -3059,7 +3045,7 @@ rewrite_expr_tree_parallel (gimple stmt, int width,
 	  if (ready_stmts_end > stmt_index)
 	    op2 = gimple_assign_lhs (stmts[stmt_index++]);
 	  else if (op_index >= 0)
-	    op2 = VEC_index (operand_entry_t, ops, op_index--)->op;
+	    op2 = ops[op_index--]->op;
 	  else
 	    {
 	      gcc_assert (stmt_index < i);
@@ -3073,8 +3059,8 @@ rewrite_expr_tree_parallel (gimple stmt, int width,
 	{
 	  if (op_index > 1)
 	    swap_ops_for_binary_stmt (ops, op_index - 2, NULL);
-	  op2 = VEC_index (operand_entry_t, ops, op_index--)->op;
-	  op1 = VEC_index (operand_entry_t, ops, op_index--)->op;
+	  op2 = ops[op_index--]->op;
+	  op1 = ops[op_index--]->op;
 	}
 
       /* If we emit the last statement then we should put
@@ -3346,7 +3332,7 @@ acceptable_pow_call (gimple stmt, tree *base, HOST_WIDE_INT *exponent)
    Place the operands of the expression tree in the vector named OPS.  */
 
 static void
-linearize_expr_tree (VEC(operand_entry_t, heap) **ops, gimple stmt,
+linearize_expr_tree (vec<operand_entry_t> *ops, gimple stmt,
 		     bool is_associative, bool set_visited)
 {
   tree binlhs = gimple_assign_rhs1 (stmt);
@@ -3474,7 +3460,7 @@ repropagate_negates (void)
   unsigned int i = 0;
   tree negate;
 
-  FOR_EACH_VEC_ELT (tree, plus_negates, i, negate)
+  FOR_EACH_VEC_ELT (plus_negates, i, negate)
     {
       gimple user = get_single_immediate_use (negate);
 
@@ -3533,8 +3519,7 @@ repropagate_negates (void)
 	      gimple_assign_set_rhs_with_ops (&gsi2, NEGATE_EXPR, negate, NULL);
 	      update_stmt (gsi_stmt (gsi2));
 	      gsi_move_before (&gsi, &gsi2);
-	      VEC_safe_push (tree, heap, plus_negates,
-			     gimple_assign_lhs (gsi_stmt (gsi2)));
+	      plus_negates.safe_push (gimple_assign_lhs (gsi_stmt (gsi2)));
 	    }
 	  else
 	    {
@@ -3614,7 +3599,7 @@ break_up_subtract_bb (basic_block bb)
 	}
       else if (gimple_assign_rhs_code (stmt) == NEGATE_EXPR
 	       && can_reassociate_p (gimple_assign_rhs1 (stmt)))
-	VEC_safe_push (tree, heap, plus_negates, gimple_assign_lhs (stmt));
+	plus_negates.safe_push (gimple_assign_lhs (stmt));
     }
   for (son = first_dom_son (CDI_DOMINATORS, bb);
        son;
@@ -3642,10 +3627,8 @@ struct repeat_factor_d
 typedef struct repeat_factor_d repeat_factor, *repeat_factor_t;
 typedef const struct repeat_factor_d *const_repeat_factor_t;
 
-DEF_VEC_O (repeat_factor);
-DEF_VEC_ALLOC_O (repeat_factor, heap);
 
-static VEC (repeat_factor, heap) *repeat_factor_vec;
+static vec<repeat_factor> repeat_factor_vec;
 
 /* Used for sorting the repeat factor vector.  Sort primarily by
    ascending occurrence count, secondarily by descending rank.  */
@@ -3668,7 +3651,7 @@ compare_repeat_factors (const void *x1, const void *x2)
    SSA name representing the value of the replacement sequence.  */
 
 static tree
-attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
+attempt_builtin_powi (gimple stmt, vec<operand_entry_t> *ops)
 {
   unsigned i, j, vec_len;
   int ii;
@@ -3688,15 +3671,15 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
     return NULL_TREE;
 
   /* Allocate the repeated factor vector.  */
-  repeat_factor_vec = VEC_alloc (repeat_factor, heap, 10);
+  repeat_factor_vec.create (10);
 
   /* Scan the OPS vector for all SSA names in the product and build
      up a vector of occurrence counts for each factor.  */
-  FOR_EACH_VEC_ELT (operand_entry_t, *ops, i, oe)
+  FOR_EACH_VEC_ELT (*ops, i, oe)
     {
       if (TREE_CODE (oe->op) == SSA_NAME)
 	{
-	  FOR_EACH_VEC_ELT (repeat_factor, repeat_factor_vec, j, rf1)
+	  FOR_EACH_VEC_ELT (repeat_factor_vec, j, rf1)
 	    {
 	      if (rf1->factor == oe->op)
 		{
@@ -3705,20 +3688,20 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 		}
 	    }
 
-	  if (j >= VEC_length (repeat_factor, repeat_factor_vec))
+	  if (j >= repeat_factor_vec.length ())
 	    {
 	      rfnew.factor = oe->op;
 	      rfnew.rank = oe->rank;
 	      rfnew.count = oe->count;
 	      rfnew.repr = NULL_TREE;
-	      VEC_safe_push (repeat_factor, heap, repeat_factor_vec, rfnew);
+	      repeat_factor_vec.safe_push (rfnew);
 	    }
 	}
     }
 
   /* Sort the repeated factor vector by (a) increasing occurrence count,
      and (b) decreasing rank.  */
-  VEC_qsort (repeat_factor, repeat_factor_vec, compare_repeat_factors);
+  repeat_factor_vec.qsort (compare_repeat_factors);
 
   /* It is generally best to combine as many base factors as possible
      into a product before applying __builtin_powi to the result.
@@ -3750,7 +3733,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 	t5 = t3 * t4
         result = t5 * y  */
 
-  vec_len = VEC_length (repeat_factor, repeat_factor_vec);
+  vec_len = repeat_factor_vec.length ();
   
   /* Repeatedly look for opportunities to create a builtin_powi call.  */
   while (true)
@@ -3762,7 +3745,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 	 it if the minimum occurrence count for its factors is at
 	 least 2, or just use this cached product as our next 
 	 multiplicand if the minimum occurrence count is 1.  */
-      FOR_EACH_VEC_ELT (repeat_factor, repeat_factor_vec, j, rf1)
+      FOR_EACH_VEC_ELT (repeat_factor_vec, j, rf1)
 	{
 	  if (rf1->repr && rf1->count > 0)
 	    break;
@@ -3783,7 +3766,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 		  fputs ("Multiplying by cached product ", dump_file);
 		  for (elt = j; elt < vec_len; elt++)
 		    {
-		      rf = &VEC_index (repeat_factor, repeat_factor_vec, elt);
+		      rf = &repeat_factor_vec[elt];
 		      print_generic_expr (dump_file, rf->factor, 0);
 		      if (elt < vec_len - 1)
 			fputs (" * ", dump_file);
@@ -3809,7 +3792,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 			 dump_file);
 		  for (elt = j; elt < vec_len; elt++)
 		    {
-		      rf = &VEC_index (repeat_factor, repeat_factor_vec, elt);
+		      rf = &repeat_factor_vec[elt];
 		      print_generic_expr (dump_file, rf->factor, 0);
 		      if (elt < vec_len - 1)
 			fputs (" * ", dump_file);
@@ -3825,7 +3808,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 	     vector whose occurrence count is at least 2.  If no such
 	     factor exists, there are no builtin_powi opportunities
 	     remaining.  */
-	  FOR_EACH_VEC_ELT (repeat_factor, repeat_factor_vec, j, rf1)
+	  FOR_EACH_VEC_ELT (repeat_factor_vec, j, rf1)
 	    {
 	      if (rf1->count >= 2)
 		break;
@@ -3843,7 +3826,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 	      fputs ("Building __builtin_pow call for (", dump_file);
 	      for (elt = j; elt < vec_len; elt++)
 		{
-		  rf = &VEC_index (repeat_factor, repeat_factor_vec, elt);
+		  rf = &repeat_factor_vec[elt];
 		  print_generic_expr (dump_file, rf->factor, 0);
 		  if (elt < vec_len - 1)
 		    fputs (" * ", dump_file);
@@ -3868,8 +3851,8 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 		{
 		  tree op1, op2;
 
-		  rf1 = &VEC_index (repeat_factor, repeat_factor_vec, ii);
-		  rf2 = &VEC_index (repeat_factor, repeat_factor_vec, ii + 1);
+		  rf1 = &repeat_factor_vec[ii];
+		  rf2 = &repeat_factor_vec[ii + 1];
 
 		  /* Init the last factor's representative to be itself.  */
 		  if (!rf2->repr)
@@ -3893,7 +3876,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 
 	  /* Form a call to __builtin_powi for the maximum product
 	     just formed, raised to the power obtained earlier.  */
-	  rf1 = &VEC_index (repeat_factor, repeat_factor_vec, j);
+	  rf1 = &repeat_factor_vec[j];
 	  iter_result = make_temp_ssa_name (type, NULL, "reassocpow");
 	  pow_stmt = gimple_build_call (powi_fndecl, 2, rf1->repr, 
 					build_int_cst (integer_type_node,
@@ -3926,16 +3909,16 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
 	  unsigned k = power;
 	  unsigned n;
 
-	  rf1 = &VEC_index (repeat_factor, repeat_factor_vec, i);
+	  rf1 = &repeat_factor_vec[i];
 	  rf1->count -= power;
 	  
-	  FOR_EACH_VEC_ELT_REVERSE (operand_entry_t, *ops, n, oe)
+	  FOR_EACH_VEC_ELT_REVERSE (*ops, n, oe)
 	    {
 	      if (oe->op == rf1->factor)
 		{
 		  if (oe->count <= k)
 		    {
-		      VEC_ordered_remove (operand_entry_t, *ops, n);
+		      ops->ordered_remove (n);
 		      k -= oe->count;
 
 		      if (k == 0)
@@ -3955,8 +3938,8 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops)
      remaining occurrence count of 0 or 1, and those with a count of 1
      don't have cached representatives.  Re-sort the ops vector and
      clean up.  */
-  VEC_qsort (operand_entry_t, *ops, sort_by_operand_rank);
-  VEC_free (repeat_factor, heap, repeat_factor_vec);
+  ops->qsort (sort_by_operand_rank);
+  repeat_factor_vec.release ();
 
   /* Return the final product computed herein.  Note that there may
      still be some elements with single occurrence count left in OPS;
@@ -4084,7 +4067,7 @@ reassociate_bb (basic_block bb)
 
 	  if (associative_tree_code (rhs_code))
 	    {
-	      VEC(operand_entry_t, heap) *ops = NULL;
+	      vec<operand_entry_t> ops = vec<operand_entry_t>();
 	      tree powi_result = NULL_TREE;
 
 	      /* There may be no immediate uses left by the time we
@@ -4094,12 +4077,12 @@ reassociate_bb (basic_block bb)
 
 	      gimple_set_visited (stmt, true);
 	      linearize_expr_tree (&ops, stmt, true, true);
-	      VEC_qsort (operand_entry_t, ops, sort_by_operand_rank);
+	      ops.qsort (sort_by_operand_rank);
 	      optimize_ops_list (rhs_code, &ops);
 	      if (undistribute_ops_list (rhs_code, &ops,
 					 loop_containing_stmt (stmt)))
 		{
-		  VEC_qsort (operand_entry_t, ops, sort_by_operand_rank);
+		  ops.qsort (sort_by_operand_rank);
 		  optimize_ops_list (rhs_code, &ops);
 		}
 
@@ -4113,11 +4096,11 @@ reassociate_bb (basic_block bb)
 
 	      /* If the operand vector is now empty, all operands were 
 		 consumed by the __builtin_powi optimization.  */
-	      if (VEC_length (operand_entry_t, ops) == 0)
+	      if (ops.length () == 0)
 		transform_stmt_to_copy (&gsi, stmt, powi_result);
-	      else if (VEC_length (operand_entry_t, ops) == 1)
+	      else if (ops.length () == 1)
 		{
-		  tree last_op = VEC_last (operand_entry_t, ops)->op;
+		  tree last_op = ops.last ()->op;
 		  
 		  if (powi_result)
 		    transform_stmt_to_multiply (&gsi, stmt, last_op,
@@ -4128,7 +4111,7 @@ reassociate_bb (basic_block bb)
 	      else
 		{
 		  enum machine_mode mode = TYPE_MODE (TREE_TYPE (lhs));
-		  int ops_num = VEC_length (operand_entry_t, ops);
+		  int ops_num = ops.length ();
 		  int width = get_reassociation_width (ops_num, rhs_code, mode);
 
 		  if (dump_file && (dump_flags & TDF_DETAILS))
@@ -4136,7 +4119,7 @@ reassociate_bb (basic_block bb)
 			     "Width = %d was chosen for reassociation\n", width);
 
 		  if (width > 1
-		      && VEC_length (operand_entry_t, ops) > 3)
+		      && ops.length () > 3)
 		    rewrite_expr_tree_parallel (stmt, width, ops);
 		  else
 		    rewrite_expr_tree (stmt, 0, ops, false);
@@ -4160,7 +4143,7 @@ reassociate_bb (basic_block bb)
 		    }
 		}
 
-	      VEC_free (operand_entry_t, heap, ops);
+	      ops.release ();
 	    }
 	}
     }
@@ -4170,18 +4153,18 @@ reassociate_bb (basic_block bb)
     reassociate_bb (son);
 }
 
-void dump_ops_vector (FILE *file, VEC (operand_entry_t, heap) *ops);
-void debug_ops_vector (VEC (operand_entry_t, heap) *ops);
+void dump_ops_vector (FILE *file, vec<operand_entry_t> ops);
+void debug_ops_vector (vec<operand_entry_t> ops);
 
 /* Dump the operand entry vector OPS to FILE.  */
 
 void
-dump_ops_vector (FILE *file, VEC (operand_entry_t, heap) *ops)
+dump_ops_vector (FILE *file, vec<operand_entry_t> ops)
 {
   operand_entry_t oe;
   unsigned int i;
 
-  FOR_EACH_VEC_ELT (operand_entry_t, ops, i, oe)
+  FOR_EACH_VEC_ELT (ops, i, oe)
     {
       fprintf (file, "Op %d -> rank: %d, tree: ", i, oe->rank);
       print_generic_expr (file, oe->op, 0);
@@ -4191,7 +4174,7 @@ dump_ops_vector (FILE *file, VEC (operand_entry_t, heap) *ops)
 /* Dump the operand entry vector OPS to STDERR.  */
 
 DEBUG_FUNCTION void
-debug_ops_vector (VEC (operand_entry_t, heap) *ops)
+debug_ops_vector (vec<operand_entry_t> ops)
 {
   dump_ops_vector (stderr, ops);
 }
@@ -4245,7 +4228,7 @@ init_reassoc (void)
 
   free (bbs);
   calculate_dominance_info (CDI_POST_DOMINATORS);
-  plus_negates = NULL;
+  plus_negates = vec<tree>();
 }
 
 /* Cleanup after the reassociation pass, and print stats if
@@ -4270,7 +4253,7 @@ fini_reassoc (void)
   pointer_map_destroy (operand_rank);
   free_alloc_pool (operand_entry_pool);
   free (bb_rank);
-  VEC_free (tree, heap, plus_negates);
+  plus_negates.release ();
   free_dominance_info (CDI_POST_DOMINATORS);
   loop_optimizer_finalize ();
 }