2012-11-26 Basile Starynkevitch <basile@starynkevitch.net>

	MELT branch merged with trunk rev 193836 using svnmerge.py
	**broken, gcc/melt/xtramelt-ana-base.melt dont compile**



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/melt-branch@193843 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 88 insertions, 94 deletions

diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c
index fa80f246b42..40350eb9b50 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 = vNULL;
 
 /* 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 = vNULL;
 
 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 = vNULL;
 
   /* 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;