struct df_rd_bb_info *bb_info = (struct df_rd_bb_info *) vbb_info;
if (bb_info)
{
- if (bb_info->expanded_lr_out)
- BITMAP_FREE (bb_info->expanded_lr_out);
BITMAP_FREE (bb_info->kill);
BITMAP_FREE (bb_info->sparse_kill);
BITMAP_FREE (bb_info->gen);
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
if (bb_info)
{
- if (bb_info->expanded_lr_out)
- bitmap_clear (bb_info->expanded_lr_out);
bitmap_clear (bb_info->kill);
bitmap_clear (bb_info->sparse_kill);
bitmap_clear (bb_info->gen);
{
bb_info = (struct df_rd_bb_info *) pool_alloc (df_rd->block_pool);
df_rd_set_bb_info (bb_index, bb_info);
- if (df->changeable_flags & DF_RD_NO_TRIM)
- bb_info->expanded_lr_out = NULL;
- else
- bb_info->expanded_lr_out = BITMAP_ALLOC (&problem_data->rd_bitmaps);
bb_info->kill = BITMAP_ALLOC (&problem_data->rd_bitmaps);
bb_info->sparse_kill = BITMAP_ALLOC (&problem_data->rd_bitmaps);
bb_info->gen = BITMAP_ALLOC (&problem_data->rd_bitmaps);
/* Process a list of DEFs for df_rd_bb_local_compute. */
static void
-df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info,
+df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info,
struct df_ref **def_rec,
enum df_ref_flags top_flag)
{
- for (; *def_rec; def_rec++)
+ while (*def_rec)
{
struct df_ref *def = *def_rec;
- unsigned int regno = DF_REF_REGNO (def);
-
- /* This makes sure we do the artificial defs in the right order
- since they are all in the same list. */
- if (top_flag != (DF_REF_FLAGS (def) & DF_REF_AT_TOP))
- continue;
-
- /* Skip over the hard regs if we do not care about them. */
- if ((df->changeable_flags & DF_NO_HARD_REGS) &&
- (regno < FIRST_PSEUDO_REGISTER))
- continue;
-
- /* Only the last def(s) for a regno in the block has any
- effect. */
- if (bitmap_bit_p (seen_in_block, regno))
- continue;
-
- /* The first def for regno in insn gets to knock out the
- defs from other instructions. */
- if ((!bitmap_bit_p (seen_in_insn, regno))
- /* If the def is to only part of the reg, it does
- not kill the other defs that reach here. */
- && (!(DF_REF_FLAGS (def) &
- (DF_REF_PARTIAL | DF_REF_CONDITIONAL | DF_REF_MAY_CLOBBER))))
+ if (top_flag == (DF_REF_FLAGS (def) & DF_REF_AT_TOP))
{
+ unsigned int regno = DF_REF_REGNO (def);
unsigned int begin = DF_DEFS_BEGIN (regno);
unsigned int n_defs = DF_DEFS_COUNT (regno);
- if (n_defs > DF_SPARSE_THRESHOLD)
- bitmap_set_bit (bb_info->sparse_kill, regno);
- else
- bitmap_set_range (bb_info->kill, begin, n_defs);
- bitmap_clear_range(bb_info->gen, begin, n_defs);
+
+ if ((!(df->changeable_flags & DF_NO_HARD_REGS))
+ || (regno >= FIRST_PSEUDO_REGISTER))
+ {
+ /* Only the last def(s) for a regno in the block has any
+ effect. */
+ if (!bitmap_bit_p (seen_in_block, regno))
+ {
+ /* The first def for regno in insn gets to knock out the
+ defs from other instructions. */
+ if ((!bitmap_bit_p (seen_in_insn, regno))
+ /* If the def is to only part of the reg, it does
+ not kill the other defs that reach here. */
+ && (!(DF_REF_FLAGS (def) &
+ (DF_REF_PARTIAL | DF_REF_CONDITIONAL | DF_REF_MAY_CLOBBER))))
+ {
+ if (n_defs > DF_SPARSE_THRESHOLD)
+ {
+ bitmap_set_bit (bb_info->sparse_kill, regno);
+ bitmap_clear_range(bb_info->gen, begin, n_defs);
+ }
+ else
+ {
+ bitmap_set_range (bb_info->kill, begin, n_defs);
+ bitmap_clear_range (bb_info->gen, begin, n_defs);
+ }
+ }
+
+ bitmap_set_bit (seen_in_insn, regno);
+ /* All defs for regno in the instruction may be put into
+ the gen set. */
+ if (!(DF_REF_FLAGS (def)
+ & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER)))
+ bitmap_set_bit (bb_info->gen, DF_REF_ID (def));
+ }
+ }
}
-
- bitmap_set_bit (seen_in_insn, regno);
- /* All defs for regno in the instruction may be put into
- the gen set. */
- if (!(DF_REF_FLAGS (def)
- & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER)))
- bitmap_set_bit (bb_info->gen, DF_REF_ID (def));
+ def_rec++;
}
}
{
basic_block bb = BASIC_BLOCK (bb_index);
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
- struct df_lr_bb_info *lr_bb_info = df_lr_get_bb_info (bb_index);
rtx insn;
bitmap_clear (seen_in_block);
bitmap_clear (seen_in_insn);
- if (!(df->changeable_flags & DF_RD_NO_TRIM))
- {
- unsigned int regno;
- bitmap_iterator bi;
- int first_reg = (df->changeable_flags & DF_NO_HARD_REGS) ? FIRST_PSEUDO_REGISTER : 0;
- EXECUTE_IF_SET_IN_BITMAP (lr_bb_info->out, first_reg, regno, bi)
- {
- unsigned int begin = DF_DEFS_BEGIN (regno);
- unsigned int n_defs = DF_DEFS_COUNT (regno);
- bitmap_set_range (bb_info->expanded_lr_out, begin, n_defs);
- }
- }
-
/* Artificials are only hard regs. */
if (!(df->changeable_flags & DF_NO_HARD_REGS))
- df_rd_bb_local_compute_process_def (bb_info,
+ df_rd_bb_local_compute_process_def (bb_info,
df_get_artificial_defs (bb_index),
0);
if (e->flags & EDGE_FAKE)
return;
- /* If we are trimming the solution, the invalidated_by_call code in
- the lr problem makes this unnecessary. However, if we do not
- trim, we must take this into account. */
- if ((df->changeable_flags & DF_RD_NO_TRIM) && e->flags & EDGE_EH)
+ if (e->flags & EDGE_EH)
{
struct df_rd_problem_data *problem_data
= (struct df_rd_problem_data *) df_rd->problem_data;
bitmap dense_invalidated = problem_data->dense_invalidated_by_call;
bitmap_iterator bi;
unsigned int regno;
- bitmap tmp = BITMAP_ALLOC (&problem_data->rd_bitmaps);
+ bitmap tmp = BITMAP_ALLOC (&df_bitmap_obstack);
bitmap_copy (tmp, op2);
bitmap_and_compl_into (tmp, dense_invalidated);
bitmap gen = bb_info->gen;
bitmap kill = bb_info->kill;
bitmap sparse_kill = bb_info->sparse_kill;
- bool changed = false;
- if ((df->changeable_flags & DF_RD_NO_TRIM) && bitmap_empty_p (sparse_kill))
- changed = bitmap_ior_and_compl (out, gen, in, kill);
+ if (bitmap_empty_p (sparse_kill))
+ return bitmap_ior_and_compl (out, gen, in, kill);
else
{
struct df_rd_problem_data *problem_data;
+ bool changed = false;
bitmap tmp;
/* Note that TMP is _not_ a temporary bitmap if we end up replacing
}
bitmap_and_compl_into (tmp, kill);
bitmap_ior_into (tmp, gen);
- if (!(df->changeable_flags & DF_RD_NO_TRIM))
- bitmap_and_into (tmp, bb_info->expanded_lr_out);
changed = !bitmap_equal_p (tmp, out);
if (changed)
{
bb_info->out = tmp;
}
else
- BITMAP_FREE (tmp);
+ BITMAP_FREE (tmp);
+ return changed;
}
-
- return changed;
}
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (i);
if (bb_info)
{
- if (bb_info->expanded_lr_out)
- BITMAP_FREE (bb_info->expanded_lr_out);
BITMAP_FREE (bb_info->kill);
BITMAP_FREE (bb_info->sparse_kill);
BITMAP_FREE (bb_info->gen);
DF_LR_RUN_DCE = 1 << 0, /* Run DCE. */
DF_NO_HARD_REGS = 1 << 1, /* Skip hard registers in RD and CHAIN Building. */
- /* Do not trim the solution using the LR result. This can make the
- solution take much longer and take more memory. This is
- necessary for the loop optimizations, but has a very small time
- and space penalty because the loop optimizations process only a
- single loop at a time. Any pass that looks at the entire
- function should not set this flag. */
- DF_RD_NO_TRIM = 1 << 2,
- DF_EQ_NOTES = 1 << 3, /* Build chains with uses present in EQUIV/EQUAL notes. */
- DF_NO_REGS_EVER_LIVE = 1 << 4, /* Do not compute the regs_ever_live. */
+ DF_EQ_NOTES = 1 << 2, /* Build chains with uses present in EQUIV/EQUAL notes. */
+ DF_NO_REGS_EVER_LIVE = 1 << 3, /* Do not compute the regs_ever_live. */
/* Cause df_insn_rescan df_notes_rescan and df_insn_delete, to
return immediately. This is used by passes that know how to update
the scanning them selves. */
- DF_NO_INSN_RESCAN = 1 << 5,
+ DF_NO_INSN_RESCAN = 1 << 4,
/* Cause df_insn_rescan df_notes_rescan and df_insn_delete, to
return after marking the insn for later processing. This allows all
rescans to be batched. */
- DF_DEFER_INSN_RESCAN = 1 << 6,
+ DF_DEFER_INSN_RESCAN = 1 << 5,
- DF_VERIFY_SCHEDULED = 1 << 7
+ DF_VERIFY_SCHEDULED = 1 << 6
};
/* Two of these structures are inline in df, one for the uses and one
/* Local sets to describe the basic blocks. */
bitmap kill;
bitmap sparse_kill;
+ bitmap gen; /* The set of defs generated in this block. */
- /* Expanded version of the DF_LT->out bitmap to match the positions
- of gen, in and out here. Only allocated if DF_RD_NO_TRIM is
- false. */
- bitmap expanded_lr_out;
-
- /* The set of defs generated in this block. This is not set unless
- the def reaches the end of the block. */
- bitmap gen;
-
- /* The results of the dataflow problem.
-
- If DF_RD_NO_TRIM is not set, these sets are SOMEWHAT trimmed by
- the output of the DF_LR problem. The out set is precisely
- trimmed during propagation which means that the result is also
- trimmed when the propagation terminates. The in set is not
- explicitly trimmed, because this is expensive (adding about 5% to
- the cost of a bootstrap). However since the out sets are trimmed
- and the in sets are built from the out of the pred, the in set is
- MOSTLY trimmed.
-
- The counter case happens at a branch where the variable V is in
- DF_LR->in the true branch but not the false branch. If V is
- defined before the branch, RD will propagate that into the
- DF_RD_in sets of both branches. When the block is processed, the
- DF_RD->out set will have V trimmed out of it but it will still be
- left in DF_RD->in.
-
- If this not a problem for the current optimizers since they were
- designed before any trimming was available. This can be fixed by
- checking the DF_LR->in set directly. */
+ /* The results of the dataflow problem. */
bitmap in; /* At the top of the block. */
bitmap out; /* At the bottom of the block. */
};
projects / thirdparty / gcc.git / commitdiff
