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:
parent
20bbd3cd53
commit
67289ea639
@ -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>
|
||||||
|
@ -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 { \
|
||||||
|
47
gcc/flow.c
47
gcc/flow.c
@ -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.
|
||||||
|
69
gcc/global.c
69
gcc/global.c
@ -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,
|
||||||
|
@ -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;
|
||||||
|
33
gcc/jump.c
33
gcc/jump.c
@ -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
|
||||||
|
67
gcc/loop.c
67
gcc/loop.c
@ -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. */
|
||||||
|
@ -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 */
|
||||||
|
49
gcc/unroll.c
49
gcc/unroll.c
@ -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
|
||||||
|
Loading…
x
Reference in New Issue
Block a user