static void
prop_phis (basic_block b)
{
gimple_stmt_iterator psi;
gimple_seq phis = phi_nodes (b);
for (psi = gsi_start (phis); !gsi_end_p (psi); )
{
gimple phi = gsi_stmt (psi);
tree def = gimple_phi_result (phi), use = gimple_phi_arg_def (phi, 0);
gcc_assert (gimple_phi_num_args (phi) == 1);
if (!is_gimple_reg (def))
{
imm_use_iterator iter;
use_operand_p use_p;
gimple stmt;
FOR_EACH_IMM_USE_STMT (stmt, iter, def)
FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
SET_USE (use_p, use);
}
else
replace_uses_by (def, use);
remove_phi_node (&psi, true);
}
}
void
remove_phi_nodes (basic_block bb)
{
gimple_stmt_iterator gsi;
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
remove_phi_node (&gsi, true);
set_phi_nodes (bb, NULL);
}
static bool
generate_loops_for_partition (struct loop *loop, bitmap partition, bool copy_p)
{
unsigned i, x;
gimple_stmt_iterator bsi;
basic_block *bbs;
if (copy_p)
{
loop = copy_loop_before (loop);
create_preheader (loop, CP_SIMPLE_PREHEADERS);
create_bb_after_loop (loop);
}
if (loop == NULL)
return false;
/* Remove stmts not in the PARTITION bitmap. The order in which we
visit the phi nodes and the statements is exactly as in
stmts_from_loop. */
bbs = get_loop_body_in_dom_order (loop);
for (x = 0, i = 0; i < loop->num_nodes; i++)
{
basic_block bb = bbs[i];
for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi);)
if (!bitmap_bit_p (partition, x++))
{
gimple phi = gsi_stmt (bsi);
if (!is_gimple_reg (gimple_phi_result (phi)))
mark_virtual_phi_result_for_renaming (phi);
remove_phi_node (&bsi, true);
}
else
gsi_next (&bsi);
for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi);)
{
gimple stmt = gsi_stmt (bsi);
if (gimple_code (gsi_stmt (bsi)) != GIMPLE_LABEL
&& !bitmap_bit_p (partition, x++))
{
unlink_stmt_vdef (stmt);
gsi_remove (&bsi, true);
release_defs (stmt);
}
else
gsi_next (&bsi);
}
}
free (bbs);
return true;
}
static void
shrink_wrap_one_built_in_call_with_conds (gcall *bi_call, vec <gimple *> conds,
unsigned int nconds)
{
gimple_stmt_iterator bi_call_bsi;
basic_block bi_call_bb, join_tgt_bb, guard_bb;
edge join_tgt_in_edge_from_call, join_tgt_in_edge_fall_thru;
edge bi_call_in_edge0, guard_bb_in_edge;
unsigned tn_cond_stmts;
unsigned ci;
gimple *cond_expr = NULL;
gimple *cond_expr_start;
/* The cfg we want to create looks like this:
[guard n-1] <- guard_bb (old block)
| \
| [guard n-2] }
| / \ }
| / ... } new blocks
| / [guard 0] }
| / / | }
[ call ] | <- bi_call_bb }
| \ |
| \ |
| [ join ] <- join_tgt_bb (old iff call must end bb)
|
possible EH edges (only if [join] is old)
When [join] is new, the immediate dominators for these blocks are:
1. [guard n-1]: unchanged
2. [call]: [guard n-1]
3. [guard m]: [guard m+1] for 0 <= m <= n-2
4. [join]: [guard n-1]
We punt for the more complex case case of [join] being old and
simply free the dominance info. We also punt on postdominators,
which aren't expected to be available at this point anyway. */
bi_call_bb = gimple_bb (bi_call);
/* Now find the join target bb -- split bi_call_bb if needed. */
if (stmt_ends_bb_p (bi_call))
{
/* We checked that there was a fallthrough edge in
can_guard_call_p. */
join_tgt_in_edge_from_call = find_fallthru_edge (bi_call_bb->succs);
gcc_assert (join_tgt_in_edge_from_call);
/* We don't want to handle PHIs. */
if (EDGE_COUNT (join_tgt_in_edge_from_call->dest->preds) > 1)
join_tgt_bb = split_edge (join_tgt_in_edge_from_call);
else
{
join_tgt_bb = join_tgt_in_edge_from_call->dest;
/* We may have degenerate PHIs in the destination. Propagate
those out. */
for (gphi_iterator i = gsi_start_phis (join_tgt_bb); !gsi_end_p (i);)
{
gphi *phi = i.phi ();
replace_uses_by (gimple_phi_result (phi),
gimple_phi_arg_def (phi, 0));
remove_phi_node (&i, true);
}
}
}
else
{
join_tgt_in_edge_from_call = split_block (bi_call_bb, bi_call);
join_tgt_bb = join_tgt_in_edge_from_call->dest;
}
bi_call_bsi = gsi_for_stmt (bi_call);
/* Now it is time to insert the first conditional expression
into bi_call_bb and split this bb so that bi_call is
shrink-wrapped. */
tn_cond_stmts = conds.length ();
cond_expr = NULL;
cond_expr_start = conds[0];
for (ci = 0; ci < tn_cond_stmts; ci++)
{
gimple *c = conds[ci];
gcc_assert (c || ci != 0);
if (!c)
break;
gsi_insert_before (&bi_call_bsi, c, GSI_SAME_STMT);
cond_expr = c;
}
ci++;
gcc_assert (cond_expr && gimple_code (cond_expr) == GIMPLE_COND);
typedef std::pair<edge, edge> edge_pair;
auto_vec<edge_pair, 8> edges;
bi_call_in_edge0 = split_block (bi_call_bb, cond_expr);
bi_call_in_edge0->flags &= ~EDGE_FALLTHRU;
bi_call_in_edge0->flags |= EDGE_FALSE_VALUE;
guard_bb = bi_call_bb;
bi_call_bb = bi_call_in_edge0->dest;
join_tgt_in_edge_fall_thru = make_edge (guard_bb, join_tgt_bb,
EDGE_TRUE_VALUE);
edges.reserve (nconds);
edges.quick_push (edge_pair (bi_call_in_edge0, join_tgt_in_edge_fall_thru));
/* Code generation for the rest of the conditions */
for (unsigned int i = 1; i < nconds; ++i)
{
unsigned ci0;
edge bi_call_in_edge;
gimple_stmt_iterator guard_bsi = gsi_for_stmt (cond_expr_start);
ci0 = ci;
cond_expr_start = conds[ci0];
for (; ci < tn_cond_stmts; ci++)
{
gimple *c = conds[ci];
gcc_assert (c || ci != ci0);
if (!c)
break;
gsi_insert_before (&guard_bsi, c, GSI_SAME_STMT);
cond_expr = c;
}
ci++;
gcc_assert (cond_expr && gimple_code (cond_expr) == GIMPLE_COND);
guard_bb_in_edge = split_block (guard_bb, cond_expr);
guard_bb_in_edge->flags &= ~EDGE_FALLTHRU;
guard_bb_in_edge->flags |= EDGE_TRUE_VALUE;
bi_call_in_edge = make_edge (guard_bb, bi_call_bb, EDGE_FALSE_VALUE);
edges.quick_push (edge_pair (bi_call_in_edge, guard_bb_in_edge));
}
/* Now update the probability and profile information, processing the
guards in order of execution.
There are two approaches we could take here. On the one hand we
could assign a probability of X to the call block and distribute
that probability among its incoming edges. On the other hand we
could assign a probability of X to each individual call edge.
The choice only affects calls that have more than one condition.
In those cases, the second approach would give the call block
a greater probability than the first. However, the difference
is only small, and our chosen X is a pure guess anyway.
Here we take the second approach because it's slightly simpler
and because it's easy to see that it doesn't lose profile counts. */
bi_call_bb->count = profile_count::zero ();
while (!edges.is_empty ())
{
edge_pair e = edges.pop ();
edge call_edge = e.first;
edge nocall_edge = e.second;
basic_block src_bb = call_edge->src;
gcc_assert (src_bb == nocall_edge->src);
call_edge->probability = profile_probability::very_unlikely ();
nocall_edge->probability = profile_probability::always ()
- call_edge->probability;
bi_call_bb->count += call_edge->count ();
if (nocall_edge->dest != join_tgt_bb)
nocall_edge->dest->count = src_bb->count - bi_call_bb->count;
}
if (dom_info_available_p (CDI_DOMINATORS))
{
/* The split_blocks leave [guard 0] as the immediate dominator
of [call] and [call] as the immediate dominator of [join].
Fix them up. */
set_immediate_dominator (CDI_DOMINATORS, bi_call_bb, guard_bb);
set_immediate_dominator (CDI_DOMINATORS, join_tgt_bb, guard_bb);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
location_t loc;
loc = gimple_location (bi_call);
fprintf (dump_file,
"%s:%d: note: function call is shrink-wrapped"
" into error conditions.\n",
LOCATION_FILE (loc), LOCATION_LINE (loc));
}
}
