mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-05 10:40:50 +08:00
Code Issues Packages Projects Releases Wiki Activity

basic-block.h (XMALLOC_REG_SET, [...]): New.

Browse Source 
* basic-block.h (XMALLOC_REG_SET, XFREE_REG_SET): New.
	(struct basic_block_def): Remove local_set and cond_local_set
	fields.  Update comment for global_live_at_start.
	* flow.c (calculate_global_regs_live): Allocate local_sets and
	cond_local_sets here as arrays of bitmaps previously stored in
	bb->local_set and bb->cond_local_set.  Use xmalloc instead of
	obstack allocated bitmaps.

From-SVN: r90390
This commit is contained in:
Steven Bosscher 2004-11-10 09:28:29 +00:00 committed by Steven Bosscher
parent 780f9446a9
commit dda49b66a4
3 changed files with 70 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gcc/ChangeLog
View File

@ -1,3 +1,13 @@
2004-11-10 Steven Bosscher <stevenb@suse.de>
* basic-block.h (XMALLOC_REG_SET, XFREE_REG_SET): New.
(struct basic_block_def): Remove local_set and cond_local_set
fields. Update comment for global_live_at_start.
* flow.c (calculate_global_regs_live): Allocate local_sets and
cond_local_sets here as arrays of bitmaps previously stored in
bb->local_set and bb->cond_local_set. Use xmalloc instead of
obstack allocated bitmaps.
2004-11-09 H.J. Lu <hongjiu.lu@intel.com>
PR target/18380

21
gcc/basic-block.h
View File

@ -110,6 +110,12 @@ typedef bitmap_iterator reg_set_iterator;
/* Do any cleanup needed on a regset when it is no longer used. */
#define FREE_REG_SET(REGSET) BITMAP_FREE(REGSET)
/* Allocate a register set with xmalloc. */
#define XMALLOC_REG_SET() BITMAP_XMALLOC ()
/* Free a register set. */
#define XFREE_REG_SET(REGSET) BITMAP_XFREE (REGSET)
/* Do any one-time initializations needed for regsets. */
#define INIT_ONCE_REG_SET() BITMAP_INIT_ONCE ()
@ -229,20 +235,9 @@ struct basic_block_def GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb")
VEC(edge) *preds;
VEC(edge) *succs;
/* Liveness info. */
/* The registers that are modified within this in block. */
bitmap GTY ((skip (""))) local_set;
/* The registers that are conditionally modified within this block.
In other words, registers that are set only as part of a
COND_EXEC. */
bitmap GTY ((skip (""))) cond_local_set;
/* The registers that are live on entry to this block.
Note that in SSA form, global_live_at_start does not reflect the
use of regs in phi functions, since the liveness of these regs
may depend on which edge was taken into the block. */
/* The registers that are live on entry to this block. */
bitmap GTY ((skip (""))) global_live_at_start;
/* The registers that are live on exit from this block. */
bitmap GTY ((skip (""))) global_live_at_end;

78
gcc/flow.c
View File

@ -112,7 +112,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
/* TODO:
Split out from life_analysis:
- local property discovery (bb->local_live, bb->local_set)
- local property discovery
- global property computation
- log links creation
- pre/post modify transformation
@ -1018,6 +1018,14 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
regset tmp, new_live_at_end, invalidated_by_call;
regset_head tmp_head, invalidated_by_call_head;
regset_head new_live_at_end_head;
/* The registers that are modified within this in block. */
regset *local_sets;
/* The registers that are conditionally modified within this block.
In other words, regs that are set only as part of a COND_EXEC. */
regset *cond_local_sets;
int i;
/* Some passes used to forget clear aux field of basic block causing
@ -1036,12 +1044,18 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
SET_REGNO_REG_SET (invalidated_by_call, i);
/* Allocate space for the sets of local properties. */
local_sets = xcalloc (last_basic_block - (INVALID_BLOCK + 1),
sizeof (regset));
cond_local_sets = xcalloc (last_basic_block - (INVALID_BLOCK + 1),
sizeof (regset));
/* Create a worklist. Allocate an extra slot for ENTRY_BLOCK, and one
because the `head == tail' style test for an empty queue doesn't
work with a full queue. */
queue = xmalloc ((n_basic_blocks + 2) * sizeof (*queue));
queue = xmalloc ((n_basic_blocks - (INVALID_BLOCK + 1)) * sizeof (*queue));
qtail = queue;
qhead = qend = queue + n_basic_blocks + 2;
qhead = qend = queue + n_basic_blocks - (INVALID_BLOCK + 1);
/* Queue the blocks set in the initial mask. Do this in reverse block
number order so that we are more likely for the first round to do
@ -1171,13 +1185,14 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
}
/* On our first pass through this block, we'll go ahead and continue.
Recognize first pass by local_set NULL. On subsequent passes, we
get to skip out early if live_at_end wouldn't have changed. */
Recognize first pass by checking if local_set is NULL for this
basic block. On subsequent passes, we get to skip out early if
live_at_end wouldn't have changed. */
if (bb->local_set == NULL)
if (local_sets[bb->index - (INVALID_BLOCK + 1)] == NULL)
{
bb->local_set = OBSTACK_ALLOC_REG_SET (&flow_obstack);
bb->cond_local_set = OBSTACK_ALLOC_REG_SET (&flow_obstack);
local_sets[bb->index - (INVALID_BLOCK + 1)] = XMALLOC_REG_SET ();
cond_local_sets[bb->index - (INVALID_BLOCK + 1)] = XMALLOC_REG_SET ();
rescan = 1;
}
else
@ -1190,28 +1205,35 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
new_live_at_end);
if (!rescan)
/* If any of the registers in the new live_at_end set are
conditionally set in this basic block, we must rescan.
This is because conditional lifetimes at the end of the
block do not just take the live_at_end set into
account, but also the liveness at the start of each
successor block. We can miss changes in those sets if
we only compare the new live_at_end against the
previous one. */
rescan = bitmap_intersect_p (new_live_at_end,
bb->cond_local_set);
{
regset cond_local_set;
/* If any of the registers in the new live_at_end set are
conditionally set in this basic block, we must rescan.
This is because conditional lifetimes at the end of the
block do not just take the live_at_end set into
account, but also the liveness at the start of each
successor block. We can miss changes in those sets if
we only compare the new live_at_end against the
previous one. */
cond_local_set = cond_local_sets[bb->index - (INVALID_BLOCK + 1)];
rescan = bitmap_intersect_p (new_live_at_end, cond_local_set);
}
if (!rescan)
{
regset local_set;
/* Find the set of changed bits. Take this opportunity
to notice that this set is empty and early out. */
bitmap_xor (tmp, bb->global_live_at_end, new_live_at_end);
if (bitmap_empty_p (tmp))
continue;
/* If any of the changed bits overlap with local_set,
/* If any of the changed bits overlap with local_sets[bb],
we'll have to rescan the block. */
rescan = bitmap_intersect_p (tmp, bb->local_set);
local_set = local_sets[bb->index - (INVALID_BLOCK + 1)];
rescan = bitmap_intersect_p (tmp, local_set);
}
}
@ -1238,8 +1260,10 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
/* Rescan the block insn by insn to turn (a copy of) live_at_end
into live_at_start. */
propagate_block (bb, new_live_at_end, bb->local_set,
bb->cond_local_set, flags);
propagate_block (bb, new_live_at_end,
local_sets[bb->index - (INVALID_BLOCK + 1)],
cond_local_sets[bb->index - (INVALID_BLOCK + 1)],
flags);
/* If live_at start didn't change, no need to go farther. */
if (REG_SET_EQUAL_P (bb->global_live_at_start, new_live_at_end))
@ -1272,20 +1296,22 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
EXECUTE_IF_SET_IN_SBITMAP (blocks_out, 0, i,
{
basic_block bb = BASIC_BLOCK (i);
FREE_REG_SET (bb->local_set);
FREE_REG_SET (bb->cond_local_set);
XFREE_REG_SET (local_sets[bb->index - (INVALID_BLOCK + 1)]);
XFREE_REG_SET (cond_local_sets[bb->index - (INVALID_BLOCK + 1)]);
});
}
else
{
FOR_EACH_BB (bb)
{
FREE_REG_SET (bb->local_set);
FREE_REG_SET (bb->cond_local_set);
XFREE_REG_SET (local_sets[bb->index - (INVALID_BLOCK + 1)]);
XFREE_REG_SET (cond_local_sets[bb->index - (INVALID_BLOCK + 1)]);
}
}
free (queue);
free (cond_local_sets);
free (local_sets);
}