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, 88 insertions, 94 deletions

diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c
index fa80f24..48e15f8 100644
--- a/gcc/haifa-sched.c
+++ b/gcc/haifa-sched.c
@@ -143,7 +143,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "target.h"
 #include "common/common-target.h"
 #include "params.h"
-#include "vecprim.h"
 #include "dbgcnt.h"
 #include "cfgloop.h"
 #include "ira.h"
@@ -355,7 +354,7 @@ int cycle_issued_insns;
 
 /* This records the actual schedule.  It is built up during the main phase
    of schedule_block, and afterwards used to reorder the insns in the RTL.  */
-static VEC(rtx, heap) *scheduled_insns;
+static vec<rtx> scheduled_insns;
 
 static int may_trap_exp (const_rtx, int);
 
@@ -384,13 +383,13 @@ const struct common_sched_info_def haifa_common_sched_info =
   };
 
 /* Mapping from instruction UID to its Logical UID.  */
-VEC (int, heap) *sched_luids = NULL;
+vec<int> sched_luids = vec<int>();
 
 /* Next LUID to assign to an instruction.  */
 int sched_max_luid = 1;
 
 /* Haifa Instruction Data.  */
-VEC (haifa_insn_data_def, heap) *h_i_d = NULL;
+vec<haifa_insn_data_def> h_i_d = vec<haifa_insn_data_def>();
 
 void (* sched_init_only_bb) (basic_block, basic_block);
 
@@ -863,7 +862,7 @@ static void dump_new_block_header (int, basic_block, rtx, rtx);
 static void restore_bb_notes (basic_block);
 static void fix_jump_move (rtx);
 static void move_block_after_check (rtx);
-static void move_succs (VEC(edge,gc) **, basic_block);
+static void move_succs (vec<edge, va_gc> **, basic_block);
 static void sched_remove_insn (rtx);
 static void clear_priorities (rtx, rtx_vec_t *);
 static void calc_priorities (rtx_vec_t);
@@ -1142,15 +1141,13 @@ update_insn_after_change (rtx insn)
   INSN_TICK (insn) = INVALID_TICK;
 }
 
-DEF_VEC_P(dep_t);
-DEF_VEC_ALLOC_P(dep_t, heap);
 
 /* Two VECs, one to hold dependencies for which pattern replacements
    need to be applied or restored at the start of the next cycle, and
    another to hold an integer that is either one, to apply the
    corresponding replacement, or zero to restore it.  */
-static VEC(dep_t, heap) *next_cycle_replace_deps;
-static VEC(int, heap) *next_cycle_apply;
+static vec<dep_t> next_cycle_replace_deps;
+static vec<int> next_cycle_apply;
 
 static void apply_replacement (dep_t, bool);
 static void restore_pattern (dep_t, bool);
@@ -1272,7 +1269,7 @@ recompute_todo_spec (rtx next, bool for_backtrack)
 	 REG_DEP_CONTROL; if the condition register isn't modified after it,
 	 we know that it still has the right value.  */
       if (QUEUE_INDEX (pro) == QUEUE_SCHEDULED)
-	FOR_EACH_VEC_ELT_REVERSE (rtx, scheduled_insns, i, prev)
+	FOR_EACH_VEC_ELT_REVERSE (scheduled_insns, i, prev)
 	  {
 	    HARD_REG_SET t;
 
@@ -1863,7 +1860,7 @@ struct model_pressure_group {
 
 /* Index POINT gives the instruction at point POINT of the model schedule.
    This array doesn't change during main scheduling.  */
-static VEC (rtx, heap) *model_schedule;
+static vec<rtx> model_schedule;
 
 /* The list of instructions in the model worklist, sorted in order of
    decreasing priority.  */
@@ -1907,7 +1904,7 @@ static unsigned int model_next_priority;
 
 /* The instruction at point POINT of the model schedule.  */
 #define MODEL_INSN(POINT) \
-  (VEC_index (rtx, model_schedule, POINT))
+  (model_schedule[POINT])
 
 
 /* Return INSN's index in the model schedule, or model_num_insns if it
@@ -3255,8 +3252,8 @@ model_add_to_schedule (rtx insn)
   gcc_assert (QUEUE_INDEX (insn) == QUEUE_NOWHERE);
   QUEUE_INDEX (insn) = QUEUE_SCHEDULED;
 
-  point = VEC_length (rtx, model_schedule);
-  VEC_quick_push (rtx, model_schedule, insn);
+  point = model_schedule.length ();
+  model_schedule.quick_push (insn);
   INSN_MODEL_INDEX (insn) = point + 1;
 }
 
@@ -3612,7 +3609,7 @@ model_reset_queue_indices (void)
   unsigned int i;
   rtx insn;
 
-  FOR_EACH_VEC_ELT (rtx, model_schedule, i, insn)
+  FOR_EACH_VEC_ELT (model_schedule, i, insn)
     QUEUE_INDEX (insn) = MODEL_INSN_INFO (insn)->old_queue;
 }
 
@@ -3643,7 +3640,7 @@ model_start_schedule (void)
   basic_block bb;
 
   model_next_priority = 1;
-  model_schedule = VEC_alloc (rtx, heap, sched_max_luid);
+  model_schedule.create (sched_max_luid);
   model_insns = XCNEWVEC (struct model_insn_info, sched_max_luid);
 
   bb = BLOCK_FOR_INSN (NEXT_INSN (current_sched_info->prev_head));
@@ -3653,7 +3650,7 @@ model_start_schedule (void)
   model_init_pressure_group (&model_before_pressure);
   while (model_worklist)
     model_choose_insn ();
-  gcc_assert (model_num_insns == (int) VEC_length (rtx, model_schedule));
+  gcc_assert (model_num_insns == (int) model_schedule.length ());
   if (sched_verbose >= 2)
     fprintf (sched_dump, "\n");
 
@@ -3682,7 +3679,7 @@ static void
 model_end_schedule (void)
 {
   model_finalize_pressure_group (&model_before_pressure);
-  VEC_free (rtx, heap, model_schedule);
+  model_schedule.release ();
 }
 
 /* A structure that holds local state for the loop in schedule_block.  */
@@ -4027,13 +4024,13 @@ struct haifa_saved_data
 
   /* Describe pattern replacements that occurred since this backtrack point
      was queued.  */
-  VEC (dep_t, heap) *replacement_deps;
-  VEC (int, heap) *replace_apply;
+  vec<dep_t> replacement_deps;
+  vec<int> replace_apply;
 
   /* A copy of the next-cycle replacement vectors at the time of the backtrack
      point.  */
-  VEC (dep_t, heap) *next_cycle_deps;
-  VEC (int, heap) *next_cycle_apply;
+  vec<dep_t> next_cycle_deps;
+  vec<int> next_cycle_apply;
 };
 
 /* A record, in reverse order, of all scheduled insns which have delay slots
@@ -4090,10 +4087,10 @@ save_backtrack_point (struct delay_pair *pair,
 
   save->sched_block = sched_block;
 
-  save->replacement_deps = NULL;
-  save->replace_apply = NULL;
-  save->next_cycle_deps = VEC_copy (dep_t, heap, next_cycle_replace_deps);
-  save->next_cycle_apply = VEC_copy (int, heap, next_cycle_apply);
+  save->replacement_deps.create (0);
+  save->replace_apply.create (0);
+  save->next_cycle_deps = next_cycle_replace_deps.copy ();
+  save->next_cycle_apply = next_cycle_apply.copy ();
 
   if (current_sched_info->save_state)
     save->fe_saved_data = (*current_sched_info->save_state) ();
@@ -4169,18 +4166,18 @@ toggle_cancelled_flags (bool set)
 static void
 undo_replacements_for_backtrack (struct haifa_saved_data *save)
 {
-  while (!VEC_empty (dep_t, save->replacement_deps))
+  while (!save->replacement_deps.is_empty ())
     {
-      dep_t dep = VEC_pop (dep_t, save->replacement_deps);
-      int apply_p = VEC_pop (int, save->replace_apply);
+      dep_t dep = save->replacement_deps.pop ();
+      int apply_p = save->replace_apply.pop ();
 
       if (apply_p)
 	restore_pattern (dep, true);
       else
 	apply_replacement (dep, true);
     }
-  VEC_free (dep_t, heap, save->replacement_deps);
-  VEC_free (int, heap, save->replace_apply);
+  save->replacement_deps.release ();
+  save->replace_apply.release ();
 }
 
 /* Pop entries from the SCHEDULED_INSNS vector up to and including INSN.
@@ -4190,9 +4187,7 @@ undo_replacements_for_backtrack (struct haifa_saved_data *save)
 static void
 unschedule_insns_until (rtx insn)
 {
-  VEC (rtx, heap) *recompute_vec;
-
-  recompute_vec = VEC_alloc (rtx, heap, 0);
+  vec<rtx> recompute_vec = vec<rtx>();
 
   /* Make two passes over the insns to be unscheduled.  First, we clear out
      dependencies and other trivial bookkeeping.  */
@@ -4202,7 +4197,7 @@ unschedule_insns_until (rtx insn)
       sd_iterator_def sd_it;
       dep_t dep;
 
-      last = VEC_pop (rtx, scheduled_insns);
+      last = scheduled_insns.pop ();
 
       /* This will be changed by restore_backtrack_point if the insn is in
 	 any queue.  */
@@ -4221,7 +4216,7 @@ unschedule_insns_until (rtx insn)
 	  if (!MUST_RECOMPUTE_SPEC_P (con))
 	    {
 	      MUST_RECOMPUTE_SPEC_P (con) = 1;
-	      VEC_safe_push (rtx, heap, recompute_vec, con);
+	      recompute_vec.safe_push (con);
 	    }
 	}
 
@@ -4234,11 +4229,11 @@ unschedule_insns_until (rtx insn)
      popped the scheduled_insns vector up to the point where we
      restart scheduling, as recompute_todo_spec requires it to be
      up-to-date.  */
-  while (!VEC_empty (rtx, recompute_vec))
+  while (!recompute_vec.is_empty ())
     {
       rtx con;
 
-      con = VEC_pop (rtx, recompute_vec);
+      con = recompute_vec.pop ();
       MUST_RECOMPUTE_SPEC_P (con) = 0;
       if (!sd_lists_empty_p (con, SD_LIST_HARD_BACK))
 	{
@@ -4250,7 +4245,7 @@ unschedule_insns_until (rtx insn)
       else if (QUEUE_INDEX (con) != QUEUE_SCHEDULED)
 	TODO_SPEC (con) = recompute_todo_spec (con, true);
     }
-  VEC_free (rtx, heap, recompute_vec);
+  recompute_vec.release ();
 }
 
 /* Restore scheduler state from the topmost entry on the backtracking queue.
@@ -4353,9 +4348,9 @@ restore_last_backtrack_point (struct sched_block_state *psched_block)
 
   mark_backtrack_feeds (save->delay_pair->i2, 0);
 
-  gcc_assert (VEC_empty (dep_t, next_cycle_replace_deps));
-  next_cycle_replace_deps = VEC_copy (dep_t, heap, save->next_cycle_deps);
-  next_cycle_apply = VEC_copy (int, heap, save->next_cycle_apply);
+  gcc_assert (next_cycle_replace_deps.is_empty ());
+  next_cycle_replace_deps = save->next_cycle_deps.copy ();
+  next_cycle_apply = save->next_cycle_apply.copy ();
 
   free (save);
 
@@ -4390,8 +4385,8 @@ free_topmost_backtrack_point (bool reset_tick)
     }
   else
     {
-      VEC_free (dep_t, heap, save->replacement_deps);
-      VEC_free (int, heap, save->replace_apply);
+      save->replacement_deps.release ();
+      save->replace_apply.release ();
     }
 
   if (targetm.sched.free_sched_context)
@@ -4425,8 +4420,8 @@ apply_replacement (dep_t dep, bool immediately)
   struct dep_replacement *desc = DEP_REPLACE (dep);
   if (!immediately && targetm.sched.exposed_pipeline && reload_completed)
     {
-      VEC_safe_push (dep_t, heap, next_cycle_replace_deps, dep);
-      VEC_safe_push (int, heap, next_cycle_apply, 1);
+      next_cycle_replace_deps.safe_push (dep);
+      next_cycle_apply.safe_push (1);
     }
   else
     {
@@ -4448,8 +4443,8 @@ apply_replacement (dep_t dep, bool immediately)
 
       if (backtrack_queue != NULL)
 	{
-	  VEC_safe_push (dep_t, heap, backtrack_queue->replacement_deps, dep);
-	  VEC_safe_push (int, heap, backtrack_queue->replace_apply, 1);
+	  backtrack_queue->replacement_deps.safe_push (dep);
+	  backtrack_queue->replace_apply.safe_push (1);
 	}
     }
 }
@@ -4471,8 +4466,8 @@ restore_pattern (dep_t dep, bool immediately)
 
   if (!immediately && targetm.sched.exposed_pipeline && reload_completed)
     {
-      VEC_safe_push (dep_t, heap, next_cycle_replace_deps, dep);
-      VEC_safe_push (int, heap, next_cycle_apply, 0);
+      next_cycle_replace_deps.safe_push (dep);
+      next_cycle_apply.safe_push (0);
       return;
     }
 
@@ -4499,8 +4494,8 @@ restore_pattern (dep_t dep, bool immediately)
       update_insn_after_change (desc->insn);
       if (backtrack_queue != NULL)
 	{
-	  VEC_safe_push (dep_t, heap, backtrack_queue->replacement_deps, dep);
-	  VEC_safe_push (int, heap, backtrack_queue->replace_apply, 0);
+	  backtrack_queue->replacement_deps.safe_push (dep);
+	  backtrack_queue->replace_apply.safe_push (0);
 	}
     }
   INSN_TICK (next) = tick;
@@ -4520,16 +4515,16 @@ perform_replacements_new_cycle (void)
 {
   int i;
   dep_t dep;
-  FOR_EACH_VEC_ELT (dep_t, next_cycle_replace_deps, i, dep)
+  FOR_EACH_VEC_ELT (next_cycle_replace_deps, i, dep)
     {
-      int apply_p = VEC_index (int, next_cycle_apply, i);
+      int apply_p = next_cycle_apply[i];
       if (apply_p)
 	apply_replacement (dep, true);
       else
 	restore_pattern (dep, true);
     }
-  VEC_truncate (dep_t, next_cycle_replace_deps, 0);
-  VEC_truncate (int, next_cycle_apply, 0);
+  next_cycle_replace_deps.truncate (0);
+  next_cycle_apply.truncate (0);
 }
 
 /* Compute INSN_TICK_ESTIMATE for INSN.  PROCESSED is a bitmap of
@@ -4617,7 +4612,7 @@ resolve_dependencies (rtx insn)
   if (QUEUE_INDEX (insn) >= 0)
     queue_remove (insn);
 
-  VEC_safe_push (rtx, heap, scheduled_insns, insn);
+  scheduled_insns.safe_push (insn);
 
   /* Update dependent instructions.  */
   for (sd_it = sd_iterator_start (insn, SD_LIST_FORW);
@@ -4797,7 +4792,7 @@ undo_all_replacements (void)
   rtx insn;
   int i;
 
-  FOR_EACH_VEC_ELT (rtx, scheduled_insns, i, insn)
+  FOR_EACH_VEC_ELT (scheduled_insns, i, insn)
     {
       sd_iterator_def sd_it;
       dep_t dep;
@@ -4930,14 +4925,14 @@ ok_for_early_queue_removal (rtx insn)
     {
       rtx prev_insn;
       int n_cycles;
-      int i = VEC_length (rtx, scheduled_insns);
+      int i = scheduled_insns.length ();
       for (n_cycles = flag_sched_stalled_insns_dep; n_cycles; n_cycles--)
 	{
 	  while (i-- > 0)
 	    {
 	      int cost;
 
-	      prev_insn = VEC_index (rtx, scheduled_insns, i);
+	      prev_insn = scheduled_insns[i];
 
 	      if (!NOTE_P (prev_insn))
 		{
@@ -5623,7 +5618,7 @@ commit_schedule (rtx prev_head, rtx tail, basic_block *target_bb)
 
   last_scheduled_insn = prev_head;
   for (i = 0;
-       VEC_iterate (rtx, scheduled_insns, i, insn);
+       scheduled_insns.iterate (i, &insn);
        i++)
     {
       if (control_flow_insn_p (last_scheduled_insn)
@@ -5652,7 +5647,7 @@ commit_schedule (rtx prev_head, rtx tail, basic_block *target_bb)
       last_scheduled_insn = insn;
     }
 
-  VEC_truncate (rtx, scheduled_insns, 0);
+  scheduled_insns.truncate (0);
 }
 
 /* Examine all insns on the ready list and queue those which can't be
@@ -5971,7 +5966,7 @@ schedule_block (basic_block *target_bb, state_t init_state)
 
   advance = 0;
 
-  gcc_assert (VEC_length (rtx, scheduled_insns) == 0);
+  gcc_assert (scheduled_insns.length () == 0);
   sort_p = TRUE;
   must_backtrack = false;
   modulo_insns_scheduled = 0;
@@ -6082,7 +6077,7 @@ schedule_block (basic_block *target_bb, state_t init_state)
 		  rtx insn = ready_remove_first (&ready);
 		  gcc_assert (DEBUG_INSN_P (insn));
 		  (*current_sched_info->begin_schedule_ready) (insn);
-		  VEC_safe_push (rtx, heap, scheduled_insns, insn);
+		  scheduled_insns.safe_push (insn);
 		  last_scheduled_insn = insn;
 		  advance = schedule_insn (insn);
 		  gcc_assert (advance == 0);
@@ -6233,7 +6228,7 @@ schedule_block (basic_block *target_bb, state_t init_state)
 
 	  /* Update counters, etc in the scheduler's front end.  */
 	  (*current_sched_info->begin_schedule_ready) (insn);
-	  VEC_safe_push (rtx, heap, scheduled_insns, insn);
+	  scheduled_insns.safe_push (insn);
 	  gcc_assert (NONDEBUG_INSN_P (insn));
 	  last_nondebug_scheduled_insn = last_scheduled_insn = insn;
 
@@ -6433,7 +6428,7 @@ schedule_block (basic_block *target_bb, state_t init_state)
   else
     last_scheduled_insn = tail;
 
-  VEC_truncate (rtx, scheduled_insns, 0);
+  scheduled_insns.truncate (0);
 
   if (!current_sched_info->queue_must_finish_empty
       || haifa_recovery_bb_recently_added_p)
@@ -6661,7 +6656,7 @@ haifa_sched_init (void)
   setup_sched_dump ();
   sched_init ();
 
-  scheduled_insns = VEC_alloc (rtx, heap, 0);
+  scheduled_insns.create (0);
 
   if (spec_info != NULL)
     {
@@ -6672,19 +6667,20 @@ haifa_sched_init (void)
   /* Initialize luids, dependency caches, target and h_i_d for the
      whole function.  */
   {
-    bb_vec_t bbs = VEC_alloc (basic_block, heap, n_basic_blocks);
+    bb_vec_t bbs;
+    bbs.create (n_basic_blocks);
     basic_block bb;
 
     sched_init_bbs ();
 
     FOR_EACH_BB (bb)
-      VEC_quick_push (basic_block, bbs, bb);
+      bbs.quick_push (bb);
     sched_init_luids (bbs);
     sched_deps_init (true);
     sched_extend_target ();
     haifa_init_h_i_d (bbs);
 
-    VEC_free (basic_block, heap, bbs);
+    bbs.release ();
   }
 
   sched_init_only_bb = haifa_init_only_bb;
@@ -6728,7 +6724,7 @@ haifa_sched_finish (void)
                c, nr_be_in_control);
     }
 
-  VEC_free (rtx, heap, scheduled_insns);
+  scheduled_insns.release ();
 
   /* Finalize h_i_d, dependency caches, and luids for the whole
      function.  Target will be finalized in md_global_finish ().  */
@@ -7093,7 +7089,7 @@ sched_extend_ready_list (int new_sched_ready_n_insns)
     {
       i = 0;
       sched_ready_n_insns = 0;
-      VEC_reserve (rtx, heap, scheduled_insns, new_sched_ready_n_insns);
+      scheduled_insns.reserve (new_sched_ready_n_insns);
     }
   else
     i = sched_ready_n_insns + 1;
@@ -7290,7 +7286,7 @@ add_to_speculative_block (rtx insn)
 	sd_iterator_next (&sd_it);
     }
 
-  priorities_roots = NULL;
+  priorities_roots.create (0);
   clear_priorities (insn, &priorities_roots);
 
   while (1)
@@ -7384,7 +7380,7 @@ add_to_speculative_block (rtx insn)
     }
 
   calc_priorities (priorities_roots);
-  VEC_free (rtx, heap, priorities_roots);
+  priorities_roots.release ();
 }
 
 /* Extends and fills with zeros (only the new part) array pointed to by P.  */
@@ -7494,8 +7490,8 @@ init_before_recovery (basic_block *before_recovery_ptr)
       /* Add new blocks to the root loop.  */
       if (current_loops != NULL)
 	{
-	  add_bb_to_loop (single, VEC_index (loop_p, current_loops->larray, 0));
-	  add_bb_to_loop (empty, VEC_index (loop_p, current_loops->larray, 0));
+	  add_bb_to_loop (single, (*current_loops->larray)[0]);
+	  add_bb_to_loop (empty, (*current_loops->larray)[0]);
 	}
 
       single->count = last->count;
@@ -7881,11 +7877,11 @@ create_check_block_twin (rtx insn, bool mutate_p)
     /* Fix priorities.  If MUTATE_P is nonzero, this is not necessary,
        because it'll be done later in add_to_speculative_block.  */
     {
-      rtx_vec_t priorities_roots = NULL;
+      rtx_vec_t priorities_roots = rtx_vec_t();
 
       clear_priorities (twin, &priorities_roots);
       calc_priorities (priorities_roots);
-      VEC_free (rtx, heap, priorities_roots);
+      priorities_roots.release ();
     }
 }
 
@@ -8153,7 +8149,7 @@ static void
 move_block_after_check (rtx jump)
 {
   basic_block bb, jump_bb, jump_bb_next;
-  VEC(edge,gc) *t;
+  vec<edge, va_gc> *t;
 
   bb = BLOCK_FOR_INSN (PREV_INSN (jump));
   jump_bb = BLOCK_FOR_INSN (jump);
@@ -8183,7 +8179,7 @@ move_block_after_check (rtx jump)
    This functions attaches edge vector pointed to by SUCCSP to
    block TO.  */
 static void
-move_succs (VEC(edge,gc) **succsp, basic_block to)
+move_succs (vec<edge, va_gc> **succsp, basic_block to)
 {
   edge e;
   edge_iterator ei;
@@ -8240,7 +8236,7 @@ clear_priorities (rtx insn, rtx_vec_t *roots_ptr)
     }
 
   if (insn_is_root_p)
-    VEC_safe_push (rtx, heap, *roots_ptr, insn);
+    roots_ptr->safe_push (insn);
 }
 
 /* Recompute priorities of instructions, whose priorities might have been
@@ -8252,7 +8248,7 @@ calc_priorities (rtx_vec_t roots)
   int i;
   rtx insn;
 
-  FOR_EACH_VEC_ELT (rtx, roots, i, insn)
+  FOR_EACH_VEC_ELT (roots, i, insn)
     priority (insn);
 }
 
@@ -8287,7 +8283,7 @@ sched_extend_luids (void)
 {
   int new_luids_max_uid = get_max_uid () + 1;
 
-  VEC_safe_grow_cleared (int, heap, sched_luids, new_luids_max_uid);
+  sched_luids.safe_grow_cleared (new_luids_max_uid);
 }
 
 /* Initialize LUID for INSN.  */
@@ -8318,7 +8314,7 @@ sched_init_luids (bb_vec_t bbs)
   basic_block bb;
 
   sched_extend_luids ();
-  FOR_EACH_VEC_ELT (basic_block, bbs, i, bb)
+  FOR_EACH_VEC_ELT (bbs, i, bb)
     {
       rtx insn;
 
@@ -8331,7 +8327,7 @@ sched_init_luids (bb_vec_t bbs)
 void
 sched_finish_luids (void)
 {
-  VEC_free (int, heap, sched_luids);
+  sched_luids.release ();
   sched_max_luid = 1;
 }
 
@@ -8355,13 +8351,11 @@ sched_extend_target (void)
 static void
 extend_h_i_d (void)
 {
-  int reserve = (get_max_uid () + 1
-                 - VEC_length (haifa_insn_data_def, h_i_d));
+  int reserve = (get_max_uid () + 1 - h_i_d.length ());
   if (reserve > 0
-      && ! VEC_space (haifa_insn_data_def, h_i_d, reserve))
+      && ! h_i_d.space (reserve))
     {
-      VEC_safe_grow_cleared (haifa_insn_data_def, heap, h_i_d,
-                             3 * get_max_uid () / 2);
+      h_i_d.safe_grow_cleared (3 * get_max_uid () / 2);
       sched_extend_target ();
     }
 }
@@ -8390,7 +8384,7 @@ haifa_init_h_i_d (bb_vec_t bbs)
   basic_block bb;
 
   extend_h_i_d ();
-  FOR_EACH_VEC_ELT (basic_block, bbs, i, bb)
+  FOR_EACH_VEC_ELT (bbs, i, bb)
     {
       rtx insn;
 
@@ -8407,7 +8401,7 @@ haifa_finish_h_i_d (void)
   haifa_insn_data_t data;
   struct reg_use_data *use, *next;
 
-  FOR_EACH_VEC_ELT (haifa_insn_data_def, h_i_d, i, data)
+  FOR_EACH_VEC_ELT (h_i_d, i, data)
     {
       free (data->max_reg_pressure);
       free (data->reg_pressure);
@@ -8417,7 +8411,7 @@ haifa_finish_h_i_d (void)
 	  free (use);
 	}
     }
-  VEC_free (haifa_insn_data_def, heap, h_i_d);
+  h_i_d.release ();
 }
 
 /* Init data for the new insn INSN.  */
@@ -8491,7 +8485,7 @@ sched_emit_insn (rtx pat)
     current_sched_info->add_remove_insn (insn, 0);
 
   (*current_sched_info->begin_schedule_ready) (insn);
-  VEC_safe_push (rtx, heap, scheduled_insns, insn);
+  scheduled_insns.safe_push (insn);
 
   last_scheduled_insn = insn;
   return insn;