Fix PR47002: memory leaks.

2010-12-23  Sebastian Pop  <sebastian.pop@amd.com>

	PR tree-optimization/47002
	* tree-data-ref.c (compute_data_dependences_for_loop): Pass in a
	pointer to the loop_nest.
	(analyze_all_data_dependences): Initialize and free the loop_nest.
	(free_dependence_relations): Do not free loop_nest.
	(build_rdg): Pass in the loop_nest, datarefs, and dependence_relations.
	(free_rdg): Also free the data on edges.
	* tree-data-ref.h (build_rdg): Update declaration.
	(compute_data_dependences_for_loop): Same.
	* tree-if-conv.c (if_convertible_loop_p_1): Pass in the loop_nest.
	(if_convertible_loop_p): Allocate and free loop_nest.
	* tree-loop-distribution.c (rdg_flag_loop_exits): Free conds.
	(free_rdg_components): VEC_free components.
	(distribute_loop): Update call to build_rdg.  Allocate and free
	loop_nest, datarefs, and dependence_relations.
	* tree-loop-linear.c (linear_transform_loops): Allocate and free
	loop_nest.
	* tree-parloops.c (loop_parallel_p): Same.
	* tree-predcom.c (tree_predictive_commoning_loop): Same.
	* tree-vect-data-refs.c (vect_analyze_data_refs): Pass to
	compute_data_dependences_for_loop a pointer to LOOP_VINFO_LOOP_NEST.
	* tree-vect-loop.c (new_loop_vec_info): Initialize LOOP_VINFO_LOOP_NEST.
	(destroy_loop_vec_info): Free LOOP_VINFO_MAY_ALIAS_DDRS and
	LOOP_VINFO_LOOP_NEST.
	* tree-vect-slp.c (destroy_bb_vec_info): Call free_data_refs and
	free_dependence_relations.
	* tree-vectorizer.h (struct _loop_vec_info): Add a field loop_nest.
	(LOOP_VINFO_LOOP_NEST): New.

From-SVN: r168210

1 files changed, 33 insertions, 45 deletions

diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index a6d0731..a9782f4 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -4247,11 +4247,11 @@ find_loop_nest (struct loop *loop, VEC (loop_p, heap) **loop_nest)
 bool
 compute_data_dependences_for_loop (struct loop *loop,
 				   bool compute_self_and_read_read_dependences,
+				   VEC (loop_p, heap) **loop_nest,
 				   VEC (data_reference_p, heap) **datarefs,
 				   VEC (ddr_p, heap) **dependence_relations)
 {
   bool res = true;
-  VEC (loop_p, heap) *vloops = VEC_alloc (loop_p, heap, 3);
 
   memset (&dependence_stats, 0, sizeof (dependence_stats));
 
@@ -4259,19 +4259,19 @@ compute_data_dependences_for_loop (struct loop *loop,
      is not computable, give up without spending time to compute other
      dependences.  */
   if (!loop
-      || !find_loop_nest (loop, &vloops)
+      || !find_loop_nest (loop, loop_nest)
       || find_data_references_in_loop (loop, datarefs) == chrec_dont_know)
     {
       struct data_dependence_relation *ddr;
 
       /* Insert a single relation into dependence_relations:
 	 chrec_dont_know.  */
-      ddr = initialize_data_dependence_relation (NULL, NULL, vloops);
+      ddr = initialize_data_dependence_relation (NULL, NULL, *loop_nest);
       VEC_safe_push (ddr_p, heap, *dependence_relations, ddr);
       res = false;
     }
   else
-    compute_all_dependences (*datarefs, dependence_relations, vloops,
+    compute_all_dependences (*datarefs, dependence_relations, *loop_nest,
 			     compute_self_and_read_read_dependences);
 
   if (dump_file && (dump_flags & TDF_STATS))
@@ -4375,9 +4375,10 @@ analyze_all_data_dependences (struct loop *loop)
     VEC_alloc (data_reference_p, heap, nb_data_refs);
   VEC (ddr_p, heap) *dependence_relations =
     VEC_alloc (ddr_p, heap, nb_data_refs * nb_data_refs);
+  VEC (loop_p, heap) *loop_nest = VEC_alloc (loop_p, heap, 3);
 
   /* Compute DDs on the whole function.  */
-  compute_data_dependences_for_loop (loop, false, &datarefs,
+  compute_data_dependences_for_loop (loop, false, &loop_nest, &datarefs,
 				     &dependence_relations);
 
   if (dump_file)
@@ -4411,6 +4412,7 @@ analyze_all_data_dependences (struct loop *loop)
 	}
     }
 
+  VEC_free (loop_p, heap, loop_nest);
   free_dependence_relations (dependence_relations);
   free_data_refs (datarefs);
 }
@@ -4454,22 +4456,11 @@ free_dependence_relations (VEC (ddr_p, heap) *dependence_relations)
 {
   unsigned int i;
   struct data_dependence_relation *ddr;
-  VEC (loop_p, heap) *loop_nest = NULL;
 
   FOR_EACH_VEC_ELT (ddr_p, dependence_relations, i, ddr)
-    {
-      if (ddr == NULL)
-	continue;
-      if (loop_nest == NULL)
-	loop_nest = DDR_LOOP_NEST (ddr);
-      else
-	gcc_assert (DDR_LOOP_NEST (ddr) == NULL
-		    || DDR_LOOP_NEST (ddr) == loop_nest);
+    if (ddr)
       free_dependence_relation (ddr);
-    }
 
-  if (loop_nest)
-    VEC_free (loop_p, heap, loop_nest);
   VEC_free (ddr_p, heap, dependence_relations);
 }
 
@@ -4905,37 +4896,24 @@ build_empty_rdg (int n_stmts)
    scalar dependence.  */
 
 struct graph *
-build_rdg (struct loop *loop)
+build_rdg (struct loop *loop,
+	   VEC (loop_p, heap) **loop_nest,
+	   VEC (ddr_p, heap) **dependence_relations,
+	   VEC (data_reference_p, heap) **datarefs)
 {
-  int nb_data_refs = 10;
   struct graph *rdg = NULL;
-  VEC (ddr_p, heap) *dependence_relations;
-  VEC (data_reference_p, heap) *datarefs;
-  VEC (gimple, heap) *stmts = VEC_alloc (gimple, heap, nb_data_refs);
-
-  dependence_relations = VEC_alloc (ddr_p, heap, nb_data_refs * nb_data_refs) ;
-  datarefs = VEC_alloc (data_reference_p, heap, nb_data_refs);
-  compute_data_dependences_for_loop (loop,
-                                     false,
-                                     &datarefs,
-                                     &dependence_relations);
-
-  if (!known_dependences_p (dependence_relations))
-    {
-      free_dependence_relations (dependence_relations);
-      free_data_refs (datarefs);
-      VEC_free (gimple, heap, stmts);
-
-      return rdg;
-    }
+  VEC (gimple, heap) *stmts = VEC_alloc (gimple, heap, 10);
 
-  stmts_from_loop (loop, &stmts);
-  rdg = build_empty_rdg (VEC_length (gimple, stmts));
+  compute_data_dependences_for_loop (loop, false, loop_nest, datarefs,
+				     dependence_relations);
 
-  rdg->indices = htab_create (nb_data_refs, hash_stmt_vertex_info,
-			      eq_stmt_vertex_info, hash_stmt_vertex_del);
-  create_rdg_vertices (rdg, stmts);
-  create_rdg_edges (rdg, dependence_relations);
+  if (known_dependences_p (*dependence_relations))
+    {
+      stmts_from_loop (loop, &stmts);
+      rdg = build_empty_rdg (VEC_length (gimple, stmts));
+      create_rdg_vertices (rdg, stmts);
+      create_rdg_edges (rdg, *dependence_relations);
+    }
 
   VEC_free (gimple, heap, stmts);
   return rdg;
@@ -4949,7 +4927,17 @@ free_rdg (struct graph *rdg)
   int i;
 
   for (i = 0; i < rdg->n_vertices; i++)
-    free (rdg->vertices[i].data);
+    {
+      struct vertex *v = &(rdg->vertices[i]);
+      struct graph_edge *e;
+
+      for (e = v->succ; e; e = e->succ_next)
+	if (e->data)
+	  free (e->data);
+
+      if (v->data)
+	free (v->data);
+    }
 
   htab_delete (rdg->indices);
   free_graph (rdg);