local-alloc.c (local_alloc): Use xmalloc/xcalloc, not alloca.

	* local-alloc.c (local_alloc): Use xmalloc/xcalloc, not alloca.
	(update_equiv_regs): Likewise.
	(block_alloc): Likewise.
	* reg-stack.c (reg_to_stack): Likewise.
	(convert_regs_2): Likewise.
	* reload1.c (reload_as_needed): Likewise.

From-SVN: r30434

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index ecca2e557754f2887212c21372179c446b1a5fb2..c511909523595c659f6f8485ae765510f45afb5c 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+Sat Nov  6 10:00:34 1999  Mark Mitchell  <mark@codesourcery.com>
+
+       * local-alloc.c (local_alloc): Use xmalloc/xcalloc, not alloca.
+       (update_equiv_regs): Likewise.
+       (block_alloc): Likewise.
+       * reg-stack.c (reg_to_stack): Likewise.
+       (convert_regs_2): Likewise.
+       * reload1.c (reload_as_needed): Likewise.
+       
 Sat Nov  6 09:57:59 1999  Mark Mitchell  <mark@codesourcery.com>
 
        * Makefile.in (dbxout.o): Depend on ggc.h.

diff --git a/gcc/local-alloc.c b/gcc/local-alloc.c
index a135cad07d7a73044ff688c4d55a792e7672c453..0e01668d11514be67711b49c17c9c556133298d4 100644 (file)
--- a/gcc/local-alloc.c
+++ b/gcc/local-alloc.c
@@ -411,9 +411,6 @@ local_alloc ()
       next_qty = 0;
 
       block_alloc (b);
-#ifdef USE_C_ALLOCA
-      alloca (0);
-#endif
     }
 
   free (qty_phys_reg);
@@ -687,17 +684,13 @@ update_equiv_regs ()
 {
   /* Set when an attempt should be made to replace a register with the
      associated reg_equiv_replacement entry at the end of this function.  */
-  char *reg_equiv_replace
-    = (char *) alloca (max_regno * sizeof *reg_equiv_replace);
+  char *reg_equiv_replace;
   rtx insn;
   int block, depth;
 
-  reg_equiv_init_insns = (rtx *) alloca (max_regno * sizeof (rtx));
-  reg_equiv_replacement = (rtx *) alloca (max_regno * sizeof (rtx));
-
-  bzero ((char *) reg_equiv_init_insns, max_regno * sizeof (rtx));
-  bzero ((char *) reg_equiv_replacement, max_regno * sizeof (rtx));
-  bzero ((char *) reg_equiv_replace, max_regno * sizeof *reg_equiv_replace);
+  reg_equiv_replace = (char *) xcalloc (max_regno, sizeof *reg_equiv_replace);
+  reg_equiv_init_insns = (rtx *) xcalloc (max_regno, sizeof (rtx));
+  reg_equiv_replacement = (rtx *) xcalloc (max_regno, sizeof (rtx));
 
   init_alias_analysis ();
 
@@ -1017,6 +1010,9 @@ update_equiv_regs ()
 
   /* Clean up.  */
   end_alias_analysis ();
+  free (reg_equiv_replace);
+  free (reg_equiv_init_insns);
+  free (reg_equiv_replacement);
 }
 
 /* Mark REG as having no known equivalence.
@@ -1080,9 +1076,8 @@ block_alloc (b)
 
   /* +2 to leave room for a post_mark_life at the last insn and for
      the birth of a CLOBBER in the first insn.  */
-  regs_live_at = (HARD_REG_SET *) alloca ((2 * insn_count + 2)
-                                         * sizeof (HARD_REG_SET));
-  bzero ((char *) regs_live_at, (2 * insn_count + 2) * sizeof (HARD_REG_SET));
+  regs_live_at = (HARD_REG_SET *) xcalloc ((2 * insn_count + 2),
+                                          sizeof (HARD_REG_SET));
 
   /* Initialize table of hardware registers currently live.  */
 
@@ -1321,7 +1316,7 @@ block_alloc (b)
      number of suggested registers they need so we allocate those with
      the most restrictive needs first.  */
 
-  qty_order = (int *) alloca (next_qty * sizeof (int));
+  qty_order = (int *) xmalloc (next_qty * sizeof (int));
   for (i = 0; i < next_qty; i++)
     qty_order[i] = i;
 
@@ -1491,6 +1486,10 @@ block_alloc (b)
        for (i = qty_first_reg[q]; i >= 0; i = reg_next_in_qty[i])
          reg_renumber[i] = qty_phys_reg[q] + reg_offset[i];
       }
+
+  /* Clean up.  */
+  free (regs_live_at);
+  free (qty_order);
 }
 \f
 /* Compare two quantities' priority for getting real registers.

diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c
index ec7d06997cc7a0680e1975ddc344b5eb8fc619e6..98b877867455f5b945aeef5c474c83527bc15411 100644 (file)
--- a/gcc/reg-stack.c
+++ b/gcc/reg-stack.c
@@ -435,8 +435,7 @@ reg_to_stack (first, file)
   life_analysis (first, max_reg_num (), file, 0);
 
   /* Set up block info for each basic block.  */
-  bi = (block_info) alloca ((n_basic_blocks + 1) * sizeof (*bi));
-  memset (bi, 0, (n_basic_blocks + 1) * sizeof (*bi));
+  bi = (block_info) xcalloc ((n_basic_blocks + 1), sizeof (*bi));
   for (i = n_basic_blocks - 1; i >= 0; --i)
     BASIC_BLOCK (i)->aux = bi + i;
   EXIT_BLOCK_PTR->aux = bi + n_basic_blocks;
@@ -483,7 +482,9 @@ reg_to_stack (first, file)
                     !JUMP_NOOP_MOVES, !JUMP_AFTER_REGSCAN);
     }
 
+  /* Clean up.  */
   VARRAY_FREE (stack_regs_mentioned_data);
+  free (bi);
 }
 \f
 /* Check PAT, which is in INSN, for LABEL_REFs.  Add INSN to the
@@ -2616,7 +2617,7 @@ convert_regs_2 (file, block)
   basic_block *stack, *sp;
   int inserted;
 
-  stack = (basic_block *) alloca (sizeof (*stack) * n_basic_blocks);
+  stack = (basic_block *) xmalloc (sizeof (*stack) * n_basic_blocks);
   sp = stack;
 
   *sp++ = block;

diff --git a/gcc/reload1.c b/gcc/reload1.c
index 2f50fb33c4d78d160ceb9b16578bbed18ac5e855..3526ae9f134a4a6e0b915311e42364bbecff033b 100644 (file)
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -4309,9 +4309,8 @@ reload_as_needed (live_known)
 
   bzero ((char *) spill_reg_rtx, sizeof spill_reg_rtx);
   bzero ((char *) spill_reg_store, sizeof spill_reg_store);
-  reg_last_reload_reg = (rtx *) alloca (max_regno * sizeof (rtx));
-  bzero ((char *) reg_last_reload_reg, max_regno * sizeof (rtx));
-  reg_has_output_reload = (char *) alloca (max_regno);
+  reg_last_reload_reg = (rtx *) xcalloc (max_regno, sizeof (rtx));
+  reg_has_output_reload = (char *) xmalloc (max_regno);
   CLEAR_HARD_REG_SET (reg_reloaded_valid);
 
   set_initial_elim_offsets ();
@@ -4573,11 +4572,11 @@ reload_as_needed (live_known)
            && INSN_CLOBBERS_REGNO_P (insn, i))
          CLEAR_HARD_REG_BIT (reg_reloaded_valid, i);
 #endif
-
-#ifdef USE_C_ALLOCA
-      alloca (0);
-#endif
     }
+
+  /* Clean up.  */
+  free (reg_last_reload_reg);
+  free (reg_has_output_reload);
 }
 
 /* Discard all record of any value reloaded from X,