Re: PATCH: insn-attrtab vs. VM usage

[Robert Lipe <robertlipe at usa dot net>]

Richard Henderson wrote:
> On Mon, Oct 25, 1999 at 01:21:36PM -0500, Robert Lipe wrote:
> >  * gcse.c (expr_reaches_here_p): Use gmalloc and explit free instead
> >  of alloca.
> 
> What in the world is gmalloc.  Don't you mean xmalloc?

gmalloc is in gcse.c.  It looked like it was a way to determine how much
mem was used by each pass, so I went with it.  But since the alloca
stuff certainly wasn't reflected in the original version, I'll assume
it's OK to blow this off and all that activity in gcse_main() won't miss
it.

> > +      visited = (char *) gmalloc (n_basic_blocks);
> >        bzero (visited, n_basic_blocks);
> 
> Anyway, this pair is xcalloc.

Revised patch.

RJL


Index: gcse.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/gcse.c,v
retrieving revision 1.58
diff -u -p -r1.58 gcse.c
--- gcse.c	1999/10/24 19:23:11	1.58
+++ gcse.c	1999/10/25 20:54:00
@@ -2892,8 +2892,7 @@ expr_reaches_here_p (occr, expr, bb, che
 
   if (visited == NULL)
     {
-      visited = (char *) alloca (n_basic_blocks);
-      bzero (visited, n_basic_blocks);
+      visited = xcalloc (n_basic_blocks, 1);
     }
 
   for (pred = BASIC_BLOCK(bb)->pred; pred != NULL; pred = pred->pred_next)
@@ -4178,7 +4177,7 @@ compute_pre_data ()
    the closest such expression.  */
 
 static int
-pre_expr_reaches_here_p (occr_bb, expr, bb, check_pre_comp, visited)
+pre_expr_reaches_here_p_work (occr_bb, expr, bb, check_pre_comp, visited)
      int occr_bb;
      struct expr *expr;
      int bb;
@@ -4187,12 +4186,6 @@ pre_expr_reaches_here_p (occr_bb, expr, 
 {
   edge pred;
 
-  if (visited == NULL)
-    {
-      visited = (char *) alloca (n_basic_blocks);
-      bzero (visited, n_basic_blocks);
-    }
-
   for (pred = BASIC_BLOCK (bb)->pred; pred != NULL; pred = pred->pred_next)
     {
       int pred_bb = pred->src->index;
@@ -4221,8 +4214,8 @@ pre_expr_reaches_here_p (occr_bb, expr, 
       else
 	{
 	  visited[pred_bb] = 1;
-	  if (pre_expr_reaches_here_p (occr_bb, expr, pred_bb,
-				       check_pre_comp, visited))
+	  if (pre_expr_reaches_here_p_work (occr_bb, expr, pred_bb,
+				            check_pre_comp, visited))
 	    return 1;
 	}
     }
@@ -4230,6 +4223,35 @@ pre_expr_reaches_here_p (occr_bb, expr, 
   /* All paths have been checked.  */
   return 0;
 }
+
+/* The wrapper for pre_expr_reaches_here_work that ensures that any
+   memory allocated for that function is returned. */
+
+static int
+pre_expr_reaches_here_p (occr_bb, expr, bb, check_pre_comp, visited)
+     int occr_bb;
+     struct expr *expr;
+     int bb;
+     int check_pre_comp;
+     char *visited;
+{
+  int rval;
+  int visited_allocated_locally = 0;
+
+  if (visited == NULL)
+    {
+      visited = (char *) xcalloc (n_basic_blocks, 1);
+      visited_allocated_locally = 1;
+    }
+
+  rval = pre_expr_reaches_here_p_work(occr_bb, expr, bb, check_pre_comp, 
+				      visited);
+
+  if (visited_allocated_locally) 
+    free (visited);
+
+  return (rval);
+}
 
 
 /* Given an expr, generate RTL which we can insert at the end of a BB,
@@ -4719,8 +4741,7 @@ pre_gcse ()
   /* Compute a mapping from expression number (`bitmap_index') to
      hash table entry.  */
 
-  index_map = (struct expr **) alloca (n_exprs * sizeof (struct expr *));
-  bzero ((char *) index_map, n_exprs * sizeof (struct expr *));
+  index_map = xcalloc (n_exprs, sizeof (struct expr *));
   for (i = 0; i < expr_hash_table_size; i++)
     {
       struct expr *expr;
@@ -4749,6 +4770,7 @@ pre_gcse ()
       changed = 1;
     }
 
+  free (index_map);
   free (pre_redundant_insns);
 
   return changed;
@@ -4985,10 +5007,10 @@ delete_null_pointer_checks (f)
 
   /* We need predecessor/successor lists as well as pred/succ counts for
      each basic block.  */
-  s_preds = (int_list_ptr *) alloca (n_basic_blocks * sizeof (int_list_ptr));
-  s_succs = (int_list_ptr *) alloca (n_basic_blocks * sizeof (int_list_ptr));
-  num_preds = (int *) alloca (n_basic_blocks * sizeof (int));
-  num_succs = (int *) alloca (n_basic_blocks * sizeof (int));
+  s_preds = (int_list_ptr *) gmalloc (n_basic_blocks * sizeof (int_list_ptr));
+  s_succs = (int_list_ptr *) gmalloc (n_basic_blocks * sizeof (int_list_ptr));
+  num_preds = (int *) gmalloc (n_basic_blocks * sizeof (int));
+  num_succs = (int *) gmalloc (n_basic_blocks * sizeof (int));
   compute_preds_succs (s_preds, s_succs, num_preds, num_succs);
 
   /* Allocate bitmaps to hold local and global properties.  */
@@ -5141,6 +5163,12 @@ delete_null_pointer_checks (f)
   /* Free storage allocated by find_basic_blocks.  */
   free_basic_block_vars (0);
 
+  /* Free our local predecessor/successor lists. */
+  free (s_preds);
+  free (s_succs);
+  free (num_preds);
+  free (num_succs);
+
   /* Free bitmaps.  */
   free (nonnull_local);
   free (nonnull_killed);
@@ -5273,11 +5301,13 @@ hoist_expr_reaches_here_p (expr_bb, expr
      char *visited;
 {
   edge pred;
+  int visited_allocated_locally = 0;
+  
 
   if (visited == NULL)
     {
-      visited = (char *) alloca (n_basic_blocks);
-      bzero (visited, n_basic_blocks);
+       visited_allocated_locally = 1;
+       visited = xcalloc (n_basic_blocks, 1);
     }
 
   visited[expr_bb] = 1;
@@ -5303,7 +5333,8 @@ hoist_expr_reaches_here_p (expr_bb, expr
 	    break;
 	}
     }
-
+  if (visited_allocated_locally) 
+    free (visited);
   return (pred == NULL);
 }
 
@@ -5319,8 +5350,7 @@ hoist_code ()
   /* Compute a mapping from expression number (`bitmap_index') to
      hash table entry.  */
 
-  index_map = (struct expr **) alloca (n_exprs * sizeof (struct expr *));
-  bzero ((char *) index_map, n_exprs * sizeof (struct expr *));
+  index_map = xcalloc (n_exprs, sizeof (struct expr *));
   for (i = 0; i < expr_hash_table_size; i++)
     {
       struct expr *expr;
@@ -5473,6 +5503,7 @@ hoist_code ()
 	    }
 	}
     }
+    free (index_map);
 }
 
 /* Top level routine to perform one code hoisting (aka unification) pass