bitmap.h (BITMAP_XMALLOC): New macro.

* bitmap.h (BITMAP_XMALLOC): New macro.
	* flow.c (CLEAN_ALLOCA): Remove.
	(delete_unreachable_blocks): Use xmalloc/xcalloc instead of alloca.
	(life_analysis): Likewise.
	(update_life_info): Don't use CLEAN_ALLOCA.
	(life_analysis_1): Use xmalloc/xcalloc instead of alloca.
	(calculate_global_regs_live): Likewise.
	(print_rtl_with_bb): Likewise.
	(verify_flow_info): Likewise.
	* global.c (global_alloc): Likewise.
	(global_conflicts): Likewise.
	* integrate.c (save_for_inline_nocopy): Likewise.
	(expand_inline_function): Likewise.
	* jump.c (jump_optimize_1): Likewise.
	(duplicate_loop_exit_test): Likewise.
	(thread_jumps): Likewise.
	* loop.c (loop_optimize): Likewise.
	(combine_givs): Likewise.
	(recombine_givs): Likewise.
	* reorg.c (dbr_schedule): Likewise.
	* unroll.c (unroll_loop): Likewise.

From-SVN: r30333
This commit is contained in:
Mark Mitchell 1999-11-01 23:19:44 +00:00 committed by Mark Mitchell
parent 20bbd3cd53
commit 67289ea639
9 changed files with 194 additions and 127 deletions

View File

@ -1,5 +1,26 @@
Mon Nov 1 15:41:01 1999 Mark P. Mitchell <mark@codesourcery.com> Mon Nov 1 15:41:01 1999 Mark P. Mitchell <mark@codesourcery.com>
* bitmap.h (BITMAP_XMALLOC): New macro.
* flow.c (CLEAN_ALLOCA): Remove.
(delete_unreachable_blocks): Use xmalloc/xcalloc instead of alloca.
(life_analysis): Likewise.
(update_life_info): Don't use CLEAN_ALLOCA.
(life_analysis_1): Use xmalloc/xcalloc instead of alloca.
(calculate_global_regs_live): Likewise.
(print_rtl_with_bb): Likewise.
(verify_flow_info): Likewise.
* global.c (global_alloc): Likewise.
(global_conflicts): Likewise.
* integrate.c (save_for_inline_nocopy): Likewise.
(expand_inline_function): Likewise.
* jump.c (jump_optimize_1): Likewise.
(duplicate_loop_exit_test): Likewise.
(thread_jumps): Likewise.
* loop.c (loop_optimize): Likewise.
(combine_givs): Likewise.
(recombine_givs): Likewise.
* reorg.c (dbr_schedule): Likewise.
* combine.c (combine_instructions): Use xmalloc instead of alloca. * combine.c (combine_instructions): Use xmalloc instead of alloca.
Mon Nov 1 13:22:30 1999 Richard Henderson <rth@cygnus.com> Mon Nov 1 13:22:30 1999 Richard Henderson <rth@cygnus.com>

View File

@ -114,6 +114,10 @@ extern void debug_bitmap PROTO((bitmap));
#define BITMAP_ALLOCA() \ #define BITMAP_ALLOCA() \
bitmap_initialize ((bitmap) alloca (sizeof (bitmap_head))) bitmap_initialize ((bitmap) alloca (sizeof (bitmap_head)))
/* Allocate a bitmap with xmalloc. */
#define BITMAP_XMALLOC() \
bitmap_initialize ((bitmap) xmalloc (sizeof (bitmap_head)))
/* Do any cleanup needed on a bitmap when it is no longer used. */ /* Do any cleanup needed on a bitmap when it is no longer used. */
#define BITMAP_FREE(BITMAP) \ #define BITMAP_FREE(BITMAP) \
do { \ do { \

View File

@ -157,13 +157,6 @@ Boston, MA 02111-1307, USA. */
#define HAVE_prologue 0 #define HAVE_prologue 0
#endif #endif
#ifdef USE_C_ALLOCA
#define CLEAN_ALLOCA alloca (0)
#else
#define CLEAN_ALLOCA
#endif
/* The contents of the current function definition are allocated /* The contents of the current function definition are allocated
in this obstack, and all are freed at the end of the function. in this obstack, and all are freed at the end of the function.
For top-level functions, this is temporary_obstack. For top-level functions, this is temporary_obstack.
@ -1668,7 +1661,7 @@ delete_unreachable_blocks ()
int i, n; int i, n;
n = n_basic_blocks; n = n_basic_blocks;
tos = worklist = (basic_block *) alloca (sizeof (basic_block) * n); tos = worklist = (basic_block *) xmalloc (sizeof (basic_block) * n);
/* Use basic_block->aux as a marker. Clear them all. */ /* Use basic_block->aux as a marker. Clear them all. */
@ -1752,6 +1745,8 @@ delete_unreachable_blocks ()
blocks to remove as well. */ blocks to remove as well. */
if (deleted_handler) if (deleted_handler)
delete_eh_regions (); delete_eh_regions ();
free (worklist);
} }
/* Find EH regions for which there is no longer a handler, and delete them. */ /* Find EH regions for which there is no longer a handler, and delete them. */
@ -2453,7 +2448,7 @@ life_analysis (f, nregs, file, remove_dead_code)
#endif #endif
/* Allocate a bitmap to be filled in by record_volatile_insns. */ /* Allocate a bitmap to be filled in by record_volatile_insns. */
uid_volatile = BITMAP_ALLOCA (); uid_volatile = BITMAP_XMALLOC ();
/* We want alias analysis information for local dead store elimination. */ /* We want alias analysis information for local dead store elimination. */
init_alias_analysis (); init_alias_analysis ();
@ -2472,6 +2467,7 @@ life_analysis (f, nregs, file, remove_dead_code)
dump_flow_info (file); dump_flow_info (file);
BITMAP_FREE (uid_volatile); BITMAP_FREE (uid_volatile);
free (uid_volatile);
free_basic_block_vars (1); free_basic_block_vars (1);
} }
@ -2601,8 +2597,6 @@ update_life_info (blocks, extent, prop_flags)
if (extent == UPDATE_LIFE_LOCAL) if (extent == UPDATE_LIFE_LOCAL)
verify_local_live_at_start (tmp, bb); verify_local_live_at_start (tmp, bb);
CLEAN_ALLOCA;
}); });
FREE_REG_SET (tmp); FREE_REG_SET (tmp);
@ -2916,8 +2910,7 @@ life_analysis_1 (f, nregs, flags)
allocate_reg_life_data (); allocate_reg_life_data ();
allocate_bb_life_data (); allocate_bb_life_data ();
reg_next_use = (rtx *) alloca (nregs * sizeof (rtx)); reg_next_use = (rtx *) xcalloc (nregs, sizeof (rtx));
memset (reg_next_use, 0, nregs * sizeof (rtx));
/* Assume that the stack pointer is unchanging if alloca hasn't been used. /* Assume that the stack pointer is unchanging if alloca hasn't been used.
This will be cleared by record_volatile_insns if it encounters an insn This will be cleared by record_volatile_insns if it encounters an insn
@ -2971,8 +2964,6 @@ life_analysis_1 (f, nregs, flags)
COPY_REG_SET (tmp, bb->global_live_at_end); COPY_REG_SET (tmp, bb->global_live_at_end);
propagate_block (tmp, bb->head, bb->end, (regset) NULL, i, flags); propagate_block (tmp, bb->head, bb->end, (regset) NULL, i, flags);
CLEAN_ALLOCA;
} }
FREE_REG_SET (tmp); FREE_REG_SET (tmp);
@ -3000,6 +2991,8 @@ life_analysis_1 (f, nregs, flags)
if (reload_completed) if (reload_completed)
memcpy (regs_ever_live, save_regs_ever_live, sizeof (regs_ever_live)); memcpy (regs_ever_live, save_regs_ever_live, sizeof (regs_ever_live));
/* Clean up. */
free (reg_next_use);
reg_next_use = NULL; reg_next_use = NULL;
} }
@ -3022,7 +3015,7 @@ calculate_global_regs_live (blocks_in, blocks_out, flags)
/* Create a worklist. Allocate an extra slot for ENTRY_BLOCK, and one /* Create a worklist. Allocate an extra slot for ENTRY_BLOCK, and one
because the `head == tail' style test for an empty queue doesn't because the `head == tail' style test for an empty queue doesn't
work with a full queue. */ work with a full queue. */
queue = (basic_block *) alloca ((n_basic_blocks + 2) * sizeof (*queue)); queue = (basic_block *) xmalloc ((n_basic_blocks + 2) * sizeof (*queue));
qtail = queue; qtail = queue;
qhead = qend = queue + n_basic_blocks + 2; qhead = qend = queue + n_basic_blocks + 2;
@ -3158,6 +3151,8 @@ calculate_global_regs_live (blocks_in, blocks_out, flags)
basic_block bb = BASIC_BLOCK (i); basic_block bb = BASIC_BLOCK (i);
FREE_REG_SET (bb->local_set); FREE_REG_SET (bb->local_set);
}); });
free (queue);
} }
/* Subroutines of life analysis. */ /* Subroutines of life analysis. */
@ -5069,15 +5064,11 @@ print_rtl_with_bb (outf, rtx_first)
enum bb_state { NOT_IN_BB, IN_ONE_BB, IN_MULTIPLE_BB }; enum bb_state { NOT_IN_BB, IN_ONE_BB, IN_MULTIPLE_BB };
int max_uid = get_max_uid (); int max_uid = get_max_uid ();
basic_block *start = (basic_block *) basic_block *start = (basic_block *)
alloca (max_uid * sizeof (basic_block)); xcalloc (max_uid, sizeof (basic_block));
basic_block *end = (basic_block *) basic_block *end = (basic_block *)
alloca (max_uid * sizeof (basic_block)); xcalloc (max_uid, sizeof (basic_block));
enum bb_state *in_bb_p = (enum bb_state *) enum bb_state *in_bb_p = (enum bb_state *)
alloca (max_uid * sizeof (enum bb_state)); xcalloc (max_uid, sizeof (enum bb_state));
memset (start, 0, max_uid * sizeof (basic_block));
memset (end, 0, max_uid * sizeof (basic_block));
memset (in_bb_p, 0, max_uid * sizeof (enum bb_state));
for (i = n_basic_blocks - 1; i >= 0; i--) for (i = n_basic_blocks - 1; i >= 0; i--)
{ {
@ -5134,6 +5125,10 @@ print_rtl_with_bb (outf, rtx_first)
if (did_output) if (did_output)
putc ('\n', outf); putc ('\n', outf);
} }
free (start);
free (end);
free (in_bb_p);
} }
if (current_function_epilogue_delay_list != 0) if (current_function_epilogue_delay_list != 0)
@ -5878,8 +5873,7 @@ verify_flow_info ()
rtx x; rtx x;
int i, err = 0; int i, err = 0;
bb_info = (basic_block *) alloca (max_uid * sizeof (basic_block)); bb_info = (basic_block *) xcalloc (max_uid, sizeof (basic_block));
memset (bb_info, 0, max_uid * sizeof (basic_block));
/* First pass check head/end pointers and set bb_info array used by /* First pass check head/end pointers and set bb_info array used by
later passes. */ later passes. */
@ -6074,6 +6068,9 @@ verify_flow_info ()
if (err) if (err)
abort (); abort ();
/* Clean up. */
free (bb_info);
} }
/* Functions to access an edge list with a vector representation. /* Functions to access an edge list with a vector representation.

View File

@ -372,15 +372,14 @@ global_alloc (file)
/* Establish mappings from register number to allocation number /* Establish mappings from register number to allocation number
and vice versa. In the process, count the allocnos. */ and vice versa. In the process, count the allocnos. */
reg_allocno = (int *) alloca (max_regno * sizeof (int)); reg_allocno = (int *) xmalloc (max_regno * sizeof (int));
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
reg_allocno[i] = -1; reg_allocno[i] = -1;
/* Initialize the shared-hard-reg mapping /* Initialize the shared-hard-reg mapping
from the list of pairs that may share. */ from the list of pairs that may share. */
reg_may_share = (int *) alloca (max_regno * sizeof (int)); reg_may_share = (int *) xcalloc (max_regno, sizeof (int));
bzero ((char *) reg_may_share, max_regno * sizeof (int));
for (x = regs_may_share; x; x = XEXP (XEXP (x, 1), 1)) for (x = regs_may_share; x; x = XEXP (XEXP (x, 1), 1))
{ {
int r1 = REGNO (XEXP (x, 0)); int r1 = REGNO (XEXP (x, 0));
@ -411,15 +410,11 @@ global_alloc (file)
else else
reg_allocno[i] = -1; reg_allocno[i] = -1;
allocno_reg = (int *) alloca (max_allocno * sizeof (int)); allocno_reg = (int *) xmalloc (max_allocno * sizeof (int));
allocno_size = (int *) alloca (max_allocno * sizeof (int)); allocno_size = (int *) xcalloc (max_allocno, sizeof (int));
allocno_calls_crossed = (int *) alloca (max_allocno * sizeof (int)); allocno_calls_crossed = (int *) xcalloc (max_allocno, sizeof (int));
allocno_n_refs = (int *) alloca (max_allocno * sizeof (int)); allocno_n_refs = (int *) xcalloc (max_allocno, sizeof (int));
allocno_live_length = (int *) alloca (max_allocno * sizeof (int)); allocno_live_length = (int *) xcalloc (max_allocno, sizeof (int));
bzero ((char *) allocno_size, max_allocno * sizeof (int));
bzero ((char *) allocno_calls_crossed, max_allocno * sizeof (int));
bzero ((char *) allocno_n_refs, max_allocno * sizeof (int));
bzero ((char *) allocno_live_length, max_allocno * sizeof (int));
for (i = FIRST_PSEUDO_REGISTER; i < (size_t) max_regno; i++) for (i = FIRST_PSEUDO_REGISTER; i < (size_t) max_regno; i++)
if (reg_allocno[i] >= 0) if (reg_allocno[i] >= 0)
@ -461,26 +456,15 @@ global_alloc (file)
initialize them. */ initialize them. */
hard_reg_conflicts hard_reg_conflicts
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET)); = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET));
bzero ((char *) hard_reg_conflicts, max_allocno * sizeof (HARD_REG_SET));
hard_reg_preferences hard_reg_preferences
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET)); = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET));
bzero ((char *) hard_reg_preferences, max_allocno * sizeof (HARD_REG_SET));
hard_reg_copy_preferences hard_reg_copy_preferences
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET)); = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET));
bzero ((char *) hard_reg_copy_preferences,
max_allocno * sizeof (HARD_REG_SET));
hard_reg_full_preferences hard_reg_full_preferences
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET)); = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET));
bzero ((char *) hard_reg_full_preferences,
max_allocno * sizeof (HARD_REG_SET));
regs_someone_prefers regs_someone_prefers
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET)); = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET));
bzero ((char *) regs_someone_prefers, max_allocno * sizeof (HARD_REG_SET));
allocno_row_words = (max_allocno + INT_BITS - 1) / INT_BITS; allocno_row_words = (max_allocno + INT_BITS - 1) / INT_BITS;
@ -490,7 +474,7 @@ global_alloc (file)
conflicts = (INT_TYPE *) xcalloc (max_allocno * allocno_row_words, conflicts = (INT_TYPE *) xcalloc (max_allocno * allocno_row_words,
sizeof (INT_TYPE)); sizeof (INT_TYPE));
allocnos_live = (INT_TYPE *) alloca (allocno_row_words * sizeof (INT_TYPE)); allocnos_live = (INT_TYPE *) xmalloc (allocno_row_words * sizeof (INT_TYPE));
/* If there is work to be done (at least one reg to allocate), /* If there is work to be done (at least one reg to allocate),
perform global conflict analysis and allocate the regs. */ perform global conflict analysis and allocate the regs. */
@ -523,7 +507,7 @@ global_alloc (file)
/* Determine the order to allocate the remaining pseudo registers. */ /* Determine the order to allocate the remaining pseudo registers. */
allocno_order = (int *) alloca (max_allocno * sizeof (int)); allocno_order = (int *) xmalloc (max_allocno * sizeof (int));
for (i = 0; i < (size_t) max_allocno; i++) for (i = 0; i < (size_t) max_allocno; i++)
allocno_order[i] = i; allocno_order[i] = i;
@ -568,6 +552,8 @@ global_alloc (file)
if (reg_alternate_class (allocno_reg[allocno_order[i]]) != NO_REGS) if (reg_alternate_class (allocno_reg[allocno_order[i]]) != NO_REGS)
find_reg (allocno_order[i], 0, 1, 0, 0); find_reg (allocno_order[i], 0, 1, 0, 0);
} }
free (allocno_order);
} }
/* Do the reloads now while the allocno data still exist, so that we can /* Do the reloads now while the allocno data still exist, so that we can
@ -582,7 +568,22 @@ global_alloc (file)
retval = reload (get_insns (), 1, file); retval = reload (get_insns (), 1, file);
} }
/* Clean up. */
free (reg_allocno);
free (reg_may_share);
free (allocno_reg);
free (allocno_size);
free (allocno_calls_crossed);
free (allocno_n_refs);
free (allocno_live_length);
free (hard_reg_conflicts);
free (hard_reg_preferences);
free (hard_reg_copy_preferences);
free (hard_reg_full_preferences);
free (regs_someone_prefers);
free (conflicts); free (conflicts);
free (allocnos_live);
return retval; return retval;
} }
@ -626,9 +627,9 @@ global_conflicts ()
int *block_start_allocnos; int *block_start_allocnos;
/* Make a vector that mark_reg_{store,clobber} will store in. */ /* Make a vector that mark_reg_{store,clobber} will store in. */
regs_set = (rtx *) alloca (max_parallel * sizeof (rtx) * 2); regs_set = (rtx *) xmalloc (max_parallel * sizeof (rtx) * 2);
block_start_allocnos = (int *) alloca (max_allocno * sizeof (int)); block_start_allocnos = (int *) xmalloc (max_allocno * sizeof (int));
for (b = 0; b < n_basic_blocks; b++) for (b = 0; b < n_basic_blocks; b++)
{ {
@ -788,6 +789,10 @@ global_conflicts ()
insn = NEXT_INSN (insn); insn = NEXT_INSN (insn);
} }
} }
/* Clean up. */
free (block_start_allocnos);
free (regs_set);
} }
/* Expand the preference information by looking for cases where one allocno /* Expand the preference information by looking for cases where one allocno
dies in an insn that sets an allocno. If those two allocnos don't conflict, dies in an insn that sets an allocno. If those two allocnos don't conflict,

View File

@ -350,7 +350,7 @@ save_for_inline_nocopy (fndecl)
for the parms, prior to elimination of virtual registers. for the parms, prior to elimination of virtual registers.
These values are needed for substituting parms properly. */ These values are needed for substituting parms properly. */
parmdecl_map = (tree *) alloca (max_parm_reg * sizeof (tree)); parmdecl_map = (tree *) xmalloc (max_parm_reg * sizeof (tree));
/* Make and emit a return-label if we have not already done so. */ /* Make and emit a return-label if we have not already done so. */
@ -401,6 +401,9 @@ save_for_inline_nocopy (fndecl)
current_function->original_arg_vector = argvec; current_function->original_arg_vector = argvec;
current_function->original_decl_initial = DECL_INITIAL (fndecl); current_function->original_decl_initial = DECL_INITIAL (fndecl);
DECL_SAVED_INSNS (fndecl) = current_function; DECL_SAVED_INSNS (fndecl) = current_function;
/* Clean up. */
free (parmdecl_map);
} }
/* Note whether a parameter is modified or not. */ /* Note whether a parameter is modified or not. */
@ -566,8 +569,8 @@ expand_inline_function (fndecl, parms, target, ignore, type,
/* Expand the function arguments. Do this first so that any /* Expand the function arguments. Do this first so that any
new registers get created before we allocate the maps. */ new registers get created before we allocate the maps. */
arg_vals = (rtx *) alloca (nargs * sizeof (rtx)); arg_vals = (rtx *) xmalloc (nargs * sizeof (rtx));
arg_trees = (tree *) alloca (nargs * sizeof (tree)); arg_trees = (tree *) xmalloc (nargs * sizeof (tree));
for (formal = DECL_ARGUMENTS (fndecl), actual = parms, i = 0; for (formal = DECL_ARGUMENTS (fndecl), actual = parms, i = 0;
formal; formal;
@ -649,11 +652,10 @@ expand_inline_function (fndecl, parms, target, ignore, type,
/* Allocate the structures we use to remap things. */ /* Allocate the structures we use to remap things. */
map = (struct inline_remap *) alloca (sizeof (struct inline_remap)); map = (struct inline_remap *) xmalloc (sizeof (struct inline_remap));
map->fndecl = fndecl; map->fndecl = fndecl;
map->reg_map = (rtx *) alloca (max_regno * sizeof (rtx)); map->reg_map = (rtx *) xcalloc (max_regno, sizeof (rtx));
bzero ((char *) map->reg_map, max_regno * sizeof (rtx));
/* We used to use alloca here, but the size of what it would try to /* We used to use alloca here, but the size of what it would try to
allocate would occasionally cause it to exceed the stack limit and allocate would occasionally cause it to exceed the stack limit and
@ -663,8 +665,7 @@ expand_inline_function (fndecl, parms, target, ignore, type,
map->label_map = real_label_map; map->label_map = real_label_map;
inl_max_uid = (inl_f->emit->x_cur_insn_uid + 1); inl_max_uid = (inl_f->emit->x_cur_insn_uid + 1);
map->insn_map = (rtx *) alloca (inl_max_uid * sizeof (rtx)); map->insn_map = (rtx *) xcalloc (inl_max_uid, sizeof (rtx));
bzero ((char *) map->insn_map, inl_max_uid * sizeof (rtx));
map->min_insnno = 0; map->min_insnno = 0;
map->max_insnno = inl_max_uid; map->max_insnno = inl_max_uid;
@ -1356,8 +1357,13 @@ expand_inline_function (fndecl, parms, target, ignore, type,
/* Make sure we free the things we explicitly allocated with xmalloc. */ /* Make sure we free the things we explicitly allocated with xmalloc. */
if (real_label_map) if (real_label_map)
free (real_label_map); free (real_label_map);
if (map)
VARRAY_FREE (map->const_equiv_varray); VARRAY_FREE (map->const_equiv_varray);
free (map->reg_map);
free (map->insn_map);
free (map);
free (arg_vals);
free (arg_trees);
inlining = inlining_previous; inlining = inlining_previous;
return target; return target;

View File

@ -205,8 +205,7 @@ jump_optimize_1 (f, cross_jump, noop_moves, after_regscan, mark_labels_only)
/* Leave some extra room for labels and duplicate exit test insns /* Leave some extra room for labels and duplicate exit test insns
we make. */ we make. */
max_jump_chain = max_uid * 14 / 10; max_jump_chain = max_uid * 14 / 10;
jump_chain = (rtx *) alloca (max_jump_chain * sizeof (rtx)); jump_chain = (rtx *) xcalloc (max_jump_chain, sizeof (rtx));
bzero ((char *) jump_chain, max_jump_chain * sizeof (rtx));
mark_all_labels (f, cross_jump); mark_all_labels (f, cross_jump);
@ -227,7 +226,7 @@ jump_optimize_1 (f, cross_jump, noop_moves, after_regscan, mark_labels_only)
/* Quit now if we just wanted to rebuild the JUMP_LABEL and REG_LABEL /* Quit now if we just wanted to rebuild the JUMP_LABEL and REG_LABEL
notes and recompute LABEL_NUSES. */ notes and recompute LABEL_NUSES. */
if (mark_labels_only) if (mark_labels_only)
return; goto end;
exception_optimize (); exception_optimize ();
@ -246,9 +245,7 @@ jump_optimize_1 (f, cross_jump, noop_moves, after_regscan, mark_labels_only)
for (insn = f; insn; insn = NEXT_INSN (insn)) for (insn = f; insn; insn = NEXT_INSN (insn))
INSN_DELETED_P (insn) = 0; INSN_DELETED_P (insn) = 0;
/* Show that the jump chain is not valid. */ goto end;
jump_chain = 0;
return;
} }
#ifdef HAVE_return #ifdef HAVE_return
@ -2301,7 +2298,9 @@ jump_optimize_1 (f, cross_jump, noop_moves, after_regscan, mark_labels_only)
if (calculate_can_reach_end (last_insn, 0, 1)) if (calculate_can_reach_end (last_insn, 0, 1))
can_reach_end = 1; can_reach_end = 1;
/* Show JUMP_CHAIN no longer valid. */ end:
/* Clean up. */
free (jump_chain);
jump_chain = 0; jump_chain = 0;
} }
@ -2872,10 +2871,7 @@ duplicate_loop_exit_test (loop_start)
/* We can do the replacement. Allocate reg_map if this is the /* We can do the replacement. Allocate reg_map if this is the
first replacement we found. */ first replacement we found. */
if (reg_map == 0) if (reg_map == 0)
{ reg_map = (rtx *) xcalloc (max_reg, sizeof (rtx));
reg_map = (rtx *) alloca (max_reg * sizeof (rtx));
bzero ((char *) reg_map, max_reg * sizeof (rtx));
}
REG_LOOP_TEST_P (reg) = 1; REG_LOOP_TEST_P (reg) = 1;
@ -2987,6 +2983,10 @@ duplicate_loop_exit_test (loop_start)
delete_insn (next_nonnote_insn (loop_start)); delete_insn (next_nonnote_insn (loop_start));
/* Clean up. */
if (reg_map)
free (reg_map);
return 1; return 1;
} }
@ -5182,9 +5182,9 @@ thread_jumps (f, max_reg, flag_before_loop)
int *all_reset; int *all_reset;
/* Allocate register tables and quick-reset table. */ /* Allocate register tables and quick-reset table. */
modified_regs = (char *) alloca (max_reg * sizeof (char)); modified_regs = (char *) xmalloc (max_reg * sizeof (char));
same_regs = (int *) alloca (max_reg * sizeof (int)); same_regs = (int *) xmalloc (max_reg * sizeof (int));
all_reset = (int *) alloca (max_reg * sizeof (int)); all_reset = (int *) xmalloc (max_reg * sizeof (int));
for (i = 0; i < max_reg; i++) for (i = 0; i < max_reg; i++)
all_reset[i] = -1; all_reset[i] = -1;
@ -5342,6 +5342,11 @@ thread_jumps (f, max_reg, flag_before_loop)
} }
} }
} }
/* Clean up. */
free (modified_regs);
free (same_regs);
free (all_reset);
} }
/* This is like RTX_EQUAL_P except that it knows about our handling of /* This is like RTX_EQUAL_P except that it knows about our handling of

View File

@ -464,9 +464,6 @@ loop_optimize (f, dumpfile, unroll_p, bct_p)
max_reg_before_loop = max_reg_num (); max_reg_before_loop = max_reg_num ();
moved_once = (char *) alloca (max_reg_before_loop);
bzero (moved_once, max_reg_before_loop);
regs_may_share = 0; regs_may_share = 0;
/* Count the number of loops. */ /* Count the number of loops. */
@ -483,31 +480,29 @@ loop_optimize (f, dumpfile, unroll_p, bct_p)
if (max_loop_num == 0) if (max_loop_num == 0)
return; return;
moved_once = (char *) xcalloc (max_reg_before_loop, sizeof (char));
/* Get size to use for tables indexed by uids. /* Get size to use for tables indexed by uids.
Leave some space for labels allocated by find_and_verify_loops. */ Leave some space for labels allocated by find_and_verify_loops. */
max_uid_for_loop = get_max_uid () + 1 + max_loop_num * 32; max_uid_for_loop = get_max_uid () + 1 + max_loop_num * 32;
uid_luid = (int *) alloca (max_uid_for_loop * sizeof (int)); uid_luid = (int *) xcalloc (max_uid_for_loop, sizeof (int));
uid_loop_num = (int *) alloca (max_uid_for_loop * sizeof (int)); uid_loop_num = (int *) xcalloc (max_uid_for_loop, sizeof (int));
bzero ((char *) uid_luid, max_uid_for_loop * sizeof (int));
bzero ((char *) uid_loop_num, max_uid_for_loop * sizeof (int));
/* Allocate tables for recording each loop. We set each entry, so they need /* Allocate tables for recording each loop. We set each entry, so they need
not be zeroed. */ not be zeroed. */
loop_number_loop_starts = (rtx *) alloca (max_loop_num * sizeof (rtx)); loop_number_loop_starts = (rtx *) xmalloc (max_loop_num * sizeof (rtx));
loop_number_loop_ends = (rtx *) alloca (max_loop_num * sizeof (rtx)); loop_number_loop_ends = (rtx *) xmalloc (max_loop_num * sizeof (rtx));
loop_number_loop_cont = (rtx *) alloca (max_loop_num * sizeof (rtx)); loop_number_loop_cont = (rtx *) xmalloc (max_loop_num * sizeof (rtx));
loop_number_cont_dominator = (rtx *) alloca (max_loop_num * sizeof (rtx)); loop_number_cont_dominator = (rtx *) xmalloc (max_loop_num * sizeof (rtx));
loop_outer_loop = (int *) alloca (max_loop_num * sizeof (int)); loop_outer_loop = (int *) xmalloc (max_loop_num * sizeof (int));
loop_invalid = (char *) alloca (max_loop_num * sizeof (char)); loop_invalid = (char *) xmalloc (max_loop_num * sizeof (char));
loop_number_exit_labels = (rtx *) alloca (max_loop_num * sizeof (rtx)); loop_number_exit_labels = (rtx *) xmalloc (max_loop_num * sizeof (rtx));
loop_number_exit_count = (int *) alloca (max_loop_num * sizeof (int)); loop_number_exit_count = (int *) xmalloc (max_loop_num * sizeof (int));
#ifdef HAVE_decrement_and_branch_on_count #ifdef HAVE_decrement_and_branch_on_count
/* Allocate for BCT optimization */ /* Allocate for BCT optimization */
loop_used_count_register = (int *) alloca (max_loop_num * sizeof (int)); loop_used_count_register = (int *) xcalloc (max_loop_num, sizeof (int));
bzero ((char *) loop_used_count_register, max_loop_num * sizeof (int));
#endif /* HAVE_decrement_and_branch_on_count */ #endif /* HAVE_decrement_and_branch_on_count */
/* Find and process each loop. /* Find and process each loop.
@ -574,6 +569,23 @@ loop_optimize (f, dumpfile, unroll_p, bct_p)
unroll_block_trees (); unroll_block_trees ();
end_alias_analysis (); end_alias_analysis ();
/* Clean up. */
free (moved_once);
free (uid_luid);
free (uid_loop_num);
free (loop_number_loop_starts);
free (loop_number_loop_ends);
free (loop_number_loop_cont);
free (loop_number_cont_dominator);
free (loop_outer_loop);
free (loop_invalid);
free (loop_number_exit_labels);
free (loop_number_exit_count);
#ifdef HAVE_decrement_and_branch_on_count
free (loop_used_count_register);
#endif /* HAVE_decrement_and_branch_on_count */
} }
/* Returns the next insn, in execution order, after INSN. START and /* Returns the next insn, in execution order, after INSN. START and
@ -7116,11 +7128,8 @@ combine_givs (bl)
if (!g1->ignore) if (!g1->ignore)
giv_array[i++] = g1; giv_array[i++] = g1;
stats = (struct combine_givs_stats *) alloca (giv_count * sizeof (*stats)); stats = (struct combine_givs_stats *) xcalloc (giv_count, sizeof (*stats));
bzero ((char *) stats, giv_count * sizeof (*stats)); can_combine = (rtx *) xcalloc (giv_count, giv_count * sizeof(rtx));
can_combine = (rtx *) alloca (giv_count * giv_count * sizeof(rtx));
bzero ((char *) can_combine, giv_count * giv_count * sizeof(rtx));
for (i = 0; i < giv_count; i++) for (i = 0; i < giv_count; i++)
{ {
@ -7250,6 +7259,10 @@ restart:
goto restart; goto restart;
} }
} }
/* Clean up. */
free (stats);
free (can_combine);
} }
struct recombine_givs_stats struct recombine_givs_stats
@ -7387,8 +7400,8 @@ recombine_givs (bl, loop_start, loop_end, unroll_p)
giv_count++; giv_count++;
} }
giv_array giv_array
= (struct induction **) alloca (giv_count * sizeof (struct induction *)); = (struct induction **) xmalloc (giv_count * sizeof (struct induction *));
stats = (struct recombine_givs_stats *) alloca (giv_count * sizeof *stats); stats = (struct recombine_givs_stats *) xmalloc (giv_count * sizeof *stats);
/* Initialize stats and set up the ix field for each giv in stats to name /* Initialize stats and set up the ix field for each giv in stats to name
the corresponding index into stats. */ the corresponding index into stats. */
@ -7679,6 +7692,10 @@ recombine_givs (bl, loop_start, loop_end, unroll_p)
rescan = i; rescan = i;
} }
} }
/* Clean up. */
free (giv_array);
free (stats);
} }
/* EMIT code before INSERT_BEFORE to set REG = B * M + A. */ /* EMIT code before INSERT_BEFORE to set REG = B * M + A. */

View File

@ -3531,7 +3531,7 @@ dbr_schedule (first, file)
epilogue_insn = insn; epilogue_insn = insn;
} }
uid_to_ruid = (int *) alloca ((max_uid + 1) * sizeof (int)); uid_to_ruid = (int *) xmalloc ((max_uid + 1) * sizeof (int));
for (i = 0, insn = first; insn; i++, insn = NEXT_INSN (insn)) for (i = 0, insn = first; insn; i++, insn = NEXT_INSN (insn))
uid_to_ruid[INSN_UID (insn)] = i; uid_to_ruid[INSN_UID (insn)] = i;
@ -3676,5 +3676,6 @@ dbr_schedule (first, file)
REG_NOTES (insn)); REG_NOTES (insn));
} }
free_resource_info (); free_resource_info ();
free (uid_to_ruid);
} }
#endif /* DELAY_SLOTS */ #endif /* DELAY_SLOTS */

View File

@ -682,7 +682,7 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
max_labelno = max_label_num (); max_labelno = max_label_num ();
max_insnno = get_max_uid (); max_insnno = get_max_uid ();
map = (struct inline_remap *) alloca (sizeof (struct inline_remap)); map = (struct inline_remap *) xmalloc (sizeof (struct inline_remap));
map->integrating = 0; map->integrating = 0;
map->const_equiv_varray = 0; map->const_equiv_varray = 0;
@ -691,10 +691,9 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
if (max_labelno > 0) if (max_labelno > 0)
{ {
map->label_map = (rtx *) alloca (max_labelno * sizeof (rtx)); map->label_map = (rtx *) xmalloc (max_labelno * sizeof (rtx));
local_label = (char *) alloca (max_labelno); local_label = (char *) xcalloc (max_labelno, sizeof (char));
bzero (local_label, max_labelno);
} }
else else
map->label_map = 0; map->label_map = 0;
@ -742,7 +741,7 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
/* Allocate space for the insn map. */ /* Allocate space for the insn map. */
map->insn_map = (rtx *) alloca (max_insnno * sizeof (rtx)); map->insn_map = (rtx *) xmalloc (max_insnno * sizeof (rtx));
/* Set this to zero, to indicate that we are doing loop unrolling, /* Set this to zero, to indicate that we are doing loop unrolling,
not function inlining. */ not function inlining. */
@ -768,17 +767,12 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
preconditioning code and find_splittable_regs will never be used preconditioning code and find_splittable_regs will never be used
to access the splittable_regs[] and addr_combined_regs[] arrays. */ to access the splittable_regs[] and addr_combined_regs[] arrays. */
splittable_regs = (rtx *) alloca (maxregnum * sizeof (rtx)); splittable_regs = (rtx *) xcalloc (maxregnum, sizeof (rtx));
bzero ((char *) splittable_regs, maxregnum * sizeof (rtx)); derived_regs = (char *) xcalloc (maxregnum, sizeof (char));
derived_regs = (char *) alloca (maxregnum); splittable_regs_updates = (int *) xcalloc (maxregnum, sizeof (int));
bzero (derived_regs, maxregnum);
splittable_regs_updates = (int *) alloca (maxregnum * sizeof (int));
bzero ((char *) splittable_regs_updates, maxregnum * sizeof (int));
addr_combined_regs addr_combined_regs
= (struct induction **) alloca (maxregnum * sizeof (struct induction *)); = (struct induction **) xcalloc (maxregnum, sizeof (struct induction *));
bzero ((char *) addr_combined_regs, maxregnum * sizeof (struct induction *)); local_regno = (char *) xcalloc (maxregnum, sizeof (char));
local_regno = (char *) alloca (maxregnum);
bzero (local_regno, maxregnum);
/* Mark all local registers, i.e. the ones which are referenced only /* Mark all local registers, i.e. the ones which are referenced only
inside the loop. */ inside the loop. */
@ -884,7 +878,7 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
rtx *labels; rtx *labels;
int abs_inc, neg_inc; int abs_inc, neg_inc;
map->reg_map = (rtx *) alloca (maxregnum * sizeof (rtx)); map->reg_map = (rtx *) xmalloc (maxregnum * sizeof (rtx));
VARRAY_CONST_EQUIV_INIT (map->const_equiv_varray, maxregnum, VARRAY_CONST_EQUIV_INIT (map->const_equiv_varray, maxregnum,
"unroll_loop"); "unroll_loop");
@ -930,7 +924,7 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
/* Now emit a sequence of branches to jump to the proper precond /* Now emit a sequence of branches to jump to the proper precond
loop entry point. */ loop entry point. */
labels = (rtx *) alloca (sizeof (rtx) * unroll_number); labels = (rtx *) xmalloc (sizeof (rtx) * unroll_number);
for (i = 0; i < unroll_number; i++) for (i = 0; i < unroll_number; i++)
labels[i] = gen_label_rtx (); labels[i] = gen_label_rtx ();
@ -1109,6 +1103,9 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
/* Set unroll type to MODULO now. */ /* Set unroll type to MODULO now. */
unroll_type = UNROLL_MODULO; unroll_type = UNROLL_MODULO;
loop_preconditioned = 1; loop_preconditioned = 1;
/* Clean up. */
free (labels);
} }
} }
@ -1146,7 +1143,7 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
the constant maps also. */ the constant maps also. */
maxregnum = max_reg_num (); maxregnum = max_reg_num ();
map->reg_map = (rtx *) alloca (maxregnum * sizeof (rtx)); map->reg_map = (rtx *) xmalloc (maxregnum * sizeof (rtx));
init_reg_map (map, maxregnum); init_reg_map (map, maxregnum);
@ -1286,8 +1283,22 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
emit_label_after (exit_label, loop_end); emit_label_after (exit_label, loop_end);
egress: egress:
if (map && map->const_equiv_varray) if (map->const_equiv_varray)
VARRAY_FREE (map->const_equiv_varray); VARRAY_FREE (map->const_equiv_varray);
if (map->label_map)
{
free (map->label_map);
free (local_label);
}
free (map->insn_map);
free (splittable_regs);
free (derived_regs);
free (splittable_regs_updates);
free (addr_combined_regs);
free (local_regno);
if (map->reg_map)
free (map->reg_map);
free (map);
} }
/* Return true if the loop can be safely, and profitably, preconditioned /* Return true if the loop can be safely, and profitably, preconditioned