1 files changed, 67 insertions, 65 deletions

diff --git a/gcc/graphite-scop-detection.c b/gcc/graphite-scop-detection.c
index 0ea9e6a473d..c6413589e0d 100644
--- a/gcc/graphite-scop-detection.c
+++ b/gcc/graphite-scop-detection.c
@@ -66,7 +66,7 @@ typedef enum gbb_type {
 static gbb_type
 get_bb_type (basic_block bb, struct loop *last_loop)
 {
-  VEC (basic_block, heap) *dom;
+  vec<basic_block> dom;
   int nb_dom;
   struct loop *loop = bb->loop_father;
 
@@ -82,8 +82,8 @@ get_bb_type (basic_block bb, struct loop *last_loop)
     }
 
   dom = get_dominated_by (CDI_DOMINATORS, bb);
-  nb_dom = VEC_length (basic_block, dom);
-  VEC_free (basic_block, heap, dom);
+  nb_dom = dom.length ();
+  dom.release ();
 
   if (nb_dom == 0)
     return GBB_LAST;
@@ -129,23 +129,20 @@ typedef struct sd_region_p
   basic_block exit;
 } sd_region;
 
-DEF_VEC_O(sd_region);
-DEF_VEC_ALLOC_O(sd_region, heap);
 
 
 /* Moves the scops from SOURCE to TARGET and clean up SOURCE.  */
 
 static void
-move_sd_regions (VEC (sd_region, heap) **source,
-		 VEC (sd_region, heap) **target)
+move_sd_regions (vec<sd_region> *source, vec<sd_region> *target)
 {
   sd_region *s;
   int i;
 
-  FOR_EACH_VEC_ELT (sd_region, *source, i, s)
-    VEC_safe_push (sd_region, heap, *target, *s);
+  FOR_EACH_VEC_ELT (*source, i, s)
+    target->safe_push (*s);
 
-  VEC_free (sd_region, heap, *source);
+  source->release ();
 }
 
 /* Something like "n * m" is not allowed.  */
@@ -270,7 +267,7 @@ stmt_has_simple_data_refs_p (loop_p outermost_loop ATTRIBUTE_UNUSED,
   unsigned i;
   int j;
   bool res = true;
-  VEC (data_reference_p, heap) *drs = NULL;
+  vec<data_reference_p> drs = vec<data_reference_p>();
   loop_p outer;
 
   for (outer = loop_containing_stmt (stmt); outer; outer = loop_outer (outer))
@@ -279,7 +276,7 @@ stmt_has_simple_data_refs_p (loop_p outermost_loop ATTRIBUTE_UNUSED,
 					     loop_containing_stmt (stmt),
 					     stmt, &drs);
 
-      FOR_EACH_VEC_ELT (data_reference_p, drs, j, dr)
+      FOR_EACH_VEC_ELT (drs, j, dr)
 	for (i = 0; i < DR_NUM_DIMENSIONS (dr); i++)
 	  if (!graphite_can_represent_scev (DR_ACCESS_FN (dr, i)))
 	    {
@@ -288,7 +285,7 @@ stmt_has_simple_data_refs_p (loop_p outermost_loop ATTRIBUTE_UNUSED,
 	    }
 
       free_data_refs (drs);
-      drs = NULL;
+      drs.create (0);
     }
 
  done:
@@ -426,14 +423,14 @@ struct scopdet_info
 };
 
 static struct scopdet_info build_scops_1 (basic_block, loop_p,
-					  VEC (sd_region, heap) **, loop_p);
+					  vec<sd_region> *, loop_p);
 
 /* Calculates BB infos. If bb is difficult we add valid SCoPs dominated by BB
    to SCOPS.  TYPE is the gbb_type of BB.  */
 
 static struct scopdet_info
 scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
-			  VEC (sd_region, heap) **scops, gbb_type type)
+			  vec<sd_region> *scops, gbb_type type)
 {
   loop_p loop = bb->loop_father;
   struct scopdet_info result;
@@ -468,7 +465,8 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 
     case GBB_LOOP_SING_EXIT_HEADER:
       {
-	VEC (sd_region, heap) *regions = VEC_alloc (sd_region, heap, 3);
+	vec<sd_region> regions;
+	regions.create (3);
 	struct scopdet_info sinfo;
 	edge exit_e = single_exit (loop);
 
@@ -485,8 +483,8 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 	  {
 	    outermost_loop = loop;
 
-	    VEC_free (sd_region, heap, regions);
-	    regions = VEC_alloc (sd_region, heap, 3);
+	    regions.release ();
+	    regions.create (3);
 
 	    sinfo = scopdet_basic_block_info (bb, outermost_loop, scops, type);
 
@@ -500,8 +498,8 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 		sd_region open_scop;
 		open_scop.entry = bb;
 		open_scop.exit = exit_e->dest;
-		VEC_safe_push (sd_region, heap, *scops, open_scop);
-		VEC_free (sd_region, heap, regions);
+		scops->safe_push (open_scop);
+		regions.release ();
 	      }
 	  }
 	else
@@ -523,7 +521,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 	    if (result.difficult)
 	      move_sd_regions (&regions, scops);
 	    else
-	      VEC_free (sd_region, heap, regions);
+	      regions.release ();
 	  }
 
 	break;
@@ -533,8 +531,9 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
       {
         /* XXX: For now we just do not join loops with multiple exits.  If the
            exits lead to the same bb it may be possible to join the loop.  */
-        VEC (sd_region, heap) *regions = VEC_alloc (sd_region, heap, 3);
-        VEC (edge, heap) *exits = get_loop_exit_edges (loop);
+        vec<sd_region> regions;
+	regions.create (3);
+        vec<edge> exits = get_loop_exit_edges (loop);
         edge e;
         int i;
 	build_scops_1 (bb, loop, &regions, loop);
@@ -549,7 +548,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 		  - The exit destinations are dominated by another bb inside
 		    the loop.
 		  - The loop dominates bbs, that are not exit destinations.  */
-        FOR_EACH_VEC_ELT (edge, exits, i, e)
+        FOR_EACH_VEC_ELT (exits, i, e)
           if (e->src->loop_father == loop
 	      && dominated_by_p (CDI_DOMINATORS, e->dest, e->src))
 	    {
@@ -571,14 +570,15 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
         result.difficult = true;
         result.exits = false;
         move_sd_regions (&regions, scops);
-        VEC_free (edge, heap, exits);
+        exits.release ();
         break;
       }
     case GBB_COND_HEADER:
       {
-	VEC (sd_region, heap) *regions = VEC_alloc (sd_region, heap, 3);
+	vec<sd_region> regions;
+	regions.create (3);
 	struct scopdet_info sinfo;
-	VEC (basic_block, heap) *dominated;
+	vec<basic_block> dominated;
 	int i;
 	basic_block dom_bb;
 	basic_block last_exit = NULL;
@@ -587,7 +587,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 
 	/* First check the successors of BB, and check if it is
 	   possible to join the different branches.  */
-	FOR_EACH_VEC_ELT (edge, bb->succs, i, e)
+	FOR_EACH_VEC_SAFE_ELT (bb->succs, i, e)
 	  {
 	    /* Ignore loop exits.  They will be handled after the loop
 	       body.  */
@@ -666,14 +666,14 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 
 	    result.exit = last_exit;
 
-	    VEC_free (sd_region, heap, regions);
+	    regions.release ();
 	    break;
 	  }
 
 	/* Scan remaining bbs dominated by BB.  */
 	dominated = get_dominated_by (CDI_DOMINATORS, bb);
 
-	FOR_EACH_VEC_ELT (basic_block, dominated, i, dom_bb)
+	FOR_EACH_VEC_ELT (dominated, i, dom_bb)
 	  {
 	    /* Ignore loop exits: they will be handled after the loop body.  */
 	    if (loop_depth (find_common_loop (loop, dom_bb->loop_father))
@@ -698,7 +698,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 	    result.exit = NULL;
 	  }
 
-	VEC_free (basic_block, heap, dominated);
+	dominated.release ();
 
 	result.next = NULL;
 	move_sd_regions (&regions, scops);
@@ -723,7 +723,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 
 static struct scopdet_info
 build_scops_1 (basic_block current, loop_p outermost_loop,
-	       VEC (sd_region, heap) **scops, loop_p loop)
+	       vec<sd_region> *scops, loop_p loop)
 {
   bool in_scop = false;
   sd_region open_scop;
@@ -756,7 +756,7 @@ build_scops_1 (basic_block current, loop_p outermost_loop,
       else if (in_scop && (sinfo.exits || sinfo.difficult))
         {
 	  open_scop.exit = current;
-          VEC_safe_push (sd_region, heap, *scops, open_scop);
+          scops->safe_push (open_scop);
           in_scop = false;
         }
 
@@ -771,7 +771,7 @@ build_scops_1 (basic_block current, loop_p outermost_loop,
     {
       open_scop.exit = sinfo.exit;
       gcc_assert (open_scop.exit);
-      VEC_safe_push (sd_region, heap, *scops, open_scop);
+      scops->safe_push (open_scop);
     }
 
   result.exit = sinfo.exit;
@@ -976,14 +976,14 @@ create_single_exit_edge (sd_region *region)
    See comment in "create_single_exit_edge". */
 
 static void
-unmark_exit_edges (VEC (sd_region, heap) *regions)
+unmark_exit_edges (vec<sd_region> regions)
 {
   int i;
   sd_region *s;
   edge e;
   edge_iterator ei;
 
-  FOR_EACH_VEC_ELT (sd_region, regions, i, s)
+  FOR_EACH_VEC_ELT (regions, i, s)
     FOR_EACH_EDGE (e, ei, s->exit->preds)
       e->aux = NULL;
 }
@@ -993,14 +993,14 @@ unmark_exit_edges (VEC (sd_region, heap) *regions)
    See comment in "create_single_exit_edge". */
 
 static void
-mark_exit_edges (VEC (sd_region, heap) *regions)
+mark_exit_edges (vec<sd_region> regions)
 {
   int i;
   sd_region *s;
   edge e;
   edge_iterator ei;
 
-  FOR_EACH_VEC_ELT (sd_region, regions, i, s)
+  FOR_EACH_VEC_ELT (regions, i, s)
     FOR_EACH_EDGE (e, ei, s->exit->preds)
       if (bb_in_sd_region (e->src, s))
 	e->aux = s;
@@ -1009,17 +1009,17 @@ mark_exit_edges (VEC (sd_region, heap) *regions)
 /* Create for all scop regions a single entry and a single exit edge.  */
 
 static void
-create_sese_edges (VEC (sd_region, heap) *regions)
+create_sese_edges (vec<sd_region> regions)
 {
   int i;
   sd_region *s;
 
-  FOR_EACH_VEC_ELT (sd_region, regions, i, s)
+  FOR_EACH_VEC_ELT (regions, i, s)
     create_single_entry_edge (s);
 
   mark_exit_edges (regions);
 
-  FOR_EACH_VEC_ELT (sd_region, regions, i, s)
+  FOR_EACH_VEC_ELT (regions, i, s)
     /* Don't handle multiple edges exiting the function.  */
     if (!find_single_exit_edge (s)
 	&& s->exit != EXIT_BLOCK_PTR)
@@ -1039,13 +1039,13 @@ create_sese_edges (VEC (sd_region, heap) *regions)
 /* Create graphite SCoPs from an array of scop detection REGIONS.  */
 
 static void
-build_graphite_scops (VEC (sd_region, heap) *regions,
-		      VEC (scop_p, heap) **scops)
+build_graphite_scops (vec<sd_region> regions,
+		      vec<scop_p> *scops)
 {
   int i;
   sd_region *s;
 
-  FOR_EACH_VEC_ELT (sd_region, regions, i, s)
+  FOR_EACH_VEC_ELT (regions, i, s)
     {
       edge entry = find_single_entry_edge (s);
       edge exit = find_single_exit_edge (s);
@@ -1055,7 +1055,7 @@ build_graphite_scops (VEC (sd_region, heap) *regions,
 	continue;
 
       scop = new_scop (new_sese (entry, exit));
-      VEC_safe_push (scop_p, heap, *scops, scop);
+      scops->safe_push (scop);
 
       /* Are there overlapping SCoPs?  */
 #ifdef ENABLE_CHECKING
@@ -1063,7 +1063,7 @@ build_graphite_scops (VEC (sd_region, heap) *regions,
 	  int j;
 	  sd_region *s2;
 
-	  FOR_EACH_VEC_ELT (sd_region, regions, j, s2)
+	  FOR_EACH_VEC_ELT (regions, j, s2)
 	    if (s != s2)
 	      gcc_assert (!bb_in_sd_region (s->entry, s2));
 	}
@@ -1147,12 +1147,12 @@ print_graphite_scop_statistics (FILE* file, scop_p scop)
 /* Print statistics for SCOPS to FILE.  */
 
 static void
-print_graphite_statistics (FILE* file, VEC (scop_p, heap) *scops)
+print_graphite_statistics (FILE* file, vec<scop_p> scops)
 {
   int i;
   scop_p scop;
 
-  FOR_EACH_VEC_ELT (scop_p, scops, i, scop)
+  FOR_EACH_VEC_ELT (scops, i, scop)
     print_graphite_scop_statistics (file, scop);
 }
 
@@ -1177,21 +1177,22 @@ print_graphite_statistics (FILE* file, VEC (scop_p, heap) *scops)
          SCoP frontiers.  */
 
 static void
-limit_scops (VEC (scop_p, heap) **scops)
+limit_scops (vec<scop_p> *scops)
 {
-  VEC (sd_region, heap) *regions = VEC_alloc (sd_region, heap, 3);
+  vec<sd_region> regions;
+  regions.create (3);
 
   int i;
   scop_p scop;
 
-  FOR_EACH_VEC_ELT (scop_p, *scops, i, scop)
+  FOR_EACH_VEC_ELT (*scops, i, scop)
     {
       int j;
       loop_p loop;
       sese region = SCOP_REGION (scop);
       build_sese_loop_nests (region);
 
-      FOR_EACH_VEC_ELT (loop_p, SESE_LOOP_NEST (region), j, loop)
+      FOR_EACH_VEC_ELT (SESE_LOOP_NEST (region), j, loop)
         if (!loop_in_sese_p (loop_outer (loop), region)
 	    && single_exit (loop))
           {
@@ -1205,16 +1206,16 @@ limit_scops (VEC (scop_p, heap) **scops)
 		&& contains_only_close_phi_nodes (open_scop.exit))
 	      open_scop.exit = single_succ_edge (open_scop.exit)->dest;
 
-	    VEC_safe_push (sd_region, heap, regions, open_scop);
+	    regions.safe_push (open_scop);
 	  }
     }
 
   free_scops (*scops);
-  *scops = VEC_alloc (scop_p, heap, 3);
+  scops->create (3);
 
   create_sese_edges (regions);
   build_graphite_scops (regions, scops);
-  VEC_free (sd_region, heap, regions);
+  regions.release ();
 }
 
 /* Returns true when P1 and P2 are close phis with the same
@@ -1390,10 +1391,11 @@ canonicalize_loop_closed_ssa_form (void)
    them to SCOPS.  */
 
 void
-build_scops (VEC (scop_p, heap) **scops)
+build_scops (vec<scop_p> *scops)
 {
   struct loop *loop = current_loops->tree_root;
-  VEC (sd_region, heap) *regions = VEC_alloc (sd_region, heap, 3);
+  vec<sd_region> regions;
+  regions.create (3);
 
   canonicalize_loop_closed_ssa_form ();
   build_scops_1 (single_succ (ENTRY_BLOCK_PTR), ENTRY_BLOCK_PTR->loop_father,
@@ -1405,11 +1407,11 @@ build_scops (VEC (scop_p, heap) **scops)
     print_graphite_statistics (dump_file, *scops);
 
   limit_scops (scops);
-  VEC_free (sd_region, heap, regions);
+  regions.release ();
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "\nnumber of SCoPs: %d\n",
-	     VEC_length (scop_p, *scops));
+	     scops ? scops->length () : 0);
 }
 
 /* Pretty print to FILE all the SCoPs in DOT format and mark them with
@@ -1423,7 +1425,7 @@ build_scops (VEC (scop_p, heap) **scops)
      exit nodes of the SCOP.  These are not part of SCoP.  */
 
 static void
-dot_all_scops_1 (FILE *file, VEC (scop_p, heap) *scops)
+dot_all_scops_1 (FILE *file, vec<scop_p> scops)
 {
   basic_block bb;
   edge e;
@@ -1450,7 +1452,7 @@ dot_all_scops_1 (FILE *file, VEC (scop_p, heap) *scops)
       fprintf (file, "CELLSPACING=\"0\">\n");
 
       /* Select color for SCoP.  */
-      FOR_EACH_VEC_ELT (scop_p, scops, i, scop)
+      FOR_EACH_VEC_ELT (scops, i, scop)
 	{
 	  sese region = SCOP_REGION (scop);
 	  if (bb_in_sese_p (bb, region)
@@ -1560,7 +1562,7 @@ dot_all_scops_1 (FILE *file, VEC (scop_p, heap) *scops)
 /* Display all SCoPs using dotty.  */
 
 DEBUG_FUNCTION void
-dot_all_scops (VEC (scop_p, heap) *scops)
+dot_all_scops (vec<scop_p> scops)
 {
   /* When debugging, enable the following code.  This cannot be used
      in production compilers because it calls "system".  */
@@ -1583,10 +1585,10 @@ dot_all_scops (VEC (scop_p, heap) *scops)
 DEBUG_FUNCTION void
 dot_scop (scop_p scop)
 {
-  VEC (scop_p, heap) *scops = NULL;
+  vec<scop_p> scops = vec<scop_p>();
 
   if (scop)
-    VEC_safe_push (scop_p, heap, scops, scop);
+    scops.safe_push (scop);
 
   /* When debugging, enable the following code.  This cannot be used
      in production compilers because it calls "system".  */
@@ -1604,7 +1606,7 @@ dot_scop (scop_p scop)
   dot_all_scops_1 (stderr, scops);
 #endif
 
-  VEC_free (scop_p, heap, scops);
+  scops.release ();
 }
 
 #endif