This patch rewrites the old VEC macro-based interface into a new one

based on the template class 'vec'.  The user-visible changes are
described in http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec.

I have tested the patch pretty extensively:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1 files changed, 66 insertions, 74 deletions

diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index c5789663f8a..2a389895d3d 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -39,7 +39,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "cfgloop.h"
 #include "domwalk.h"
 #include "params.h"
-#include "vecprim.h"
 #include "diagnostic-core.h"
 
 
@@ -84,7 +83,7 @@ typedef struct def_blocks_d *def_blocks_p;
 
    - A NULL node at the top entry is used to mark the last slot
      associated with the current block.  */
-static VEC(tree,heap) *block_defs_stack;
+static vec<tree> block_defs_stack;
 
 
 /* Set of existing SSA names being replaced by update_ssa.  */
@@ -102,10 +101,10 @@ sbitmap interesting_blocks;
    released after we finish updating the SSA web.  */
 static bitmap names_to_release;
 
-/* VEC of VECs of PHIs to rewrite in a basic block.  Element I corresponds
+/* vec of vec of PHIs to rewrite in a basic block.  Element I corresponds
    the to basic block with index I.  Allocated once per compilation, *not*
    released between different functions.  */
-static VEC(gimple_vec, heap) *phis_to_rewrite;
+static vec<gimple_vec> phis_to_rewrite;
 
 /* The bitmap of non-NULL elements of PHIS_TO_REWRITE.  */
 static bitmap blocks_with_phis_to_rewrite;
@@ -161,8 +160,6 @@ struct var_info_d
 /* The information associated with decls.  */
 typedef struct var_info_d *var_info_p;
 
-DEF_VEC_P(var_info_p);
-DEF_VEC_ALLOC_P(var_info_p,heap);
 
 /* Each entry in VAR_INFOS contains an element of type STRUCT 
    VAR_INFO_D.  */
@@ -186,10 +183,8 @@ struct ssa_name_info
 
 /* The information associated with names.  */
 typedef struct ssa_name_info *ssa_name_info_p;
-DEF_VEC_P (ssa_name_info_p);
-DEF_VEC_ALLOC_P (ssa_name_info_p, heap);
 
-static VEC(ssa_name_info_p, heap) *info_for_ssa_name;
+static vec<ssa_name_info_p> info_for_ssa_name;
 static unsigned current_info_for_ssa_name_age;
 
 static bitmap_obstack update_ssa_obstack;
@@ -235,7 +230,7 @@ extern void debug_currdefs (void);
 
 /* The set of symbols we ought to re-write into SSA form in update_ssa.  */
 static bitmap symbols_to_rename_set;
-static VEC(tree,heap) *symbols_to_rename;
+static vec<tree> symbols_to_rename;
 
 /* Mark SYM for renaming.  */
 
@@ -245,7 +240,7 @@ mark_for_renaming (tree sym)
   if (!symbols_to_rename_set)
     symbols_to_rename_set = BITMAP_ALLOC (NULL);
   if (bitmap_set_bit (symbols_to_rename_set, DECL_UID (sym)))
-    VEC_safe_push (tree, heap, symbols_to_rename, sym);
+    symbols_to_rename.safe_push (sym);
 }
 
 /* Return true if SYM is marked for renaming.  */
@@ -309,22 +304,21 @@ static inline ssa_name_info_p
 get_ssa_name_ann (tree name)
 {
   unsigned ver = SSA_NAME_VERSION (name);
-  unsigned len = VEC_length (ssa_name_info_p, info_for_ssa_name);
+  unsigned len = info_for_ssa_name.length ();
   struct ssa_name_info *info;
 
   /* Re-allocate the vector at most once per update/into-SSA.  */
   if (ver >= len)
-    VEC_safe_grow_cleared (ssa_name_info_p, heap,
-			   info_for_ssa_name, num_ssa_names);
+    info_for_ssa_name.safe_grow_cleared (num_ssa_names);
 
   /* But allocate infos lazily.  */
-  info = VEC_index (ssa_name_info_p, info_for_ssa_name, ver);
+  info = info_for_ssa_name[ver];
   if (!info)
     {
       info = XCNEW (struct ssa_name_info);
       info->age = current_info_for_ssa_name_age;
       info->info.need_phi_state = NEED_PHI_STATE_UNKNOWN;
-      VEC_replace (ssa_name_info_p, info_for_ssa_name, ver, info);
+      info_for_ssa_name[ver] = info;
     }
 
   if (info->age < current_info_for_ssa_name_age)
@@ -734,7 +728,7 @@ find_dfsnum_interval (struct dom_dfsnum *defs, unsigned n, unsigned s)
 static void
 prune_unused_phi_nodes (bitmap phis, bitmap kills, bitmap uses)
 {
-  VEC(int, heap) *worklist;
+  vec<int> worklist;
   bitmap_iterator bi;
   unsigned i, b, p, u, top;
   bitmap live_phis;
@@ -806,8 +800,8 @@ prune_unused_phi_nodes (bitmap phis, bitmap kills, bitmap uses)
      dfs_out numbers, increase the dfs number by one (so that it corresponds
      to the start of the following interval, not to the end of the current
      one).  We use WORKLIST as a stack.  */
-  worklist = VEC_alloc (int, heap, n_defs + 1);
-  VEC_quick_push (int, worklist, 1);
+  worklist.create (n_defs + 1);
+  worklist.quick_push (1);
   top = 1;
   n_defs = 1;
   for (i = 1; i < adef; i++)
@@ -817,8 +811,8 @@ prune_unused_phi_nodes (bitmap phis, bitmap kills, bitmap uses)
 	{
 	  /* This is a closing element.  Interval corresponding to the top
 	     of the stack after removing it follows.  */
-	  VEC_pop (int, worklist);
-	  top = VEC_index (int, worklist, VEC_length (int, worklist) - 1);
+	  worklist.pop ();
+	  top = worklist[worklist.length () - 1];
 	  defs[n_defs].bb_index = top;
 	  defs[n_defs].dfs_num = defs[i].dfs_num + 1;
 	}
@@ -828,7 +822,7 @@ prune_unused_phi_nodes (bitmap phis, bitmap kills, bitmap uses)
 	     it to the correct position.  */
 	  defs[n_defs].bb_index = defs[i].bb_index;
 	  defs[n_defs].dfs_num = defs[i].dfs_num;
-	  VEC_quick_push (int, worklist, b);
+	  worklist.quick_push (b);
 	  top = b;
 	}
 
@@ -839,19 +833,19 @@ prune_unused_phi_nodes (bitmap phis, bitmap kills, bitmap uses)
       else
 	n_defs++;
     }
-  VEC_pop (int, worklist);
-  gcc_assert (VEC_empty (int, worklist));
+  worklist.pop ();
+  gcc_assert (worklist.is_empty ());
 
   /* Now process the uses.  */
   live_phis = BITMAP_ALLOC (NULL);
   EXECUTE_IF_SET_IN_BITMAP (uses, 0, i, bi)
     {
-      VEC_safe_push (int, heap, worklist, i);
+      worklist.safe_push (i);
     }
 
-  while (!VEC_empty (int, worklist))
+  while (!worklist.is_empty ())
     {
-      b = VEC_pop (int, worklist);
+      b = worklist.pop ();
       if (b == ENTRY_BLOCK)
 	continue;
 
@@ -889,11 +883,11 @@ prune_unused_phi_nodes (bitmap phis, bitmap kills, bitmap uses)
 	    continue;
 
 	  bitmap_set_bit (uses, u);
-	  VEC_safe_push (int, heap, worklist, u);
+	  worklist.safe_push (u);
 	}
     }
 
-  VEC_free (int, heap, worklist);
+  worklist.release ();
   bitmap_copy (phis, live_phis);
   BITMAP_FREE (live_phis);
   free (defs);
@@ -932,15 +926,14 @@ mark_phi_for_rewrite (basic_block bb, gimple phi)
   bitmap_set_bit (blocks_with_phis_to_rewrite, idx);
 
   n = (unsigned) last_basic_block + 1;
-  if (VEC_length (gimple_vec, phis_to_rewrite) < n)
-    VEC_safe_grow_cleared (gimple_vec, heap, phis_to_rewrite, n);
+  if (phis_to_rewrite.length () < n)
+    phis_to_rewrite.safe_grow_cleared (n);
 
-  phis = VEC_index (gimple_vec, phis_to_rewrite, idx);
-  if (!phis)
-    phis = VEC_alloc (gimple, heap, 10);
+  phis = phis_to_rewrite[idx];
+  phis.reserve (10);
 
-  VEC_safe_push (gimple, heap, phis, phi);
-  VEC_replace (gimple_vec, phis_to_rewrite, idx, phis);
+  phis.safe_push (phi);
+  phis_to_rewrite[idx] = phis;
 }
 
 /* Insert PHI nodes for variable VAR using the iterated dominance
@@ -1049,27 +1042,27 @@ insert_phi_nodes (bitmap_head *dfs)
   htab_iterator hi;
   unsigned i;
   var_info_p info;
-  VEC(var_info_p,heap) *vars;
+  vec<var_info_p> vars;
 
   timevar_push (TV_TREE_INSERT_PHI_NODES);
 
-  vars = VEC_alloc (var_info_p, heap, htab_elements (var_infos));
+  vars.create (htab_elements (var_infos));
   FOR_EACH_HTAB_ELEMENT (var_infos, info, var_info_p, hi)
     if (info->info.need_phi_state != NEED_PHI_STATE_NO)
-      VEC_quick_push (var_info_p, vars, info);
+      vars.quick_push (info);
 
   /* Do two stages to avoid code generation differences for UID
      differences but no UID ordering differences.  */
-  VEC_qsort (var_info_p, vars, insert_phi_nodes_compare_var_infos);
+  vars.qsort (insert_phi_nodes_compare_var_infos);
 
-  FOR_EACH_VEC_ELT (var_info_p, vars, i, info)
+  FOR_EACH_VEC_ELT (vars, i, info)
     {
       bitmap idf = compute_idf (info->info.def_blocks.def_blocks, dfs);
       insert_phi_nodes_for (info->var, idf, false);
       BITMAP_FREE (idf);
     }
 
-  VEC_free(var_info_p, heap, vars);
+  vars.release ();
 
   timevar_pop (TV_TREE_INSERT_PHI_NODES);
 }
@@ -1105,7 +1098,7 @@ register_new_def (tree def, tree sym)
      in the stack so that we know which symbol is being defined by
      this SSA name when we unwind the stack.  */
   if (currdef && !is_gimple_reg (sym))
-    VEC_safe_push (tree, heap, block_defs_stack, sym);
+    block_defs_stack.safe_push (sym);
 
   /* Push the current reaching definition into BLOCK_DEFS_STACK.  This
      stack is later used by the dominator tree callbacks to restore
@@ -1113,7 +1106,7 @@ register_new_def (tree def, tree sym)
      block after a recursive visit to all its immediately dominated
      blocks.  If there is no current reaching definition, then just
      record the underlying _DECL node.  */
-  VEC_safe_push (tree, heap, block_defs_stack, currdef ? currdef : sym);
+  block_defs_stack.safe_push (currdef ? currdef : sym);
 
   /* Set the current reaching definition for SYM to be DEF.  */
   info->current_def = def;
@@ -1388,7 +1381,7 @@ rewrite_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
     fprintf (dump_file, "\n\nRenaming block #%d\n\n", bb->index);
 
   /* Mark the unwind point for this block.  */
-  VEC_safe_push (tree, heap, block_defs_stack, NULL_TREE);
+  block_defs_stack.safe_push (NULL_TREE);
 
   /* Step 1.  Register new definitions for every PHI node in the block.
      Conceptually, all the PHI nodes are executed in parallel and each PHI
@@ -1423,9 +1416,9 @@ rewrite_leave_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
 		     basic_block bb ATTRIBUTE_UNUSED)
 {
   /* Restore CURRDEFS to its original state.  */
-  while (VEC_length (tree, block_defs_stack) > 0)
+  while (block_defs_stack.length () > 0)
     {
-      tree tmp = VEC_pop (tree, block_defs_stack);
+      tree tmp = block_defs_stack.pop ();
       tree saved_def, var;
 
       if (tmp == NULL_TREE)
@@ -1443,7 +1436,7 @@ rewrite_leave_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
 	  saved_def = tmp;
 	  var = SSA_NAME_VAR (saved_def);
 	  if (!is_gimple_reg (var))
-	    var = VEC_pop (tree, block_defs_stack);
+	    var = block_defs_stack.pop ();
 	}
       else
 	{
@@ -1511,11 +1504,11 @@ dump_defs_stack (FILE *file, int n)
 
   i = 1;
   fprintf (file, "Level %d (current level)\n", i);
-  for (j = (int) VEC_length (tree, block_defs_stack) - 1; j >= 0; j--)
+  for (j = (int) block_defs_stack.length () - 1; j >= 0; j--)
     {
       tree name, var;
 
-      name = VEC_index (tree, block_defs_stack, j);
+      name = block_defs_stack[j];
       if (name == NULL_TREE)
 	{
 	  i++;
@@ -1536,7 +1529,7 @@ dump_defs_stack (FILE *file, int n)
 	  if (!is_gimple_reg (var))
 	    {
 	      j--;
-	      var = VEC_index (tree, block_defs_stack, j);
+	      var = block_defs_stack[j];
 	    }
 	}
 
@@ -1572,11 +1565,11 @@ dump_currdefs (FILE *file)
   unsigned i;
   tree var;
 
-  if (VEC_empty (tree, symbols_to_rename))
+  if (symbols_to_rename.is_empty ())
     return;
 
   fprintf (file, "\n\nCurrent reaching definitions\n\n");
-  FOR_EACH_VEC_ELT (tree, symbols_to_rename, i, var)
+  FOR_EACH_VEC_ELT (symbols_to_rename, i, var)
     {
       common_info_p info = get_common_info (var);
       fprintf (file, "CURRDEF (");
@@ -1732,9 +1725,9 @@ register_new_update_single (tree new_name, tree old_name)
      restore the reaching definitions for all the variables
      defined in the block after a recursive visit to all its
      immediately dominated blocks.  */
-  VEC_reserve (tree, heap, block_defs_stack, 2);
-  VEC_quick_push (tree, block_defs_stack, currdef);
-  VEC_quick_push (tree, block_defs_stack, old_name);
+  block_defs_stack.reserve (2);
+  block_defs_stack.quick_push (currdef);
+  block_defs_stack.quick_push (old_name);
 
   /* Set the current reaching definition for OLD_NAME to be
      NEW_NAME.  */
@@ -1988,8 +1981,8 @@ rewrite_update_phi_arguments (basic_block bb)
       if (!bitmap_bit_p (blocks_with_phis_to_rewrite, e->dest->index))
 	continue;
 
-      phis = VEC_index (gimple_vec, phis_to_rewrite, e->dest->index);
-      FOR_EACH_VEC_ELT (gimple, phis, i, phi)
+      phis = phis_to_rewrite[e->dest->index];
+      FOR_EACH_VEC_ELT (phis, i, phi)
 	{
 	  tree arg, lhs_sym, reaching_def = NULL;
 	  use_operand_p arg_p;
@@ -2068,7 +2061,7 @@ rewrite_update_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
 	     bb->index);
 
   /* Mark the unwind point for this block.  */
-  VEC_safe_push (tree, heap, block_defs_stack, NULL_TREE);
+  block_defs_stack.safe_push (NULL_TREE);
 
   if (!bitmap_bit_p (blocks_to_update, bb->index))
     return;
@@ -2135,9 +2128,9 @@ static void
 rewrite_update_leave_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
 			    basic_block bb ATTRIBUTE_UNUSED)
 {
-  while (VEC_length (tree, block_defs_stack) > 0)
+  while (block_defs_stack.length () > 0)
     {
-      tree var = VEC_pop (tree, block_defs_stack);
+      tree var = block_defs_stack.pop ();
       tree saved_def;
 
       /* NULL indicates the unwind stop point for this block (see
@@ -2145,7 +2138,7 @@ rewrite_update_leave_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
       if (var == NULL)
 	return;
 
-      saved_def = VEC_pop (tree, block_defs_stack);
+      saved_def = block_defs_stack.pop ();
       get_common_info (var)->current_def = saved_def;
     }
 }
@@ -2191,7 +2184,7 @@ rewrite_blocks (basic_block entry, enum rewrite_mode what)
   else
     gcc_unreachable ();
 
-  block_defs_stack = VEC_alloc (tree, heap, 10);
+  block_defs_stack.create (10);
 
   /* Initialize the dominator walker.  */
   init_walk_dominator_tree (&walk_data);
@@ -2211,7 +2204,7 @@ rewrite_blocks (basic_block entry, enum rewrite_mode what)
 	dump_tree_ssa_stats (dump_file);
     }
 
-  VEC_free (tree, heap, block_defs_stack);
+  block_defs_stack.release ();
 
   timevar_pop (TV_TREE_SSA_REWRITE_BLOCKS);
 }
@@ -2288,7 +2281,7 @@ init_ssa_renamer (void)
 
   /* Allocate memory for the DEF_BLOCKS hash table.  */
   gcc_assert (var_infos == NULL);
-  var_infos = htab_create (VEC_length (tree, cfun->local_decls),
+  var_infos = htab_create (vec_safe_length (cfun->local_decls),
 			   var_info_hash, var_info_eq, free);
 
   bitmap_obstack_initialize (&update_ssa_obstack);
@@ -2808,7 +2801,7 @@ delete_update_ssa (void)
 
   BITMAP_FREE (symbols_to_rename_set);
   symbols_to_rename_set = NULL;
-  VEC_free (tree, heap, symbols_to_rename);
+  symbols_to_rename.release ();
 
   if (names_to_release)
     {
@@ -2824,10 +2817,9 @@ delete_update_ssa (void)
   if (blocks_with_phis_to_rewrite)
     EXECUTE_IF_SET_IN_BITMAP (blocks_with_phis_to_rewrite, 0, i, bi)
       {
-	gimple_vec phis = VEC_index (gimple_vec, phis_to_rewrite, i);
-
-	VEC_free (gimple, heap, phis);
-	VEC_replace (gimple_vec, phis_to_rewrite, i, NULL);
+	gimple_vec phis = phis_to_rewrite[i];
+	phis.release ();
+	phis_to_rewrite[i].create (0);
       }
 
   BITMAP_FREE (blocks_with_phis_to_rewrite);
@@ -3141,8 +3133,8 @@ update_ssa (unsigned update_flags)
   gcc_assert (update_ssa_initialized_fn == cfun);
 
   blocks_with_phis_to_rewrite = BITMAP_ALLOC (NULL);
-  if (!phis_to_rewrite)
-    phis_to_rewrite = VEC_alloc (gimple_vec, heap, last_basic_block + 1);
+  if (!phis_to_rewrite.exists ())
+    phis_to_rewrite.create (last_basic_block + 1);
   blocks_to_update = BITMAP_ALLOC (NULL);
 
   /* Ensure that the dominance information is up-to-date.  */
@@ -3248,7 +3240,7 @@ update_ssa (unsigned update_flags)
 	  sbitmap_free (tmp);
 	}
 
-      FOR_EACH_VEC_ELT (tree, symbols_to_rename, i, sym)
+      FOR_EACH_VEC_ELT (symbols_to_rename, i, sym)
 	insert_updated_phi_nodes_for (sym, dfs, blocks_to_update,
 	                              update_flags);
 
@@ -3269,7 +3261,7 @@ update_ssa (unsigned update_flags)
   EXECUTE_IF_SET_IN_BITMAP (old_ssa_names, 0, i, sbi)
     get_ssa_name_ann (ssa_name (i))->info.current_def = NULL_TREE;
 
-  FOR_EACH_VEC_ELT (tree, symbols_to_rename, i, sym)
+  FOR_EACH_VEC_ELT (symbols_to_rename, i, sym)
     get_var_info (sym)->info.current_def = NULL_TREE;
 
   /* Now start the renaming process at START_BB.  */