Skip to content

R
riscv-gcc-1
Commit 5c72d561 by Jan Hubicka Committed by Jan Hubicka
Options

df-problems.c (seen_in_block, [...]): Convert to bitmap_head. 

	* df-problems.c (seen_in_block, seen_in_insn): Convert to bitmap_head.
	(df_rd_problem_data): Convert sparse_invalidated_by_call,
	dense_invalidated_by_call to bitmap head.
	(df_rd_alloc, df_rd_bb_local_compute_process_def,
	df_rd_bb_local_compute, df_rd_confluence_n, df_rd_transfer_function,
	df_rd_start_dump, df_lr_verify_transfer_functions,
	df_live_verify_transfer_functions, df_chain_create_bb,
	df_chain_add_problem, df_byte_lr_check_regs, df_byte_lr_alloc,
	df_byte_lr_confluence_0, df_byte_lr_confluence_n, df_note_compute,
	df_simulate_one_insn_forwards, df_md_alloc, df_md_bb_local_compute_process_def,
	df_md_bb_local_compute_process_def, df_md_local_compute, df_md_transfer_function
	df_md_free): Update.

From-SVN: r160315
parent d65aed70
Showing with 181 additions and 163 deletions
gcc/ChangeLog
2010-06-05 Jan Hubicka <jh@suse.cz>
* df-problems.c (seen_in_block, seen_in_insn): Convert to bitmap_head.
(df_rd_problem_data): Convert sparse_invalidated_by_call,
dense_invalidated_by_call to bitmap head.
(df_rd_alloc, df_rd_bb_local_compute_process_def,
df_rd_bb_local_compute, df_rd_confluence_n, df_rd_transfer_function,
df_rd_start_dump, df_lr_verify_transfer_functions,
df_live_verify_transfer_functions, df_chain_create_bb,
df_chain_add_problem, df_byte_lr_check_regs, df_byte_lr_alloc,
df_byte_lr_confluence_0, df_byte_lr_confluence_n, df_note_compute,
df_simulate_one_insn_forwards, df_md_alloc, df_md_bb_local_compute_process_def,
df_md_bb_local_compute_process_def, df_md_local_compute, df_md_transfer_function
df_md_free): Update.
2010-06-05 Joseph Myers <joseph@codesourcery.com> 2010-06-05 Joseph Myers <joseph@codesourcery.com>
PR c/44322 PR c/44322
......
gcc/df-problems.c
...@@ -54,8 +54,8 @@ along with GCC; see the file COPYING3. If not see ...@@ -54,8 +54,8 @@ along with GCC; see the file COPYING3. If not see
#define DF_SPARSE_THRESHOLD 32 #define DF_SPARSE_THRESHOLD 32
static bitmap seen_in_block = NULL; static bitmap_head seen_in_block;
static bitmap seen_in_insn = NULL; static bitmap_head seen_in_insn;
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
...@@ -195,9 +195,9 @@ df_print_bb_index (basic_block bb, FILE *file) ...@@ -195,9 +195,9 @@ df_print_bb_index (basic_block bb, FILE *file)
struct df_rd_problem_data struct df_rd_problem_data
{ {
/* The set of defs to regs invalidated by call. */ /* The set of defs to regs invalidated by call. */
bitmap sparse_invalidated_by_call; bitmap_head sparse_invalidated_by_call;
/* The set of defs to regs invalidate by call for rd. */ /* The set of defs to regs invalidate by call for rd. */
bitmap dense_invalidated_by_call; bitmap_head dense_invalidated_by_call;
/* An obstack for the bitmaps we need for this problem. */ /* An obstack for the bitmaps we need for this problem. */
bitmap_obstack rd_bitmaps; bitmap_obstack rd_bitmaps;
}; };
...@@ -250,8 +250,8 @@ df_rd_alloc (bitmap all_blocks) ...@@ -250,8 +250,8 @@ df_rd_alloc (bitmap all_blocks)
if (df_rd->problem_data) if (df_rd->problem_data)
{ {
problem_data = (struct df_rd_problem_data *) df_rd->problem_data; problem_data = (struct df_rd_problem_data *) df_rd->problem_data;
bitmap_clear (problem_data->sparse_invalidated_by_call); bitmap_clear (&problem_data->sparse_invalidated_by_call);
bitmap_clear (problem_data->dense_invalidated_by_call); bitmap_clear (&problem_data->dense_invalidated_by_call);
} }
else else
{ {
...@@ -259,10 +259,10 @@ df_rd_alloc (bitmap all_blocks) ...@@ -259,10 +259,10 @@ df_rd_alloc (bitmap all_blocks)
df_rd->problem_data = problem_data; df_rd->problem_data = problem_data;
bitmap_obstack_initialize (&problem_data->rd_bitmaps); bitmap_obstack_initialize (&problem_data->rd_bitmaps);
problem_data->sparse_invalidated_by_call bitmap_initialize (&problem_data->sparse_invalidated_by_call,
= BITMAP_ALLOC (&problem_data->rd_bitmaps); &problem_data->rd_bitmaps);
problem_data->dense_invalidated_by_call bitmap_initialize (&problem_data->dense_invalidated_by_call,
= BITMAP_ALLOC (&problem_data->rd_bitmaps); &problem_data->rd_bitmaps);
} }
df_grow_bb_info (df_rd); df_grow_bb_info (df_rd);
...@@ -370,11 +370,11 @@ df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info, ...@@ -370,11 +370,11 @@ df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info,
{ {
/* Only the last def(s) for a regno in the block has any /* Only the last def(s) for a regno in the block has any
effect. */ effect. */
if (!bitmap_bit_p (seen_in_block, regno)) if (!bitmap_bit_p (&seen_in_block, regno))
{ {
/* The first def for regno in insn gets to knock out the /* The first def for regno in insn gets to knock out the
defs from other instructions. */ defs from other instructions. */
if ((!bitmap_bit_p (seen_in_insn, regno)) if ((!bitmap_bit_p (&seen_in_insn, regno))
/* If the def is to only part of the reg, it does /* If the def is to only part of the reg, it does
not kill the other defs that reach here. */ not kill the other defs that reach here. */
&& (!(DF_REF_FLAGS (def) & && (!(DF_REF_FLAGS (def) &
...@@ -392,7 +392,7 @@ df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info, ...@@ -392,7 +392,7 @@ df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info,
} }
} }
bitmap_set_bit (seen_in_insn, regno); bitmap_set_bit (&seen_in_insn, regno);
/* All defs for regno in the instruction may be put into /* All defs for regno in the instruction may be put into
the gen set. */ the gen set. */
if (!(DF_REF_FLAGS (def) if (!(DF_REF_FLAGS (def)
...@@ -414,8 +414,8 @@ df_rd_bb_local_compute (unsigned int bb_index) ...@@ -414,8 +414,8 @@ df_rd_bb_local_compute (unsigned int bb_index)
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index); struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
rtx insn; rtx insn;
bitmap_clear (seen_in_block); bitmap_clear (&seen_in_block);
bitmap_clear (seen_in_insn); bitmap_clear (&seen_in_insn);
/* Artificials are only hard regs. */ /* Artificials are only hard regs. */
if (!(df->changeable_flags & DF_NO_HARD_REGS)) if (!(df->changeable_flags & DF_NO_HARD_REGS))
...@@ -439,8 +439,8 @@ df_rd_bb_local_compute (unsigned int bb_index) ...@@ -439,8 +439,8 @@ df_rd_bb_local_compute (unsigned int bb_index)
result and another def for the clobber. If only one vector result and another def for the clobber. If only one vector
is used and the clobber goes first, the result will be is used and the clobber goes first, the result will be
lost. */ lost. */
bitmap_ior_into (seen_in_block, seen_in_insn); bitmap_ior_into (&seen_in_block, &seen_in_insn);
bitmap_clear (seen_in_insn); bitmap_clear (&seen_in_insn);
} }
/* Process the artificial defs at the top of the block last since we /* Process the artificial defs at the top of the block last since we
...@@ -463,11 +463,11 @@ df_rd_local_compute (bitmap all_blocks) ...@@ -463,11 +463,11 @@ df_rd_local_compute (bitmap all_blocks)
unsigned int regno; unsigned int regno;
struct df_rd_problem_data *problem_data struct df_rd_problem_data *problem_data
= (struct df_rd_problem_data *) df_rd->problem_data; = (struct df_rd_problem_data *) df_rd->problem_data;
bitmap sparse_invalidated = problem_data->sparse_invalidated_by_call; bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_call;
bitmap dense_invalidated = problem_data->dense_invalidated_by_call; bitmap dense_invalidated = &problem_data->dense_invalidated_by_call;
seen_in_block = BITMAP_ALLOC (&df_bitmap_obstack); bitmap_initialize (&seen_in_block, &df_bitmap_obstack);
seen_in_insn = BITMAP_ALLOC (&df_bitmap_obstack); bitmap_initialize (&seen_in_insn, &df_bitmap_obstack);
df_maybe_reorganize_def_refs (DF_REF_ORDER_BY_REG); df_maybe_reorganize_def_refs (DF_REF_ORDER_BY_REG);
...@@ -487,8 +487,8 @@ df_rd_local_compute (bitmap all_blocks) ...@@ -487,8 +487,8 @@ df_rd_local_compute (bitmap all_blocks)
DF_DEFS_COUNT (regno)); DF_DEFS_COUNT (regno));
} }
BITMAP_FREE (seen_in_block); bitmap_clear (&seen_in_block);
BITMAP_FREE (seen_in_insn); bitmap_clear (&seen_in_insn);
} }
...@@ -524,23 +524,24 @@ df_rd_confluence_n (edge e) ...@@ -524,23 +524,24 @@ df_rd_confluence_n (edge e)
{ {
struct df_rd_problem_data *problem_data struct df_rd_problem_data *problem_data
= (struct df_rd_problem_data *) df_rd->problem_data; = (struct df_rd_problem_data *) df_rd->problem_data;
bitmap sparse_invalidated = problem_data->sparse_invalidated_by_call; bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_call;
bitmap dense_invalidated = problem_data->dense_invalidated_by_call; bitmap dense_invalidated = &problem_data->dense_invalidated_by_call;
bitmap_iterator bi; bitmap_iterator bi;
unsigned int regno; unsigned int regno;
bitmap tmp = BITMAP_ALLOC (&df_bitmap_obstack); bitmap_head tmp;
bitmap_copy (tmp, op2); bitmap_initialize (&tmp, &df_bitmap_obstack);
bitmap_and_compl_into (tmp, dense_invalidated); bitmap_copy (&tmp, op2);
bitmap_and_compl_into (&tmp, dense_invalidated);
EXECUTE_IF_SET_IN_BITMAP (sparse_invalidated, 0, regno, bi) EXECUTE_IF_SET_IN_BITMAP (sparse_invalidated, 0, regno, bi)
{ {
bitmap_clear_range (tmp, bitmap_clear_range (&tmp,
DF_DEFS_BEGIN (regno), DF_DEFS_BEGIN (regno),
DF_DEFS_COUNT (regno)); DF_DEFS_COUNT (regno));
} }
bitmap_ior_into (op1, tmp); bitmap_ior_into (op1, &tmp);
BITMAP_FREE (tmp); bitmap_clear (&tmp);
} }
else else
bitmap_ior_into (op1, op2); bitmap_ior_into (op1, op2);
...@@ -567,30 +568,30 @@ df_rd_transfer_function (int bb_index) ...@@ -567,30 +568,30 @@ df_rd_transfer_function (int bb_index)
{ {
struct df_rd_problem_data *problem_data; struct df_rd_problem_data *problem_data;
bool changed = false; bool changed = false;
bitmap tmp; bitmap_head tmp;
/* Note that TMP is _not_ a temporary bitmap if we end up replacing /* Note that TMP is _not_ a temporary bitmap if we end up replacing
OUT with TMP. Therefore, allocate TMP in the RD bitmaps obstack. */ OUT with TMP. Therefore, allocate TMP in the RD bitmaps obstack. */
problem_data = (struct df_rd_problem_data *) df_rd->problem_data; problem_data = (struct df_rd_problem_data *) df_rd->problem_data;
tmp = BITMAP_ALLOC (&problem_data->rd_bitmaps); bitmap_initialize (&tmp, &problem_data->rd_bitmaps);
bitmap_copy (tmp, in); bitmap_copy (&tmp, in);
EXECUTE_IF_SET_IN_BITMAP (sparse_kill, 0, regno, bi) EXECUTE_IF_SET_IN_BITMAP (sparse_kill, 0, regno, bi)
{ {
bitmap_clear_range (tmp, bitmap_clear_range (&tmp,
DF_DEFS_BEGIN (regno), DF_DEFS_BEGIN (regno),
DF_DEFS_COUNT (regno)); DF_DEFS_COUNT (regno));
} }
bitmap_and_compl_into (tmp, kill); bitmap_and_compl_into (&tmp, kill);
bitmap_ior_into (tmp, gen); bitmap_ior_into (&tmp, gen);
changed = !bitmap_equal_p (tmp, out); changed = !bitmap_equal_p (&tmp, out);
if (changed) if (changed)
{ {
bitmap_clear (out); bitmap_clear (out);
bb_info->out = *tmp; bb_info->out = tmp;
} }
else else
bitmap_clear (tmp); bitmap_clear (&tmp);
return changed; return changed;
} }
} }
...@@ -633,9 +634,9 @@ df_rd_start_dump (FILE *file) ...@@ -633,9 +634,9 @@ df_rd_start_dump (FILE *file)
fprintf (file, ";; Reaching defs:\n\n"); fprintf (file, ";; Reaching defs:\n\n");
fprintf (file, " sparse invalidated \t"); fprintf (file, " sparse invalidated \t");
dump_bitmap (file, problem_data->sparse_invalidated_by_call); dump_bitmap (file, &problem_data->sparse_invalidated_by_call);
fprintf (file, " dense invalidated \t"); fprintf (file, " dense invalidated \t");
dump_bitmap (file, problem_data->dense_invalidated_by_call); dump_bitmap (file, &problem_data->dense_invalidated_by_call);
for (regno = 0; regno < m; regno++) for (regno = 0; regno < m; regno++)
if (DF_DEFS_COUNT (regno)) if (DF_DEFS_COUNT (regno))
...@@ -1269,25 +1270,21 @@ void ...@@ -1269,25 +1270,21 @@ void
df_lr_verify_transfer_functions (void) df_lr_verify_transfer_functions (void)
{ {
basic_block bb; basic_block bb;
bitmap saved_def; bitmap_head saved_def;
bitmap saved_use; bitmap_head saved_use;
bitmap saved_adef; bitmap_head all_blocks;
bitmap saved_ause;
bitmap all_blocks;
if (!df) if (!df)
return; return;
saved_def = BITMAP_ALLOC (NULL); bitmap_initialize (&saved_def, &bitmap_default_obstack);
saved_use = BITMAP_ALLOC (NULL); bitmap_initialize (&saved_use, &bitmap_default_obstack);
saved_adef = BITMAP_ALLOC (NULL); bitmap_initialize (&all_blocks, &bitmap_default_obstack);
saved_ause = BITMAP_ALLOC (NULL);
all_blocks = BITMAP_ALLOC (NULL);
FOR_ALL_BB (bb) FOR_ALL_BB (bb)
{ {
struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index); struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
bitmap_set_bit (all_blocks, bb->index); bitmap_set_bit (&all_blocks, bb->index);
if (bb_info) if (bb_info)
{ {
...@@ -1297,14 +1294,14 @@ df_lr_verify_transfer_functions (void) ...@@ -1297,14 +1294,14 @@ df_lr_verify_transfer_functions (void)
if (!bitmap_bit_p (df_lr->out_of_date_transfer_functions, if (!bitmap_bit_p (df_lr->out_of_date_transfer_functions,
bb->index)) bb->index))
{ {
bitmap_copy (saved_def, &bb_info->def); bitmap_copy (&saved_def, &bb_info->def);
bitmap_copy (saved_use, &bb_info->use); bitmap_copy (&saved_use, &bb_info->use);
bitmap_clear (&bb_info->def); bitmap_clear (&bb_info->def);
bitmap_clear (&bb_info->use); bitmap_clear (&bb_info->use);
df_lr_bb_local_compute (bb->index); df_lr_bb_local_compute (bb->index);
gcc_assert (bitmap_equal_p (saved_def, &bb_info->def)); gcc_assert (bitmap_equal_p (&saved_def, &bb_info->def));
gcc_assert (bitmap_equal_p (saved_use, &bb_info->use)); gcc_assert (bitmap_equal_p (&saved_use, &bb_info->use));
} }
} }
else else
...@@ -1322,13 +1319,11 @@ df_lr_verify_transfer_functions (void) ...@@ -1322,13 +1319,11 @@ df_lr_verify_transfer_functions (void)
/* Make sure there are no dirty bits in blocks that have been deleted. */ /* Make sure there are no dirty bits in blocks that have been deleted. */
gcc_assert (!bitmap_intersect_compl_p (df_lr->out_of_date_transfer_functions, gcc_assert (!bitmap_intersect_compl_p (df_lr->out_of_date_transfer_functions,
all_blocks)); &all_blocks));
BITMAP_FREE (saved_def); bitmap_clear (&saved_def);
BITMAP_FREE (saved_use); bitmap_clear (&saved_use);
BITMAP_FREE (saved_adef); bitmap_clear (&all_blocks);
BITMAP_FREE (saved_ause);
BITMAP_FREE (all_blocks);
} }
...@@ -1828,23 +1823,23 @@ void ...@@ -1828,23 +1823,23 @@ void
df_live_verify_transfer_functions (void) df_live_verify_transfer_functions (void)
{ {
basic_block bb; basic_block bb;
bitmap saved_gen; bitmap_head saved_gen;
bitmap saved_kill; bitmap_head saved_kill;
bitmap all_blocks; bitmap_head all_blocks;
if (!df) if (!df)
return; return;
saved_gen = BITMAP_ALLOC (NULL); bitmap_initialize (&saved_gen, &bitmap_default_obstack);
saved_kill = BITMAP_ALLOC (NULL); bitmap_initialize (&saved_kill, &bitmap_default_obstack);
all_blocks = BITMAP_ALLOC (NULL); bitmap_initialize (&all_blocks, &bitmap_default_obstack);
df_grow_insn_info (); df_grow_insn_info ();
FOR_ALL_BB (bb) FOR_ALL_BB (bb)
{ {
struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index); struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
bitmap_set_bit (all_blocks, bb->index); bitmap_set_bit (&all_blocks, bb->index);
if (bb_info) if (bb_info)
{ {
...@@ -1854,14 +1849,14 @@ df_live_verify_transfer_functions (void) ...@@ -1854,14 +1849,14 @@ df_live_verify_transfer_functions (void)
if (!bitmap_bit_p (df_live->out_of_date_transfer_functions, if (!bitmap_bit_p (df_live->out_of_date_transfer_functions,
bb->index)) bb->index))
{ {
bitmap_copy (saved_gen, &bb_info->gen); bitmap_copy (&saved_gen, &bb_info->gen);
bitmap_copy (saved_kill, &bb_info->kill); bitmap_copy (&saved_kill, &bb_info->kill);
bitmap_clear (&bb_info->gen); bitmap_clear (&bb_info->gen);
bitmap_clear (&bb_info->kill); bitmap_clear (&bb_info->kill);
df_live_bb_local_compute (bb->index); df_live_bb_local_compute (bb->index);
gcc_assert (bitmap_equal_p (saved_gen, &bb_info->gen)); gcc_assert (bitmap_equal_p (&saved_gen, &bb_info->gen));
gcc_assert (bitmap_equal_p (saved_kill, &bb_info->kill)); gcc_assert (bitmap_equal_p (&saved_kill, &bb_info->kill));
} }
} }
else else
...@@ -1879,10 +1874,10 @@ df_live_verify_transfer_functions (void) ...@@ -1879,10 +1874,10 @@ df_live_verify_transfer_functions (void)
/* Make sure there are no dirty bits in blocks that have been deleted. */ /* Make sure there are no dirty bits in blocks that have been deleted. */
gcc_assert (!bitmap_intersect_compl_p (df_live->out_of_date_transfer_functions, gcc_assert (!bitmap_intersect_compl_p (df_live->out_of_date_transfer_functions,
all_blocks)); &all_blocks));
BITMAP_FREE (saved_gen); bitmap_clear (&saved_gen);
BITMAP_FREE (saved_kill); bitmap_clear (&saved_kill);
BITMAP_FREE (all_blocks); bitmap_clear (&all_blocks);
} }
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
...@@ -2109,9 +2104,10 @@ df_chain_create_bb (unsigned int bb_index) ...@@ -2109,9 +2104,10 @@ df_chain_create_bb (unsigned int bb_index)
basic_block bb = BASIC_BLOCK (bb_index); basic_block bb = BASIC_BLOCK (bb_index);
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index); struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
rtx insn; rtx insn;
bitmap cpy = BITMAP_ALLOC (NULL); bitmap_head cpy;
bitmap_copy (cpy, &bb_info->in); bitmap_initialize (&cpy, &bitmap_default_obstack);
bitmap_copy (&cpy, &bb_info->in);
bitmap_set_bit (df_chain->out_of_date_transfer_functions, bb_index); bitmap_set_bit (df_chain->out_of_date_transfer_functions, bb_index);
/* Since we are going forwards, process the artificial uses first /* Since we are going forwards, process the artificial uses first
...@@ -2123,12 +2119,12 @@ df_chain_create_bb (unsigned int bb_index) ...@@ -2123,12 +2119,12 @@ df_chain_create_bb (unsigned int bb_index)
/* Artificials are only hard regs. */ /* Artificials are only hard regs. */
if (!(df->changeable_flags & DF_NO_HARD_REGS)) if (!(df->changeable_flags & DF_NO_HARD_REGS))
df_chain_create_bb_process_use (cpy, df_chain_create_bb_process_use (&cpy,
df_get_artificial_uses (bb->index), df_get_artificial_uses (bb->index),
DF_REF_AT_TOP); DF_REF_AT_TOP);
#endif #endif
df_rd_simulate_artificial_defs_at_top (bb, cpy); df_rd_simulate_artificial_defs_at_top (bb, &cpy);
/* Process the regular instructions next. */ /* Process the regular instructions next. */
FOR_BB_INSNS (bb, insn) FOR_BB_INSNS (bb, insn)
...@@ -2138,22 +2134,22 @@ df_chain_create_bb (unsigned int bb_index) ...@@ -2138,22 +2134,22 @@ df_chain_create_bb (unsigned int bb_index)
/* First scan the uses and link them up with the defs that remain /* First scan the uses and link them up with the defs that remain
in the cpy vector. */ in the cpy vector. */
df_chain_create_bb_process_use (cpy, DF_INSN_UID_USES (uid), 0); df_chain_create_bb_process_use (&cpy, DF_INSN_UID_USES (uid), 0);
if (df->changeable_flags & DF_EQ_NOTES) if (df->changeable_flags & DF_EQ_NOTES)
df_chain_create_bb_process_use (cpy, DF_INSN_UID_EQ_USES (uid), 0); df_chain_create_bb_process_use (&cpy, DF_INSN_UID_EQ_USES (uid), 0);
/* Since we are going forwards, process the defs second. */ /* Since we are going forwards, process the defs second. */
df_rd_simulate_one_insn (bb, insn, cpy); df_rd_simulate_one_insn (bb, insn, &cpy);
} }
/* Create the chains for the artificial uses of the hard registers /* Create the chains for the artificial uses of the hard registers
at the end of the block. */ at the end of the block. */
if (!(df->changeable_flags & DF_NO_HARD_REGS)) if (!(df->changeable_flags & DF_NO_HARD_REGS))
df_chain_create_bb_process_use (cpy, df_chain_create_bb_process_use (&cpy,
df_get_artificial_uses (bb->index), df_get_artificial_uses (bb->index),
0); 0);
BITMAP_FREE (cpy); bitmap_clear (&cpy);
} }
/* Create def-use chains from reaching use bitmaps for basic blocks /* Create def-use chains from reaching use bitmaps for basic blocks
...@@ -2368,12 +2364,12 @@ df_chain_add_problem (unsigned int chain_flags) ...@@ -2368,12 +2364,12 @@ df_chain_add_problem (unsigned int chain_flags)
struct df_byte_lr_problem_data struct df_byte_lr_problem_data
{ {
/* Expanded versions of bitvectors used in lr. */ /* Expanded versions of bitvectors used in lr. */
bitmap invalidated_by_call; bitmap_head invalidated_by_call;
bitmap hardware_regs_used; bitmap_head hardware_regs_used;
/* Indexed by regno, this is true if there are subregs, extracts or /* Indexed by regno, this is true if there are subregs, extracts or
strict_low_parts for this regno. */ strict_low_parts for this regno. */
bitmap needs_expansion; bitmap_head needs_expansion;
/* The start position and len for each regno in the various bit /* The start position and len for each regno in the various bit
vectors. */ vectors. */
...@@ -2452,7 +2448,7 @@ df_byte_lr_check_regs (df_ref *ref_rec) ...@@ -2452,7 +2448,7 @@ df_byte_lr_check_regs (df_ref *ref_rec)
| DF_REF_ZERO_EXTRACT | DF_REF_ZERO_EXTRACT
| DF_REF_STRICT_LOW_PART) | DF_REF_STRICT_LOW_PART)
|| GET_CODE (DF_REF_REG (ref)) == SUBREG) || GET_CODE (DF_REF_REG (ref)) == SUBREG)
bitmap_set_bit (problem_data->needs_expansion, DF_REF_REGNO (ref)); bitmap_set_bit (&problem_data->needs_expansion, DF_REF_REGNO (ref));
} }
} }
...@@ -2509,9 +2505,12 @@ df_byte_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED) ...@@ -2509,9 +2505,12 @@ df_byte_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
bitmap_obstack_initialize (&problem_data->byte_lr_bitmaps); bitmap_obstack_initialize (&problem_data->byte_lr_bitmaps);
problem_data->regno_start = XNEWVEC (unsigned int, max_reg); problem_data->regno_start = XNEWVEC (unsigned int, max_reg);
problem_data->regno_len = XNEWVEC (unsigned int, max_reg); problem_data->regno_len = XNEWVEC (unsigned int, max_reg);
problem_data->hardware_regs_used = BITMAP_ALLOC (&problem_data->byte_lr_bitmaps); bitmap_initialize (&problem_data->hardware_regs_used,
problem_data->invalidated_by_call = BITMAP_ALLOC (&problem_data->byte_lr_bitmaps); &problem_data->byte_lr_bitmaps);
problem_data->needs_expansion = BITMAP_ALLOC (&problem_data->byte_lr_bitmaps); bitmap_initialize (&problem_data->invalidated_by_call,
&problem_data->byte_lr_bitmaps);
bitmap_initialize (&problem_data->needs_expansion,
&problem_data->byte_lr_bitmaps);
/* Discover which regno's use subregs, extracts or /* Discover which regno's use subregs, extracts or
strict_low_parts. */ strict_low_parts. */
...@@ -2538,7 +2537,7 @@ df_byte_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED) ...@@ -2538,7 +2537,7 @@ df_byte_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
{ {
int len; int len;
problem_data->regno_start[regno] = index; problem_data->regno_start[regno] = index;
if (bitmap_bit_p (problem_data->needs_expansion, regno)) if (bitmap_bit_p (&problem_data->needs_expansion, regno))
len = GET_MODE_SIZE (GET_MODE (regno_reg_rtx[regno])); len = GET_MODE_SIZE (GET_MODE (regno_reg_rtx[regno]));
else else
len = 1; len = 1;
...@@ -2547,9 +2546,9 @@ df_byte_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED) ...@@ -2547,9 +2546,9 @@ df_byte_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
index += len; index += len;
} }
df_byte_lr_expand_bitmap (problem_data->hardware_regs_used, df_byte_lr_expand_bitmap (&problem_data->hardware_regs_used,
df->hardware_regs_used); df->hardware_regs_used);
df_byte_lr_expand_bitmap (problem_data->invalidated_by_call, df_byte_lr_expand_bitmap (&problem_data->invalidated_by_call,
regs_invalidated_by_call_regset); regs_invalidated_by_call_regset);
EXECUTE_IF_SET_IN_BITMAP (df_byte_lr->out_of_date_transfer_functions, 0, bb_index, bi) EXECUTE_IF_SET_IN_BITMAP (df_byte_lr->out_of_date_transfer_functions, 0, bb_index, bi)
...@@ -2771,7 +2770,7 @@ df_byte_lr_confluence_0 (basic_block bb) ...@@ -2771,7 +2770,7 @@ df_byte_lr_confluence_0 (basic_block bb)
= (struct df_byte_lr_problem_data *)df_byte_lr->problem_data; = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
bitmap op1 = &df_byte_lr_get_bb_info (bb->index)->out; bitmap op1 = &df_byte_lr_get_bb_info (bb->index)->out;
if (bb != EXIT_BLOCK_PTR) if (bb != EXIT_BLOCK_PTR)
bitmap_copy (op1, problem_data->hardware_regs_used); bitmap_copy (op1, &problem_data->hardware_regs_used);
} }
...@@ -2789,11 +2788,11 @@ df_byte_lr_confluence_n (edge e) ...@@ -2789,11 +2788,11 @@ df_byte_lr_confluence_n (edge e)
/* ??? Abnormal call edges ignored for the moment, as this gets /* ??? Abnormal call edges ignored for the moment, as this gets
confused by sibling call edges, which crashes reg-stack. */ confused by sibling call edges, which crashes reg-stack. */
if (e->flags & EDGE_EH) if (e->flags & EDGE_EH)
bitmap_ior_and_compl_into (op1, op2, problem_data->invalidated_by_call); bitmap_ior_and_compl_into (op1, op2, &problem_data->invalidated_by_call);
else else
bitmap_ior_into (op1, op2); bitmap_ior_into (op1, op2);
bitmap_ior_into (op1, problem_data->hardware_regs_used); bitmap_ior_into (op1, &problem_data->hardware_regs_used);
} }
...@@ -3808,9 +3807,11 @@ df_note_compute (bitmap all_blocks) ...@@ -3808,9 +3807,11 @@ df_note_compute (bitmap all_blocks)
{ {
unsigned int bb_index; unsigned int bb_index;
bitmap_iterator bi; bitmap_iterator bi;
bitmap live = BITMAP_ALLOC (&df_bitmap_obstack); bitmap_head live, do_not_gen, artificial_uses;
bitmap do_not_gen = BITMAP_ALLOC (&df_bitmap_obstack);
bitmap artificial_uses = BITMAP_ALLOC (&df_bitmap_obstack); bitmap_initialize (&live, &df_bitmap_obstack);
bitmap_initialize (&do_not_gen, &df_bitmap_obstack);
bitmap_initialize (&artificial_uses, &df_bitmap_obstack);
#ifdef REG_DEAD_DEBUGGING #ifdef REG_DEAD_DEBUGGING
if (dump_file) if (dump_file)
...@@ -3819,12 +3820,12 @@ df_note_compute (bitmap all_blocks) ...@@ -3819,12 +3820,12 @@ df_note_compute (bitmap all_blocks)
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi) EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{ {
df_note_bb_compute (bb_index, live, do_not_gen, artificial_uses); df_note_bb_compute (bb_index, &live, &do_not_gen, &artificial_uses);
} }
BITMAP_FREE (live); bitmap_clear (&live);
BITMAP_FREE (do_not_gen); bitmap_clear (&do_not_gen);
BITMAP_FREE (artificial_uses); bitmap_clear (&artificial_uses);
} }
...@@ -4191,7 +4192,7 @@ df_simulate_one_insn_forwards (basic_block bb, rtx insn, bitmap live) ...@@ -4191,7 +4192,7 @@ df_simulate_one_insn_forwards (basic_block bb, rtx insn, bitmap live)
/* Scratch var used by transfer functions. This is used to do md analysis /* Scratch var used by transfer functions. This is used to do md analysis
only for live registers. */ only for live registers. */
static bitmap df_md_scratch; static bitmap_head df_md_scratch;
/* Set basic block info. */ /* Set basic block info. */
...@@ -4236,7 +4237,7 @@ df_md_alloc (bitmap all_blocks) ...@@ -4236,7 +4237,7 @@ df_md_alloc (bitmap all_blocks)
sizeof (struct df_md_bb_info), 50); sizeof (struct df_md_bb_info), 50);
df_grow_bb_info (df_md); df_grow_bb_info (df_md);
df_md_scratch = BITMAP_ALLOC (NULL); bitmap_initialize (&df_md_scratch, &bitmap_default_obstack);
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi) EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{ {
...@@ -4320,7 +4321,7 @@ df_md_bb_local_compute_process_def (struct df_md_bb_info *bb_info, ...@@ -4320,7 +4321,7 @@ df_md_bb_local_compute_process_def (struct df_md_bb_info *bb_info,
int top_flag) int top_flag)
{ {
df_ref def; df_ref def;
bitmap_clear (seen_in_insn); bitmap_clear (&seen_in_insn);
while ((def = *def_rec++) != NULL) while ((def = *def_rec++) != NULL)
{ {
...@@ -4329,7 +4330,7 @@ df_md_bb_local_compute_process_def (struct df_md_bb_info *bb_info, ...@@ -4329,7 +4330,7 @@ df_md_bb_local_compute_process_def (struct df_md_bb_info *bb_info,
|| (dregno >= FIRST_PSEUDO_REGISTER)) || (dregno >= FIRST_PSEUDO_REGISTER))
&& top_flag == (DF_REF_FLAGS (def) & DF_REF_AT_TOP)) && top_flag == (DF_REF_FLAGS (def) & DF_REF_AT_TOP))
{ {
if (!bitmap_bit_p (seen_in_insn, dregno)) if (!bitmap_bit_p (&seen_in_insn, dregno))
{ {
if (DF_REF_FLAGS (def) if (DF_REF_FLAGS (def)
& (DF_REF_PARTIAL | DF_REF_CONDITIONAL | DF_REF_MAY_CLOBBER)) & (DF_REF_PARTIAL | DF_REF_CONDITIONAL | DF_REF_MAY_CLOBBER))
...@@ -4341,7 +4342,7 @@ df_md_bb_local_compute_process_def (struct df_md_bb_info *bb_info, ...@@ -4341,7 +4342,7 @@ df_md_bb_local_compute_process_def (struct df_md_bb_info *bb_info,
{ {
/* When we find a clobber and a regular def, /* When we find a clobber and a regular def,
make sure the regular def wins. */ make sure the regular def wins. */
bitmap_set_bit (seen_in_insn, dregno); bitmap_set_bit (&seen_in_insn, dregno);
bitmap_set_bit (&bb_info->kill, dregno); bitmap_set_bit (&bb_info->kill, dregno);
bitmap_clear_bit (&bb_info->gen, dregno); bitmap_clear_bit (&bb_info->gen, dregno);
} }
...@@ -4391,14 +4392,14 @@ df_md_local_compute (bitmap all_blocks) ...@@ -4391,14 +4392,14 @@ df_md_local_compute (bitmap all_blocks)
basic_block bb; basic_block bb;
bitmap *frontiers; bitmap *frontiers;
seen_in_insn = BITMAP_ALLOC (NULL); bitmap_initialize (&seen_in_insn, &bitmap_default_obstack);
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi1) EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi1)
{ {
df_md_bb_local_compute (bb_index); df_md_bb_local_compute (bb_index);
} }
BITMAP_FREE (seen_in_insn); bitmap_clear (&seen_in_insn);
frontiers = XNEWVEC (bitmap, last_basic_block); frontiers = XNEWVEC (bitmap, last_basic_block);
FOR_ALL_BB (bb) FOR_ALL_BB (bb)
...@@ -4455,13 +4456,13 @@ df_md_transfer_function (int bb_index) ...@@ -4455,13 +4456,13 @@ df_md_transfer_function (int bb_index)
/* We need to use a scratch set here so that the value returned from this /* We need to use a scratch set here so that the value returned from this
function invocation properly reflects whether the sets changed in a function invocation properly reflects whether the sets changed in a
significant way; i.e. not just because the live set was anded in. */ significant way; i.e. not just because the live set was anded in. */
bitmap_and (df_md_scratch, gen, df_get_live_out (bb)); bitmap_and (&df_md_scratch, gen, df_get_live_out (bb));
/* Multiple definitions of a register are not relevant if it is not /* Multiple definitions of a register are not relevant if it is not
live. Thus we trim the result to the places where it is live. */ live. Thus we trim the result to the places where it is live. */
bitmap_and_into (in, df_get_live_in (bb)); bitmap_and_into (in, df_get_live_in (bb));
return bitmap_ior_and_compl (out, df_md_scratch, in, kill); return bitmap_ior_and_compl (out, &df_md_scratch, in, kill);
} }
/* Initialize the solution bit vectors for problem. */ /* Initialize the solution bit vectors for problem. */
...@@ -4524,7 +4525,7 @@ df_md_free (void) ...@@ -4524,7 +4525,7 @@ df_md_free (void)
} }
} }
BITMAP_FREE (df_md_scratch); bitmap_clear (&df_md_scratch);
free_alloc_pool (df_md->block_pool); free_alloc_pool (df_md->block_pool);
df_md->block_info_size = 0; df_md->block_info_size = 0;
......
gcc/tree-ssa-pre.c
...@@ -356,15 +356,15 @@ static bool in_fre = false; ...@@ -356,15 +356,15 @@ static bool in_fre = false;
expressions. */ expressions. */
typedef struct bitmap_set typedef struct bitmap_set
{ {
bitmap expressions; bitmap_head expressions;
bitmap values; bitmap_head values;
} *bitmap_set_t; } *bitmap_set_t;
#define FOR_EACH_EXPR_ID_IN_SET(set, id, bi) \ #define FOR_EACH_EXPR_ID_IN_SET(set, id, bi) \
EXECUTE_IF_SET_IN_BITMAP((set)->expressions, 0, (id), (bi)) EXECUTE_IF_SET_IN_BITMAP(&(set)->expressions, 0, (id), (bi))
#define FOR_EACH_VALUE_ID_IN_SET(set, id, bi) \ #define FOR_EACH_VALUE_ID_IN_SET(set, id, bi) \
EXECUTE_IF_SET_IN_BITMAP((set)->values, 0, (id), (bi)) EXECUTE_IF_SET_IN_BITMAP(&(set)->values, 0, (id), (bi))
/* Mapping from value id to expressions with that value_id. */ /* Mapping from value id to expressions with that value_id. */
DEF_VEC_P (bitmap_set_t); DEF_VEC_P (bitmap_set_t);
...@@ -615,8 +615,8 @@ static bitmap_set_t ...@@ -615,8 +615,8 @@ static bitmap_set_t
bitmap_set_new (void) bitmap_set_new (void)
{ {
bitmap_set_t ret = (bitmap_set_t) pool_alloc (bitmap_set_pool); bitmap_set_t ret = (bitmap_set_t) pool_alloc (bitmap_set_pool);
ret->expressions = BITMAP_ALLOC (&grand_bitmap_obstack); bitmap_initialize (&ret->expressions, &grand_bitmap_obstack);
ret->values = BITMAP_ALLOC (&grand_bitmap_obstack); bitmap_initialize (&ret->values, &grand_bitmap_obstack);
return ret; return ret;
} }
...@@ -657,8 +657,8 @@ bitmap_remove_from_set (bitmap_set_t set, pre_expr expr) ...@@ -657,8 +657,8 @@ bitmap_remove_from_set (bitmap_set_t set, pre_expr expr)
unsigned int val = get_expr_value_id (expr); unsigned int val = get_expr_value_id (expr);
if (!value_id_constant_p (val)) if (!value_id_constant_p (val))
{ {
bitmap_clear_bit (set->values, val); bitmap_clear_bit (&set->values, val);
bitmap_clear_bit (set->expressions, get_expression_id (expr)); bitmap_clear_bit (&set->expressions, get_expression_id (expr));
} }
} }
...@@ -670,8 +670,8 @@ bitmap_insert_into_set_1 (bitmap_set_t set, pre_expr expr, ...@@ -670,8 +670,8 @@ bitmap_insert_into_set_1 (bitmap_set_t set, pre_expr expr,
{ {
/* We specifically expect this and only this function to be able to /* We specifically expect this and only this function to be able to
insert constants into a set. */ insert constants into a set. */
bitmap_set_bit (set->values, val); bitmap_set_bit (&set->values, val);
bitmap_set_bit (set->expressions, get_or_alloc_expression_id (expr)); bitmap_set_bit (&set->expressions, get_or_alloc_expression_id (expr));
} }
} }
...@@ -688,8 +688,8 @@ bitmap_insert_into_set (bitmap_set_t set, pre_expr expr) ...@@ -688,8 +688,8 @@ bitmap_insert_into_set (bitmap_set_t set, pre_expr expr)
static void static void
bitmap_set_copy (bitmap_set_t dest, bitmap_set_t orig) bitmap_set_copy (bitmap_set_t dest, bitmap_set_t orig)
{ {
bitmap_copy (dest->expressions, orig->expressions); bitmap_copy (&dest->expressions, &orig->expressions);
bitmap_copy (dest->values, orig->values); bitmap_copy (&dest->values, &orig->values);
} }
...@@ -697,8 +697,8 @@ bitmap_set_copy (bitmap_set_t dest, bitmap_set_t orig) ...@@ -697,8 +697,8 @@ bitmap_set_copy (bitmap_set_t dest, bitmap_set_t orig)
static void static void
bitmap_set_free (bitmap_set_t set) bitmap_set_free (bitmap_set_t set)
{ {
BITMAP_FREE (set->expressions); bitmap_clear (&set->expressions);
BITMAP_FREE (set->values); bitmap_clear (&set->values);
} }
...@@ -712,7 +712,7 @@ sorted_array_from_bitmap_set (bitmap_set_t set) ...@@ -712,7 +712,7 @@ sorted_array_from_bitmap_set (bitmap_set_t set)
VEC(pre_expr, heap) *result; VEC(pre_expr, heap) *result;
/* Pre-allocate roughly enough space for the array. */ /* Pre-allocate roughly enough space for the array. */
result = VEC_alloc (pre_expr, heap, bitmap_count_bits (set->values)); result = VEC_alloc (pre_expr, heap, bitmap_count_bits (&set->values));
FOR_EACH_VALUE_ID_IN_SET (set, i, bi) FOR_EACH_VALUE_ID_IN_SET (set, i, bi)
{ {
...@@ -729,7 +729,7 @@ sorted_array_from_bitmap_set (bitmap_set_t set) ...@@ -729,7 +729,7 @@ sorted_array_from_bitmap_set (bitmap_set_t set)
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, i); bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, i);
FOR_EACH_EXPR_ID_IN_SET (exprset, j, bj) FOR_EACH_EXPR_ID_IN_SET (exprset, j, bj)
{ {
if (bitmap_bit_p (set->expressions, j)) if (bitmap_bit_p (&set->expressions, j))
VEC_safe_push (pre_expr, heap, result, expression_for_id (j)); VEC_safe_push (pre_expr, heap, result, expression_for_id (j));
} }
} }
...@@ -747,18 +747,19 @@ bitmap_set_and (bitmap_set_t dest, bitmap_set_t orig) ...@@ -747,18 +747,19 @@ bitmap_set_and (bitmap_set_t dest, bitmap_set_t orig)
if (dest != orig) if (dest != orig)
{ {
bitmap temp = BITMAP_ALLOC (&grand_bitmap_obstack); bitmap_head temp;
bitmap_initialize (&temp, &grand_bitmap_obstack);
bitmap_and_into (dest->values, orig->values); bitmap_and_into (&dest->values, &orig->values);
bitmap_copy (temp, dest->expressions); bitmap_copy (&temp, &dest->expressions);
EXECUTE_IF_SET_IN_BITMAP (temp, 0, i, bi) EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi)
{ {
pre_expr expr = expression_for_id (i); pre_expr expr = expression_for_id (i);
unsigned int value_id = get_expr_value_id (expr); unsigned int value_id = get_expr_value_id (expr);
if (!bitmap_bit_p (dest->values, value_id)) if (!bitmap_bit_p (&dest->values, value_id))
bitmap_clear_bit (dest->expressions, i); bitmap_clear_bit (&dest->expressions, i);
} }
BITMAP_FREE (temp); bitmap_clear (&temp);
} }
} }
...@@ -771,14 +772,14 @@ bitmap_set_subtract (bitmap_set_t dest, bitmap_set_t orig) ...@@ -771,14 +772,14 @@ bitmap_set_subtract (bitmap_set_t dest, bitmap_set_t orig)
bitmap_iterator bi; bitmap_iterator bi;
unsigned int i; unsigned int i;
bitmap_and_compl (result->expressions, dest->expressions, bitmap_and_compl (&result->expressions, &dest->expressions,
orig->expressions); &orig->expressions);
FOR_EACH_EXPR_ID_IN_SET (result, i, bi) FOR_EACH_EXPR_ID_IN_SET (result, i, bi)
{ {
pre_expr expr = expression_for_id (i); pre_expr expr = expression_for_id (i);
unsigned int value_id = get_expr_value_id (expr); unsigned int value_id = get_expr_value_id (expr);
bitmap_set_bit (result->values, value_id); bitmap_set_bit (&result->values, value_id);
} }
return result; return result;
...@@ -791,16 +792,18 @@ bitmap_set_subtract_values (bitmap_set_t a, bitmap_set_t b) ...@@ -791,16 +792,18 @@ bitmap_set_subtract_values (bitmap_set_t a, bitmap_set_t b)
{ {
unsigned int i; unsigned int i;
bitmap_iterator bi; bitmap_iterator bi;
bitmap temp = BITMAP_ALLOC (&grand_bitmap_obstack); bitmap_head temp;
bitmap_copy (temp, a->expressions); bitmap_initialize (&temp, &grand_bitmap_obstack);
EXECUTE_IF_SET_IN_BITMAP (temp, 0, i, bi)
bitmap_copy (&temp, &a->expressions);
EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi)
{ {
pre_expr expr = expression_for_id (i); pre_expr expr = expression_for_id (i);
if (bitmap_set_contains_value (b, get_expr_value_id (expr))) if (bitmap_set_contains_value (b, get_expr_value_id (expr)))
bitmap_remove_from_set (a, expr); bitmap_remove_from_set (a, expr);
} }
BITMAP_FREE (temp); bitmap_clear (&temp);
} }
...@@ -812,16 +815,16 @@ bitmap_set_contains_value (bitmap_set_t set, unsigned int value_id) ...@@ -812,16 +815,16 @@ bitmap_set_contains_value (bitmap_set_t set, unsigned int value_id)
if (value_id_constant_p (value_id)) if (value_id_constant_p (value_id))
return true; return true;
if (!set || bitmap_empty_p (set->expressions)) if (!set || bitmap_empty_p (&set->expressions))
return false; return false;
return bitmap_bit_p (set->values, value_id); return bitmap_bit_p (&set->values, value_id);
} }
static inline bool static inline bool
bitmap_set_contains_expr (bitmap_set_t set, const pre_expr expr) bitmap_set_contains_expr (bitmap_set_t set, const pre_expr expr)
{ {
return bitmap_bit_p (set->expressions, get_expression_id (expr)); return bitmap_bit_p (&set->expressions, get_expression_id (expr));
} }
/* Replace an instance of value LOOKFOR with expression EXPR in SET. */ /* Replace an instance of value LOOKFOR with expression EXPR in SET. */
...@@ -852,10 +855,10 @@ bitmap_set_replace_value (bitmap_set_t set, unsigned int lookfor, ...@@ -852,10 +855,10 @@ bitmap_set_replace_value (bitmap_set_t set, unsigned int lookfor,
exprset = VEC_index (bitmap_set_t, value_expressions, lookfor); exprset = VEC_index (bitmap_set_t, value_expressions, lookfor);
FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi) FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
{ {
if (bitmap_bit_p (set->expressions, i)) if (bitmap_bit_p (&set->expressions, i))
{ {
bitmap_clear_bit (set->expressions, i); bitmap_clear_bit (&set->expressions, i);
bitmap_set_bit (set->expressions, get_expression_id (expr)); bitmap_set_bit (&set->expressions, get_expression_id (expr));
return; return;
} }
} }
...@@ -866,7 +869,7 @@ bitmap_set_replace_value (bitmap_set_t set, unsigned int lookfor, ...@@ -866,7 +869,7 @@ bitmap_set_replace_value (bitmap_set_t set, unsigned int lookfor,
static bool static bool
bitmap_set_equal (bitmap_set_t a, bitmap_set_t b) bitmap_set_equal (bitmap_set_t a, bitmap_set_t b)
{ {
return bitmap_equal_p (a->values, b->values); return bitmap_equal_p (&a->values, &b->values);
} }
/* Replace an instance of EXPR's VALUE with EXPR in SET if it exists, /* Replace an instance of EXPR's VALUE with EXPR in SET if it exists,
...@@ -900,8 +903,8 @@ bitmap_value_insert_into_set (bitmap_set_t set, pre_expr expr) ...@@ -900,8 +903,8 @@ bitmap_value_insert_into_set (bitmap_set_t set, pre_expr expr)
return; return;
/* If the value membership changed, add the expression. */ /* If the value membership changed, add the expression. */
if (bitmap_set_bit (set->values, val)) if (bitmap_set_bit (&set->values, val))
bitmap_set_bit (set->expressions, expr->id); bitmap_set_bit (&set->expressions, expr->id);
} }
/* Print out EXPR to outfile. */ /* Print out EXPR to outfile. */
...@@ -1870,8 +1873,8 @@ bitmap_find_leader (bitmap_set_t set, unsigned int val, gimple stmt) ...@@ -1870,8 +1873,8 @@ bitmap_find_leader (bitmap_set_t set, unsigned int val, gimple stmt)
bitmap_iterator bi; bitmap_iterator bi;
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, val); bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, val);
EXECUTE_IF_AND_IN_BITMAP (exprset->expressions, EXECUTE_IF_AND_IN_BITMAP (&exprset->expressions,
set->expressions, 0, i, bi) &set->expressions, 0, i, bi)
{ {
pre_expr val = expression_for_id (i); pre_expr val = expression_for_id (i);
/* At the point where stmt is not null, there should always /* At the point where stmt is not null, there should always
...@@ -2291,8 +2294,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge) ...@@ -2291,8 +2294,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
clean (ANTIC_IN (block), block); clean (ANTIC_IN (block), block);
/* !old->expressions can happen when we deferred a block. */ if (!bitmap_set_equal (old, ANTIC_IN (block)))
if (!old->expressions || !bitmap_set_equal (old, ANTIC_IN (block)))
{ {
changed = true; changed = true;
SET_BIT (changed_blocks, block->index); SET_BIT (changed_blocks, block->index);
...@@ -2367,7 +2369,7 @@ compute_partial_antic_aux (basic_block block, ...@@ -2367,7 +2369,7 @@ compute_partial_antic_aux (basic_block block,
before the translation starts. */ before the translation starts. */
if (max_pa if (max_pa
&& single_succ_p (block) && single_succ_p (block)
&& bitmap_count_bits (PA_IN (single_succ (block))->values) > max_pa) && bitmap_count_bits (&PA_IN (single_succ (block))->values) > max_pa)
goto maybe_dump_sets; goto maybe_dump_sets;
old_PA_IN = PA_IN (block); old_PA_IN = PA_IN (block);
...@@ -2437,8 +2439,8 @@ compute_partial_antic_aux (basic_block block, ...@@ -2437,8 +2439,8 @@ compute_partial_antic_aux (basic_block block,
/* For partial antic, we want to put back in the phi results, since /* For partial antic, we want to put back in the phi results, since
we will properly avoid making them partially antic over backedges. */ we will properly avoid making them partially antic over backedges. */
bitmap_ior_into (PA_IN (block)->values, PHI_GEN (block)->values); bitmap_ior_into (&PA_IN (block)->values, &PHI_GEN (block)->values);
bitmap_ior_into (PA_IN (block)->expressions, PHI_GEN (block)->expressions); bitmap_ior_into (&PA_IN (block)->expressions, &PHI_GEN (block)->expressions);
/* PA_IN[block] = PA_IN[block] - ANTIC_IN[block] */ /* PA_IN[block] = PA_IN[block] - ANTIC_IN[block] */
bitmap_set_subtract_values (PA_IN (block), ANTIC_IN (block)); bitmap_set_subtract_values (PA_IN (block), ANTIC_IN (block));
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment