1 files changed, 68 insertions, 89 deletions

diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
index 4274457..7f4d045 100644
--- a/gcc/tree-ssa-loop-im.c
+++ b/gcc/tree-ssa-loop-im.c
@@ -105,18 +105,14 @@ typedef struct mem_ref_loc
   gimple stmt;			/* The statement in that it occurs.  */
 } *mem_ref_loc_p;
 
-DEF_VEC_P(mem_ref_loc_p);
-DEF_VEC_ALLOC_P(mem_ref_loc_p, heap);
 
 /* The list of memory reference locations in a loop.  */
 
 typedef struct mem_ref_locs
 {
-  VEC (mem_ref_loc_p, heap) *locs;
+  vec<mem_ref_loc_p> locs;
 } *mem_ref_locs_p;
 
-DEF_VEC_P(mem_ref_locs_p);
-DEF_VEC_ALLOC_P(mem_ref_locs_p, heap);
 
 /* Description of a memory reference.  */
 
@@ -128,7 +124,7 @@ typedef struct mem_ref
   hashval_t hash;		/* Its hash value.  */
   bitmap stored;		/* The set of loops in that this memory location
 				   is stored to.  */
-  VEC (mem_ref_locs_p, heap) *accesses_in_loop;
+  vec<mem_ref_locs_p> accesses_in_loop;
 				/* The locations of the accesses.  Vector
 				   indexed by the loop number.  */
 
@@ -149,14 +145,8 @@ typedef struct mem_ref
   bitmap dep_ref;		/* The complement of INDEP_REF.  */
 } *mem_ref_p;
 
-DEF_VEC_P(mem_ref_p);
-DEF_VEC_ALLOC_P(mem_ref_p, heap);
 
-DEF_VEC_P(bitmap);
-DEF_VEC_ALLOC_P(bitmap, heap);
 
-DEF_VEC_P(htab_t);
-DEF_VEC_ALLOC_P(htab_t, heap);
 
 /* Description of memory accesses in loops.  */
 
@@ -166,18 +156,18 @@ static struct
   htab_t refs;
 
   /* The list of memory references.  */
-  VEC (mem_ref_p, heap) *refs_list;
+  vec<mem_ref_p> refs_list;
 
   /* The set of memory references accessed in each loop.  */
-  VEC (bitmap, heap) *refs_in_loop;
+  vec<bitmap> refs_in_loop;
 
   /* The set of memory references accessed in each loop, including
      subloops.  */
-  VEC (bitmap, heap) *all_refs_in_loop;
+  vec<bitmap> all_refs_in_loop;
 
   /* The set of memory references stored in each loop, including
      subloops.  */
-  VEC (bitmap, heap) *all_refs_stored_in_loop;
+  vec<bitmap> all_refs_stored_in_loop;
 
   /* Cache for expanding memory addresses.  */
   struct pointer_map_t *ttae_cache;
@@ -1473,9 +1463,9 @@ free_mem_ref_locs (mem_ref_locs_p accs)
   if (!accs)
     return;
 
-  FOR_EACH_VEC_ELT (mem_ref_loc_p, accs->locs, i, loc)
+  FOR_EACH_VEC_ELT (accs->locs, i, loc)
     free (loc);
-  VEC_free (mem_ref_loc_p, heap, accs->locs);
+  accs->locs.release ();
   free (accs);
 }
 
@@ -1487,9 +1477,9 @@ memref_free (struct mem_ref *mem)
   unsigned i;
   mem_ref_locs_p accs;
 
-  FOR_EACH_VEC_ELT (mem_ref_locs_p, mem->accesses_in_loop, i, accs)
+  FOR_EACH_VEC_ELT (mem->accesses_in_loop, i, accs)
     free_mem_ref_locs (accs);
-  VEC_free (mem_ref_locs_p, heap, mem->accesses_in_loop);
+  mem->accesses_in_loop.release ();
 
   free (mem);
 }
@@ -1509,7 +1499,7 @@ mem_ref_alloc (tree mem, unsigned hash, unsigned id)
   ref->dep_loop = BITMAP_ALLOC (&lim_bitmap_obstack);
   ref->indep_ref = BITMAP_ALLOC (&lim_bitmap_obstack);
   ref->dep_ref = BITMAP_ALLOC (&lim_bitmap_obstack);
-  ref->accesses_in_loop = NULL;
+  ref->accesses_in_loop.create (0);
 
   return ref;
 }
@@ -1520,7 +1510,7 @@ static mem_ref_locs_p
 mem_ref_locs_alloc (void)
 {
   mem_ref_locs_p accs = XNEW (struct mem_ref_locs);
-  accs->locs = NULL;
+  accs->locs.create (0);
   return accs;
 }
 
@@ -1532,23 +1522,22 @@ record_mem_ref_loc (mem_ref_p ref, struct loop *loop, gimple stmt, tree *loc)
 {
   mem_ref_loc_p aref = XNEW (struct mem_ref_loc);
   mem_ref_locs_p accs;
-  bitmap ril = VEC_index (bitmap, memory_accesses.refs_in_loop, loop->num);
+  bitmap ril = memory_accesses.refs_in_loop[loop->num];
 
-  if (VEC_length (mem_ref_locs_p, ref->accesses_in_loop)
+  if (ref->accesses_in_loop.length ()
       <= (unsigned) loop->num)
-    VEC_safe_grow_cleared (mem_ref_locs_p, heap, ref->accesses_in_loop,
-			   loop->num + 1);
-  accs = VEC_index (mem_ref_locs_p, ref->accesses_in_loop, loop->num);
+    ref->accesses_in_loop.safe_grow_cleared (loop->num + 1);
+  accs = ref->accesses_in_loop[loop->num];
   if (!accs)
     {
       accs = mem_ref_locs_alloc ();
-      VEC_replace (mem_ref_locs_p, ref->accesses_in_loop, loop->num, accs);
+      ref->accesses_in_loop[loop->num] = accs;
     }
 
   aref->stmt = stmt;
   aref->ref = loc;
 
-  VEC_safe_push (mem_ref_loc_p, heap, accs->locs, aref);
+  accs->locs.safe_push (aref);
   bitmap_set_bit (ril, ref->id);
 }
 
@@ -1585,9 +1574,9 @@ gather_mem_refs_stmt (struct loop *loop, gimple stmt)
   mem = simple_mem_ref_in_stmt (stmt, &is_stored);
   if (!mem)
     {
-      id = VEC_length (mem_ref_p, memory_accesses.refs_list);
+      id = memory_accesses.refs_list.length ();
       ref = mem_ref_alloc (error_mark_node, 0, id);
-      VEC_safe_push (mem_ref_p, heap, memory_accesses.refs_list, ref);
+      memory_accesses.refs_list.safe_push (ref);
       if (dump_file && (dump_flags & TDF_DETAILS))
 	{
 	  fprintf (dump_file, "Unanalyzed memory reference %u: ", id);
@@ -1609,9 +1598,9 @@ gather_mem_refs_stmt (struct loop *loop, gimple stmt)
     }
   else
     {
-      id = VEC_length (mem_ref_p, memory_accesses.refs_list);
+      id = memory_accesses.refs_list.length ();
       ref = mem_ref_alloc (*mem, hash, id);
-      VEC_safe_push (mem_ref_p, heap, memory_accesses.refs_list, ref);
+      memory_accesses.refs_list.safe_push (ref);
       *slot = ref;
 
       if (dump_file && (dump_flags & TDF_DETAILS))
@@ -1654,15 +1643,14 @@ gather_mem_refs_in_loops (void)
      the loop hierarchy.  */
   FOR_EACH_LOOP (li, loop, LI_FROM_INNERMOST)
     {
-      lrefs = VEC_index (bitmap, memory_accesses.refs_in_loop, loop->num);
-      alrefs = VEC_index (bitmap, memory_accesses.all_refs_in_loop, loop->num);
+      lrefs = memory_accesses.refs_in_loop[loop->num];
+      alrefs = memory_accesses.all_refs_in_loop[loop->num];
       bitmap_ior_into (alrefs, lrefs);
 
       if (loop_outer (loop) == current_loops->tree_root)
 	continue;
 
-      alrefso = VEC_index (bitmap, memory_accesses.all_refs_in_loop,
-			   loop_outer (loop)->num);
+      alrefso = memory_accesses.all_refs_in_loop[loop_outer (loop)->num];
       bitmap_ior_into (alrefso, alrefs);
     }
 }
@@ -1673,7 +1661,7 @@ gather_mem_refs_in_loops (void)
 static void
 create_vop_ref_mapping_loop (struct loop *loop)
 {
-  bitmap refs = VEC_index (bitmap, memory_accesses.refs_in_loop, loop->num);
+  bitmap refs = memory_accesses.refs_in_loop[loop->num];
   struct loop *sloop;
   bitmap_iterator bi;
   unsigned i;
@@ -1681,14 +1669,13 @@ create_vop_ref_mapping_loop (struct loop *loop)
 
   EXECUTE_IF_SET_IN_BITMAP (refs, 0, i, bi)
     {
-      ref = VEC_index (mem_ref_p, memory_accesses.refs_list, i);
+      ref = memory_accesses.refs_list[i];
       for (sloop = loop; sloop != current_loops->tree_root;
 	   sloop = loop_outer (sloop))
 	if (bitmap_bit_p (ref->stored, loop->num))
 	  {
 	    bitmap refs_stored
-	      = VEC_index (bitmap, memory_accesses.all_refs_stored_in_loop,
-			   sloop->num);
+	      = memory_accesses.all_refs_stored_in_loop[sloop->num];
 	    bitmap_set_bit (refs_stored, ref->id);
 	  }
     }
@@ -1718,22 +1705,19 @@ analyze_memory_references (void)
   bitmap empty;
 
   memory_accesses.refs = htab_create (100, memref_hash, memref_eq, NULL);
-  memory_accesses.refs_list = NULL;
-  memory_accesses.refs_in_loop = VEC_alloc (bitmap, heap,
-					    number_of_loops ());
-  memory_accesses.all_refs_in_loop = VEC_alloc (bitmap, heap,
-						number_of_loops ());
-  memory_accesses.all_refs_stored_in_loop = VEC_alloc (bitmap, heap,
-						       number_of_loops ());
+  memory_accesses.refs_list.create (0);
+  memory_accesses.refs_in_loop.create (number_of_loops ());
+  memory_accesses.all_refs_in_loop.create (number_of_loops ());
+  memory_accesses.all_refs_stored_in_loop.create (number_of_loops ());
 
   for (i = 0; i < number_of_loops (); i++)
     {
       empty = BITMAP_ALLOC (&lim_bitmap_obstack);
-      VEC_quick_push (bitmap, memory_accesses.refs_in_loop, empty);
+      memory_accesses.refs_in_loop.quick_push (empty);
       empty = BITMAP_ALLOC (&lim_bitmap_obstack);
-      VEC_quick_push (bitmap, memory_accesses.all_refs_in_loop, empty);
+      memory_accesses.all_refs_in_loop.quick_push (empty);
       empty = BITMAP_ALLOC (&lim_bitmap_obstack);
-      VEC_quick_push (bitmap, memory_accesses.all_refs_stored_in_loop, empty);
+      memory_accesses.all_refs_stored_in_loop.quick_push (empty);
     }
 
   memory_accesses.ttae_cache = NULL;
@@ -1789,26 +1773,25 @@ rewrite_mem_ref_loc (mem_ref_loc_p loc, tree tmp_var)
 
 static void
 get_all_locs_in_loop (struct loop *loop, mem_ref_p ref,
-		      VEC (mem_ref_loc_p, heap) **locs)
+		      vec<mem_ref_loc_p> *locs)
 {
   mem_ref_locs_p accs;
   unsigned i;
   mem_ref_loc_p loc;
-  bitmap refs = VEC_index (bitmap, memory_accesses.all_refs_in_loop,
-			   loop->num);
+  bitmap refs = memory_accesses.all_refs_in_loop[loop->num];
   struct loop *subloop;
 
   if (!bitmap_bit_p (refs, ref->id))
     return;
 
-  if (VEC_length (mem_ref_locs_p, ref->accesses_in_loop)
+  if (ref->accesses_in_loop.length ()
       > (unsigned) loop->num)
     {
-      accs = VEC_index (mem_ref_locs_p, ref->accesses_in_loop, loop->num);
+      accs = ref->accesses_in_loop[loop->num];
       if (accs)
 	{
-	  FOR_EACH_VEC_ELT (mem_ref_loc_p, accs->locs, i, loc)
-	    VEC_safe_push (mem_ref_loc_p, heap, *locs, loc);
+	  FOR_EACH_VEC_ELT (accs->locs, i, loc)
+	    locs->safe_push (loc);
 	}
     }
 
@@ -1823,12 +1806,12 @@ rewrite_mem_refs (struct loop *loop, mem_ref_p ref, tree tmp_var)
 {
   unsigned i;
   mem_ref_loc_p loc;
-  VEC (mem_ref_loc_p, heap) *locs = NULL;
+  vec<mem_ref_loc_p> locs = vec<mem_ref_loc_p>();
 
   get_all_locs_in_loop (loop, ref, &locs);
-  FOR_EACH_VEC_ELT (mem_ref_loc_p, locs, i, loc)
+  FOR_EACH_VEC_ELT (locs, i, loc)
     rewrite_mem_ref_loc (loc, tmp_var);
-  VEC_free (mem_ref_loc_p, heap, locs);
+  locs.release ();
 }
 
 /* The name and the length of the currently generated variable
@@ -2095,13 +2078,13 @@ execute_sm_if_changed_flag_set (struct loop *loop, mem_ref_p ref)
   unsigned i;
   mem_ref_loc_p loc;
   tree flag;
-  VEC (mem_ref_loc_p, heap) *locs = NULL;
+  vec<mem_ref_loc_p> locs = vec<mem_ref_loc_p>();
   char *str = get_lsm_tmp_name (ref->mem, ~0);
 
   lsm_tmp_name_add ("_flag");
   flag = create_tmp_reg (boolean_type_node, str);
   get_all_locs_in_loop (loop, ref, &locs);
-  FOR_EACH_VEC_ELT (mem_ref_loc_p, locs, i, loc)
+  FOR_EACH_VEC_ELT (locs, i, loc)
     {
       gimple_stmt_iterator gsi;
       gimple stmt;
@@ -2115,7 +2098,7 @@ execute_sm_if_changed_flag_set (struct loop *loop, mem_ref_p ref)
 	  gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
 	}
     }
-  VEC_free (mem_ref_loc_p, heap, locs);
+  locs.release ();
   return flag;
 }
 
@@ -2125,7 +2108,7 @@ execute_sm_if_changed_flag_set (struct loop *loop, mem_ref_p ref)
    to the reference from the temporary variable are emitted to exits.  */
 
 static void
-execute_sm (struct loop *loop, VEC (edge, heap) *exits, mem_ref_p ref)
+execute_sm (struct loop *loop, vec<edge> exits, mem_ref_p ref)
 {
   tree tmp_var, store_flag;
   unsigned i;
@@ -2181,7 +2164,7 @@ execute_sm (struct loop *loop, VEC (edge, heap) *exits, mem_ref_p ref)
     }
 
   /* Sink the store to every exit from the loop.  */
-  FOR_EACH_VEC_ELT (edge, exits, i, ex)
+  FOR_EACH_VEC_ELT (exits, i, ex)
     if (!multi_threaded_model_p)
       {
 	gimple store;
@@ -2197,7 +2180,7 @@ execute_sm (struct loop *loop, VEC (edge, heap) *exits, mem_ref_p ref)
 
 static void
 hoist_memory_references (struct loop *loop, bitmap mem_refs,
-			 VEC (edge, heap) *exits)
+			 vec<edge> exits)
 {
   mem_ref_p ref;
   unsigned  i;
@@ -2205,7 +2188,7 @@ hoist_memory_references (struct loop *loop, bitmap mem_refs,
 
   EXECUTE_IF_SET_IN_BITMAP (mem_refs, 0, i, bi)
     {
-      ref = VEC_index (mem_ref_p, memory_accesses.refs_list, i);
+      ref = memory_accesses.refs_list[i];
       execute_sm (loop, exits, ref);
     }
 }
@@ -2216,7 +2199,7 @@ hoist_memory_references (struct loop *loop, bitmap mem_refs,
 static bool
 ref_always_accessed_p (struct loop *loop, mem_ref_p ref, bool stored_p)
 {
-  VEC (mem_ref_loc_p, heap) *locs = NULL;
+  vec<mem_ref_loc_p> locs = vec<mem_ref_loc_p>();
   unsigned i;
   mem_ref_loc_p loc;
   bool ret = false;
@@ -2229,7 +2212,7 @@ ref_always_accessed_p (struct loop *loop, mem_ref_p ref, bool stored_p)
     base = TREE_OPERAND (base, 0);
 
   get_all_locs_in_loop (loop, ref, &locs);
-  FOR_EACH_VEC_ELT (mem_ref_loc_p, locs, i, loc)
+  FOR_EACH_VEC_ELT (locs, i, loc)
     {
       if (!get_lim_data (loc->stmt))
 	continue;
@@ -2262,7 +2245,7 @@ ref_always_accessed_p (struct loop *loop, mem_ref_p ref, bool stored_p)
 	  break;
 	}
     }
-  VEC_free (mem_ref_loc_p, heap, locs);
+  locs.release ();
 
   return ret;
 }
@@ -2329,16 +2312,13 @@ ref_indep_loop_p_1 (struct loop *loop, mem_ref_p ref)
   mem_ref_p aref;
 
   if (stored)
-    refs_to_check = VEC_index (bitmap,
-			       memory_accesses.all_refs_in_loop, loop->num);
+    refs_to_check = memory_accesses.all_refs_in_loop[loop->num];
   else
-    refs_to_check = VEC_index (bitmap,
-			       memory_accesses.all_refs_stored_in_loop,
-			       loop->num);
+    refs_to_check = memory_accesses.all_refs_stored_in_loop[loop->num];
 
   EXECUTE_IF_SET_IN_BITMAP (refs_to_check, 0, i, bi)
     {
-      aref = VEC_index (mem_ref_p, memory_accesses.refs_list, i);
+      aref = memory_accesses.refs_list[i];
       if (!MEM_ANALYZABLE (aref)
 	  || !refs_independent_p (ref, aref))
 	{
@@ -2425,15 +2405,14 @@ can_sm_ref_p (struct loop *loop, mem_ref_p ref)
 static void
 find_refs_for_sm (struct loop *loop, bitmap sm_executed, bitmap refs_to_sm)
 {
-  bitmap refs = VEC_index (bitmap, memory_accesses.all_refs_in_loop,
-			   loop->num);
+  bitmap refs = memory_accesses.all_refs_in_loop[loop->num];
   unsigned i;
   bitmap_iterator bi;
   mem_ref_p ref;
 
   EXECUTE_IF_AND_COMPL_IN_BITMAP (refs, sm_executed, 0, i, bi)
     {
-      ref = VEC_index (mem_ref_p, memory_accesses.refs_list, i);
+      ref = memory_accesses.refs_list[i];
       if (can_sm_ref_p (loop, ref))
 	bitmap_set_bit (refs_to_sm, i);
     }
@@ -2445,12 +2424,12 @@ find_refs_for_sm (struct loop *loop, bitmap sm_executed, bitmap refs_to_sm)
 
 static bool
 loop_suitable_for_sm (struct loop *loop ATTRIBUTE_UNUSED,
-		      VEC (edge, heap) *exits)
+		      vec<edge> exits)
 {
   unsigned i;
   edge ex;
 
-  FOR_EACH_VEC_ELT (edge, exits, i, ex)
+  FOR_EACH_VEC_ELT (exits, i, ex)
     if (ex->flags & (EDGE_ABNORMAL | EDGE_EH))
       return false;
 
@@ -2464,7 +2443,7 @@ loop_suitable_for_sm (struct loop *loop ATTRIBUTE_UNUSED,
 static void
 store_motion_loop (struct loop *loop, bitmap sm_executed)
 {
-  VEC (edge, heap) *exits = get_loop_exit_edges (loop);
+  vec<edge> exits = get_loop_exit_edges (loop);
   struct loop *subloop;
   bitmap sm_in_loop = BITMAP_ALLOC (NULL);
 
@@ -2473,7 +2452,7 @@ store_motion_loop (struct loop *loop, bitmap sm_executed)
       find_refs_for_sm (loop, sm_executed, sm_in_loop);
       hoist_memory_references (loop, sm_in_loop, exits);
     }
-  VEC_free (edge, heap, exits);
+  exits.release ();
 
   bitmap_ior_into (sm_executed, sm_in_loop);
   for (subloop = loop->inner; subloop != NULL; subloop = subloop->next)
@@ -2623,13 +2602,13 @@ tree_ssa_lim_finalize (void)
 
   htab_delete (memory_accesses.refs);
 
-  FOR_EACH_VEC_ELT (mem_ref_p, memory_accesses.refs_list, i, ref)
+  FOR_EACH_VEC_ELT (memory_accesses.refs_list, i, ref)
     memref_free (ref);
-  VEC_free (mem_ref_p, heap, memory_accesses.refs_list);
+  memory_accesses.refs_list.release ();
 
-  VEC_free (bitmap, heap, memory_accesses.refs_in_loop);
-  VEC_free (bitmap, heap, memory_accesses.all_refs_in_loop);
-  VEC_free (bitmap, heap, memory_accesses.all_refs_stored_in_loop);
+  memory_accesses.refs_in_loop.release ();
+  memory_accesses.all_refs_in_loop.release ();
+  memory_accesses.all_refs_stored_in_loop.release ();
 
   if (memory_accesses.ttae_cache)
     free_affine_expand_cache (&memory_accesses.ttae_cache);