/* Duplicate block BB2, placing it after BB in the CFG. Return the
newly created block. */
basic_block
transform_duplicate (basic_block bb, basic_block bb2)
{
edge e;
basic_block copy;
e = find_edge (bb, bb2);
copy = duplicate_block (bb2, e, bb);
flush_pending_stmts (e);
add_phi_args_after_copy (©, 1, NULL);
return (copy);
}
static void
create_block_for_threading (basic_block bb, struct redirection_data *rd)
{
edge_iterator ei;
edge e;
/* We can use the generic block duplication code and simply remove
the stuff we do not need. */
rd->dup_block = duplicate_block (bb, NULL, NULL);
FOR_EACH_EDGE (e, ei, rd->dup_block->succs)
e->aux = NULL;
/* Zero out the profile, since the block is unreachable for now. */
rd->dup_block->frequency = 0;
rd->dup_block->count = 0;
}
static bool
tail_duplicate (void)
{
fibnode_t *blocks = XCNEWVEC (fibnode_t, last_basic_block);
basic_block *trace = XNEWVEC (basic_block, n_basic_blocks);
int *counts = XNEWVEC (int, last_basic_block);
int ninsns = 0, nduplicated = 0;
gcov_type weighted_insns = 0, traced_insns = 0;
fibheap_t heap = fibheap_new ();
gcov_type cover_insns;
int max_dup_insns;
basic_block bb;
bool changed = false;
/* Create an oversized sbitmap to reduce the chance that we need to
resize it. */
bb_seen = sbitmap_alloc (last_basic_block * 2);
bitmap_clear (bb_seen);
initialize_original_copy_tables ();
if (profile_info && flag_branch_probabilities)
probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK);
else
probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY);
probability_cutoff = REG_BR_PROB_BASE / 100 * probability_cutoff;
branch_ratio_cutoff =
(REG_BR_PROB_BASE / 100 * PARAM_VALUE (TRACER_MIN_BRANCH_RATIO));
FOR_EACH_BB (bb)
{
int n = count_insns (bb);
if (!ignore_bb_p (bb))
blocks[bb->index] = fibheap_insert (heap, -bb->frequency,
bb);
counts [bb->index] = n;
ninsns += n;
weighted_insns += n * bb->frequency;
}
if (profile_info && flag_branch_probabilities)
cover_insns = PARAM_VALUE (TRACER_DYNAMIC_COVERAGE_FEEDBACK);
else
cover_insns = PARAM_VALUE (TRACER_DYNAMIC_COVERAGE);
cover_insns = (weighted_insns * cover_insns + 50) / 100;
max_dup_insns = (ninsns * PARAM_VALUE (TRACER_MAX_CODE_GROWTH) + 50) / 100;
while (traced_insns < cover_insns && nduplicated < max_dup_insns
&& !fibheap_empty (heap))
{
basic_block bb = (basic_block) fibheap_extract_min (heap);
int n, pos;
if (!bb)
break;
blocks[bb->index] = NULL;
if (ignore_bb_p (bb))
continue;
gcc_assert (!bb_seen_p (bb));
n = find_trace (bb, trace);
bb = trace[0];
traced_insns += bb->frequency * counts [bb->index];
if (blocks[bb->index])
{
fibheap_delete_node (heap, blocks[bb->index]);
blocks[bb->index] = NULL;
}
for (pos = 1; pos < n; pos++)
{
basic_block bb2 = trace[pos];
if (blocks[bb2->index])
{
fibheap_delete_node (heap, blocks[bb2->index]);
blocks[bb2->index] = NULL;
}
traced_insns += bb2->frequency * counts [bb2->index];
if (EDGE_COUNT (bb2->preds) > 1
&& can_duplicate_block_p (bb2)
/* We have the tendency to duplicate the loop header
of all do { } while loops. Do not do that - it is
not profitable and it might create a loop with multiple
entries or at least rotate the loop. */
&& (!current_loops
|| bb2->loop_father->header != bb2))
{
edge e;
basic_block copy;
nduplicated += counts [bb2->index];
e = find_edge (bb, bb2);
copy = duplicate_block (bb2, e, bb);
flush_pending_stmts (e);
add_phi_args_after_copy (©, 1, NULL);
/* Reconsider the original copy of block we've duplicated.
Removing the most common predecessor may make it to be
head. */
blocks[bb2->index] =
fibheap_insert (heap, -bb2->frequency, bb2);
if (dump_file)
fprintf (dump_file, "Duplicated %i as %i [%i]\n",
bb2->index, copy->index, copy->frequency);
bb2 = copy;
changed = true;
}
mark_bb_seen (bb2);
bb = bb2;
/* In case the trace became infrequent, stop duplicating. */
if (ignore_bb_p (bb))
break;
}
if (dump_file)
fprintf (dump_file, " covered now %.1f\n\n",
traced_insns * 100.0 / weighted_insns);
}
if (dump_file)
fprintf (dump_file, "Duplicated %i insns (%i%%)\n", nduplicated,
nduplicated * 100 / ninsns);
free_original_copy_tables ();
sbitmap_free (bb_seen);
free (blocks);
free (trace);
free (counts);
fibheap_delete (heap);
return changed;
}
static void
tail_duplicate (void)
{
fibnode_t *blocks = XCNEWVEC (fibnode_t, last_basic_block);
basic_block *trace = XNEWVEC (basic_block, n_basic_blocks);
int *counts = XNEWVEC (int, last_basic_block);
int ninsns = 0, nduplicated = 0;
gcov_type weighted_insns = 0, traced_insns = 0;
fibheap_t heap = fibheap_new ();
gcov_type cover_insns;
int max_dup_insns;
basic_block bb;
if (profile_info && flag_branch_probabilities)
probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK);
else
probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY);
probability_cutoff = REG_BR_PROB_BASE / 100 * probability_cutoff;
branch_ratio_cutoff =
(REG_BR_PROB_BASE / 100 * PARAM_VALUE (TRACER_MIN_BRANCH_RATIO));
FOR_EACH_BB (bb)
{
int n = count_insns (bb);
if (!ignore_bb_p (bb))
blocks[bb->index] = fibheap_insert (heap, -bb->frequency,
bb);
counts [bb->index] = n;
ninsns += n;
weighted_insns += n * bb->frequency;
}
if (profile_info && flag_branch_probabilities)
cover_insns = PARAM_VALUE (TRACER_DYNAMIC_COVERAGE_FEEDBACK);
else
cover_insns = PARAM_VALUE (TRACER_DYNAMIC_COVERAGE);
cover_insns = (weighted_insns * cover_insns + 50) / 100;
max_dup_insns = (ninsns * PARAM_VALUE (TRACER_MAX_CODE_GROWTH) + 50) / 100;
while (traced_insns < cover_insns && nduplicated < max_dup_insns
&& !fibheap_empty (heap))
{
basic_block bb = fibheap_extract_min (heap);
int n, pos;
if (!bb)
break;
blocks[bb->index] = NULL;
if (ignore_bb_p (bb))
continue;
gcc_assert (!seen (bb));
n = find_trace (bb, trace);
bb = trace[0];
traced_insns += bb->frequency * counts [bb->index];
if (blocks[bb->index])
{
fibheap_delete_node (heap, blocks[bb->index]);
blocks[bb->index] = NULL;
}
for (pos = 1; pos < n; pos++)
{
basic_block bb2 = trace[pos];
if (blocks[bb2->index])
{
fibheap_delete_node (heap, blocks[bb2->index]);
blocks[bb2->index] = NULL;
}
traced_insns += bb2->frequency * counts [bb2->index];
if (EDGE_COUNT (bb2->preds) > 1
&& can_duplicate_block_p (bb2))
{
edge e;
basic_block old = bb2;
e = find_edge (bb, bb2);
nduplicated += counts [bb2->index];
bb2 = duplicate_block (bb2, e, bb);
/* Reconsider the original copy of block we've duplicated.
Removing the most common predecessor may make it to be
head. */
blocks[old->index] =
fibheap_insert (heap, -old->frequency, old);
if (dump_file)
fprintf (dump_file, "Duplicated %i as %i [%i]\n",
old->index, bb2->index, bb2->frequency);
}
bb->aux = bb2;
bb2->il.rtl->visited = 1;
bb = bb2;
/* In case the trace became infrequent, stop duplicating. */
if (ignore_bb_p (bb))
break;
}
if (dump_file)
fprintf (dump_file, " covered now %.1f\n\n",
traced_insns * 100.0 / weighted_insns);
}
if (dump_file)
fprintf (dump_file, "Duplicated %i insns (%i%%)\n", nduplicated,
nduplicated * 100 / ninsns);
free (blocks);
free (trace);
free (counts);
fibheap_delete (heap);
}
basic_block
isolate_path (basic_block bb, basic_block duplicate,
edge e, gimple stmt, tree op)
{
gimple_stmt_iterator si, si2;
edge_iterator ei;
edge e2;
/* First duplicate BB if we have not done so already and remove all
the duplicate's outgoing edges as duplicate is going to unconditionally
trap. Removing the outgoing edges is both an optimization and ensures
we don't need to do any PHI node updates. */
if (!duplicate)
{
duplicate = duplicate_block (bb, NULL, NULL);
for (ei = ei_start (duplicate->succs); (e2 = ei_safe_edge (ei)); )
remove_edge (e2);
}
/* Complete the isolation step by redirecting E to reach DUPLICATE. */
e2 = redirect_edge_and_branch (e, duplicate);
if (e2)
flush_pending_stmts (e2);
/* There may be more than one statement in DUPLICATE which exhibits
undefined behaviour. Ultimately we want the first such statement in
DUPLCIATE so that we're able to delete as much code as possible.
So each time we discover undefined behaviour in DUPLICATE, search for
the statement which triggers undefined behaviour. If found, then
transform the statement into a trap and delete everything after the
statement. If not found, then this particular instance was subsumed by
an earlier instance of undefined behaviour and there's nothing to do.
This is made more complicated by the fact that we have STMT, which is in
BB rather than in DUPLICATE. So we set up two iterators, one for each
block and walk forward looking for STMT in BB, advancing each iterator at
each step.
When we find STMT the second iterator should point to STMT's equivalent in
duplicate. If DUPLICATE ends before STMT is found in BB, then there's
nothing to do.
Ignore labels and debug statements. */
si = gsi_start_nondebug_after_labels_bb (bb);
si2 = gsi_start_nondebug_after_labels_bb (duplicate);
while (!gsi_end_p (si) && !gsi_end_p (si2) && gsi_stmt (si) != stmt)
{
gsi_next_nondebug (&si);
gsi_next_nondebug (&si2);
}
/* This would be an indicator that we never found STMT in BB, which should
never happen. */
gcc_assert (!gsi_end_p (si));
/* If we did not run to the end of DUPLICATE, then SI points to STMT and
SI2 points to the duplicate of STMT in DUPLICATE. Insert a trap
before SI2 and remove SI2 and all trailing statements. */
if (!gsi_end_p (si2))
insert_trap_and_remove_trailing_statements (&si2, op);
return duplicate;
}