static basic_block
find_block_to_duplicate_for_splitting_paths (basic_block latch)
{
/* We should have simple latches at this point. So the latch should
have a single successor. This implies the predecessor of the latch
likely has the loop exit. And it's that predecessor we're most
interested in. To keep things simple, we're going to require that
the latch have a single predecessor too. */
if (single_succ_p (latch) && single_pred_p (latch))
{
basic_block bb = get_immediate_dominator (CDI_DOMINATORS, latch);
gcc_assert (single_pred_edge (latch)->src == bb);
/* If BB has been marked as not to be duplicated, then honor that
request. */
if (ignore_bb_p (bb))
return NULL;
gimple *last = gsi_stmt (gsi_last_nondebug_bb (bb));
/* The immediate dominator of the latch must end in a conditional. */
if (!last || gimple_code (last) != GIMPLE_COND)
return NULL;
/* We're hoping that BB is a join point for an IF-THEN-ELSE diamond
region. Verify that it is.
First, verify that BB has two predecessors (each arm of the
IF-THEN-ELSE) and two successors (the latch and exit). */
if (EDGE_COUNT (bb->preds) == 2 && EDGE_COUNT (bb->succs) == 2)
{
/* Now verify that BB's immediate dominator ends in a
conditional as well. */
basic_block bb_idom = get_immediate_dominator (CDI_DOMINATORS, bb);
gimple *last = gsi_stmt (gsi_last_nondebug_bb (bb_idom));
if (!last || gimple_code (last) != GIMPLE_COND)
return NULL;
/* And that BB's immediate dominator's successors are the
predecessors of BB. */
if (!find_edge (bb_idom, EDGE_PRED (bb, 0)->src)
|| !find_edge (bb_idom, EDGE_PRED (bb, 1)->src))
return NULL;
/* And that the predecessors of BB each have a single successor. */
if (!single_succ_p (EDGE_PRED (bb, 0)->src)
|| !single_succ_p (EDGE_PRED (bb, 1)->src))
return NULL;
/* So at this point we have a simple diamond for an IF-THEN-ELSE
construct starting at BB_IDOM, with a join point at BB. BB
pass control outside the loop or to the loop latch.
We're going to want to create two duplicates of BB, one for
each successor of BB_IDOM. */
return bb;
}
}
return NULL;
}
bool
potentially_threadable_block (basic_block bb)
{
gimple_stmt_iterator gsi;
/* Special case. We can get blocks that are forwarders, but are
not optimized away because they forward from outside a loop
to the loop header. We want to thread through them as we can
sometimes thread to the loop exit, which is obviously profitable.
the interesting case here is when the block has PHIs. */
if (gsi_end_p (gsi_start_nondebug_bb (bb))
&& !gsi_end_p (gsi_start_phis (bb)))
return true;
/* If BB has a single successor or a single predecessor, then
there is no threading opportunity. */
if (single_succ_p (bb) || single_pred_p (bb))
return false;
/* If BB does not end with a conditional, switch or computed goto,
then there is no threading opportunity. */
gsi = gsi_last_bb (bb);
if (gsi_end_p (gsi)
|| ! gsi_stmt (gsi)
|| (gimple_code (gsi_stmt (gsi)) != GIMPLE_COND
&& gimple_code (gsi_stmt (gsi)) != GIMPLE_GOTO
&& gimple_code (gsi_stmt (gsi)) != GIMPLE_SWITCH))
return false;
return true;
}
static void
naive_process_phi (hsa_insn_phi *phi, const vec<edge> &predecessors)
{
unsigned count = phi->operand_count ();
for (unsigned i = 0; i < count; i++)
{
gcc_checking_assert (phi->get_op (i));
hsa_op_base *op = phi->get_op (i);
hsa_bb *hbb;
edge e;
if (!op)
break;
e = predecessors[i];
if (single_succ_p (e->src))
hbb = hsa_bb_for_bb (e->src);
else
{
basic_block old_dest = e->dest;
hbb = hsa_init_new_bb (split_edge (e));
/* If switch insn used this edge, fix jump table. */
hsa_bb *source = hsa_bb_for_bb (e->src);
hsa_insn_sbr *sbr;
if (source->m_last_insn
&& (sbr = dyn_cast <hsa_insn_sbr *> (source->m_last_insn)))
sbr->replace_all_labels (old_dest, hbb->m_bb);
}
hsa_build_append_simple_mov (phi->m_dest, op, hbb);
}
}
static bool
forwarder_block_to (basic_block bb, basic_block to_bb)
{
return empty_block_p (bb)
&& single_succ_p (bb)
&& single_succ (bb) == to_bb;
}
static gbb_type
get_bb_type (basic_block bb, struct loop *last_loop)
{
vec<basic_block> dom;
int nb_dom;
struct loop *loop = bb->loop_father;
/* Check, if we entry into a new loop. */
if (loop != last_loop)
{
if (single_exit (loop) != NULL)
return GBB_LOOP_SING_EXIT_HEADER;
else if (loop->num != 0)
return GBB_LOOP_MULT_EXIT_HEADER;
else
return GBB_COND_HEADER;
}
dom = get_dominated_by (CDI_DOMINATORS, bb);
nb_dom = dom.length ();
dom.release ();
if (nb_dom == 0)
return GBB_LAST;
if (nb_dom == 1 && single_succ_p (bb))
return GBB_SIMPLE;
return GBB_COND_HEADER;
}
struct loops *
loop_optimizer_init (FILE *dumpfile)
{
struct loops *loops = xcalloc (1, sizeof (struct loops));
edge e;
edge_iterator ei;
static bool first_time = true;
if (first_time)
{
first_time = false;
init_set_costs ();
}
/* Avoid annoying special cases of edges going to exit
block. */
for (ei = ei_start (EXIT_BLOCK_PTR->preds); (e = ei_safe_edge (ei)); )
if ((e->flags & EDGE_FALLTHRU) && !single_succ_p (e->src))
split_edge (e);
else
ei_next (&ei);
/* Find the loops. */
if (flow_loops_find (loops) <= 1)
{
/* No loops. */
flow_loops_free (loops);
free (loops);
return NULL;
}
/* Not going to update these. */
free (loops->cfg.rc_order);
loops->cfg.rc_order = NULL;
free (loops->cfg.dfs_order);
loops->cfg.dfs_order = NULL;
/* Create pre-headers. */
create_preheaders (loops, CP_SIMPLE_PREHEADERS);
/* Force all latches to have only single successor. */
force_single_succ_latches (loops);
/* Mark irreducible loops. */
mark_irreducible_loops (loops);
/* Dump loops. */
flow_loops_dump (loops, dumpfile, NULL, 1);
#ifdef ENABLE_CHECKING
verify_dominators (CDI_DOMINATORS);
verify_loop_structure (loops);
#endif
return loops;
}
static bool
should_duplicate_loop_header_p (basic_block header, struct loop *loop,
int *limit)
{
gimple_stmt_iterator bsi;
gimple last;
/* Do not copy one block more than once (we do not really want to do
loop peeling here). */
if (header->aux)
return false;
/* Loop header copying usually increases size of the code. This used not to
be true, since quite often it is possible to verify that the condition is
satisfied in the first iteration and therefore to eliminate it. Jump
threading handles these cases now. */
if (optimize_loop_for_size_p (loop))
return false;
gcc_assert (EDGE_COUNT (header->succs) > 0);
if (single_succ_p (header))
return false;
if (flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 0)->dest)
&& flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 1)->dest))
return false;
/* If this is not the original loop header, we want it to have just
one predecessor in order to match the && pattern. */
if (header != loop->header && !single_pred_p (header))
return false;
last = last_stmt (header);
if (gimple_code (last) != GIMPLE_COND)
return false;
/* Approximately copy the conditions that used to be used in jump.c --
at most 20 insns and no calls. */
for (bsi = gsi_start_bb (header); !gsi_end_p (bsi); gsi_next (&bsi))
{
last = gsi_stmt (bsi);
if (gimple_code (last) == GIMPLE_LABEL)
continue;
if (is_gimple_debug (last))
continue;
if (is_gimple_call (last))
return false;
*limit -= estimate_num_insns (last, &eni_size_weights);
if (*limit < 0)
return false;
}
return true;
}
static bool
should_duplicate_loop_header_p (basic_block header, struct loop *loop,
int *limit)
{
block_stmt_iterator bsi;
tree last;
/* Do not copy one block more than once (we do not really want to do
loop peeling here). */
if (header->aux)
return false;
gcc_assert (EDGE_COUNT (header->succs) > 0);
if (single_succ_p (header))
return false;
if (flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 0)->dest)
&& flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 1)->dest))
return false;
/* If this is not the original loop header, we want it to have just
one predecessor in order to match the && pattern. */
if (header != loop->header && !single_pred_p (header))
return false;
last = last_stmt (header);
if (TREE_CODE (last) != COND_EXPR)
return false;
/* Approximately copy the conditions that used to be used in jump.c --
at most 20 insns and no calls. */
for (bsi = bsi_start (header); !bsi_end_p (bsi); bsi_next (&bsi))
{
last = bsi_stmt (bsi);
if (TREE_CODE (last) == LABEL_EXPR)
continue;
if (get_call_expr_in (last))
return false;
*limit -= estimate_num_insns (last);
if (*limit < 0)
return false;
}
return true;
}
/* Subtract COUNT and FREQUENCY from the basic block and it's
outgoing edge. */
static void
decrease_profile (basic_block bb, gcov_type count, int frequency)
{
edge e;
bb->count -= count;
if (bb->count < 0)
bb->count = 0;
bb->frequency -= frequency;
if (bb->frequency < 0)
bb->frequency = 0;
if (!single_succ_p (bb))
{
gcc_assert (!EDGE_COUNT (bb->succs));
return;
}
e = single_succ_edge (bb);
e->count -= count;
if (e->count < 0)
e->count = 0;
}
bool
potentially_threadable_block (basic_block bb)
{
gimple_stmt_iterator gsi;
/* If BB has a single successor or a single predecessor, then
there is no threading opportunity. */
if (single_succ_p (bb) || single_pred_p (bb))
return false;
/* If BB does not end with a conditional, switch or computed goto,
then there is no threading opportunity. */
gsi = gsi_last_bb (bb);
if (gsi_end_p (gsi)
|| ! gsi_stmt (gsi)
|| (gimple_code (gsi_stmt (gsi)) != GIMPLE_COND
&& gimple_code (gsi_stmt (gsi)) != GIMPLE_GOTO
&& gimple_code (gsi_stmt (gsi)) != GIMPLE_SWITCH))
return false;
return true;
}
bool
potentially_threadable_block (basic_block bb)
{
block_stmt_iterator bsi;
/* If BB has a single successor or a single predecessor, then
there is no threading opportunity. */
if (single_succ_p (bb) || single_pred_p (bb))
return false;
/* If BB does not end with a conditional, switch or computed goto,
then there is no threading opportunity. */
bsi = bsi_last (bb);
if (bsi_end_p (bsi)
|| ! bsi_stmt (bsi)
|| (TREE_CODE (bsi_stmt (bsi)) != COND_EXPR
&& TREE_CODE (bsi_stmt (bsi)) != GOTO_EXPR
&& TREE_CODE (bsi_stmt (bsi)) != SWITCH_EXPR))
return false;
return true;
}
static bool
should_duplicate_loop_header_p (basic_block header, struct loop *loop,
int *limit)
{
gimple_stmt_iterator bsi;
gimple *last;
gcc_assert (!header->aux);
/* Loop header copying usually increases size of the code. This used not to
be true, since quite often it is possible to verify that the condition is
satisfied in the first iteration and therefore to eliminate it. Jump
threading handles these cases now. */
if (optimize_loop_for_size_p (loop))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
" Not duplicating bb %i: optimizing for size.\n",
header->index);
return false;
}
gcc_assert (EDGE_COUNT (header->succs) > 0);
if (single_succ_p (header))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
" Not duplicating bb %i: it is single succ.\n",
header->index);
return false;
}
if (flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 0)->dest)
&& flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 1)->dest))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
" Not duplicating bb %i: both sucessors are in loop.\n",
loop->num);
return false;
}
/* If this is not the original loop header, we want it to have just
one predecessor in order to match the && pattern. */
if (header != loop->header && !single_pred_p (header))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
" Not duplicating bb %i: it has mutiple predecestors.\n",
header->index);
return false;
}
last = last_stmt (header);
if (gimple_code (last) != GIMPLE_COND)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
" Not duplicating bb %i: it does not end by conditional.\n",
header->index);
return false;
}
/* Count number of instructions and punt on calls. */
for (bsi = gsi_start_bb (header); !gsi_end_p (bsi); gsi_next (&bsi))
{
last = gsi_stmt (bsi);
if (gimple_code (last) == GIMPLE_LABEL)
continue;
if (is_gimple_debug (last))
continue;
if (gimple_code (last) == GIMPLE_CALL
&& !gimple_inexpensive_call_p (as_a <gcall *> (last)))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
" Not duplicating bb %i: it contains call.\n",
header->index);
return false;
}
*limit -= estimate_num_insns (last, &eni_size_weights);
if (*limit < 0)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
" Not duplicating bb %i contains too many insns.\n",
header->index);
return false;
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Will duplicate bb %i\n", header->index);
return true;
}
static void
find_tail_calls (basic_block bb, struct tailcall **ret)
{
tree ass_var = NULL_TREE, ret_var, func, param;
gimple stmt, call = NULL;
gimple_stmt_iterator gsi, agsi;
bool tail_recursion;
struct tailcall *nw;
edge e;
tree m, a;
basic_block abb;
size_t idx;
tree var;
if (!single_succ_p (bb))
return;
for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
{
stmt = gsi_stmt (gsi);
/* Ignore labels, returns, clobbers and debug stmts. */
if (gimple_code (stmt) == GIMPLE_LABEL
|| gimple_code (stmt) == GIMPLE_RETURN
|| gimple_clobber_p (stmt)
|| is_gimple_debug (stmt))
continue;
/* Check for a call. */
if (is_gimple_call (stmt))
{
call = stmt;
ass_var = gimple_call_lhs (stmt);
break;
}
/* If the statement references memory or volatile operands, fail. */
if (gimple_references_memory_p (stmt)
|| gimple_has_volatile_ops (stmt))
return;
}
if (gsi_end_p (gsi))
{
edge_iterator ei;
/* Recurse to the predecessors. */
FOR_EACH_EDGE (e, ei, bb->preds)
find_tail_calls (e->src, ret);
return;
}
/* If the LHS of our call is not just a simple register, we can't
transform this into a tail or sibling call. This situation happens,
in (e.g.) "*p = foo()" where foo returns a struct. In this case
we won't have a temporary here, but we need to carry out the side
effect anyway, so tailcall is impossible.
??? In some situations (when the struct is returned in memory via
invisible argument) we could deal with this, e.g. by passing 'p'
itself as that argument to foo, but it's too early to do this here,
and expand_call() will not handle it anyway. If it ever can, then
we need to revisit this here, to allow that situation. */
if (ass_var && !is_gimple_reg (ass_var))
return;
/* We found the call, check whether it is suitable. */
tail_recursion = false;
func = gimple_call_fndecl (call);
if (func
&& !DECL_BUILT_IN (func)
&& recursive_call_p (current_function_decl, func))
{
tree arg;
for (param = DECL_ARGUMENTS (func), idx = 0;
param && idx < gimple_call_num_args (call);
param = DECL_CHAIN (param), idx ++)
{
arg = gimple_call_arg (call, idx);
if (param != arg)
{
/* Make sure there are no problems with copying. The parameter
have a copyable type and the two arguments must have reasonably
equivalent types. The latter requirement could be relaxed if
we emitted a suitable type conversion statement. */
if (!is_gimple_reg_type (TREE_TYPE (param))
|| !useless_type_conversion_p (TREE_TYPE (param),
TREE_TYPE (arg)))
break;
/* The parameter should be a real operand, so that phi node
created for it at the start of the function has the meaning
of copying the value. This test implies is_gimple_reg_type
from the previous condition, however this one could be
relaxed by being more careful with copying the new value
of the parameter (emitting appropriate GIMPLE_ASSIGN and
updating the virtual operands). */
if (!is_gimple_reg (param))
break;
}
}
if (idx == gimple_call_num_args (call) && !param)
tail_recursion = true;
}
/* Make sure the tail invocation of this function does not refer
to local variables. */
FOR_EACH_LOCAL_DECL (cfun, idx, var)
{
if (TREE_CODE (var) != PARM_DECL
&& auto_var_in_fn_p (var, cfun->decl)
&& (ref_maybe_used_by_stmt_p (call, var)
|| call_may_clobber_ref_p (call, var)))
return;
}
/* Now check the statements after the call. None of them has virtual
operands, so they may only depend on the call through its return
value. The return value should also be dependent on each of them,
since we are running after dce. */
m = NULL_TREE;
a = NULL_TREE;
abb = bb;
agsi = gsi;
while (1)
{
tree tmp_a = NULL_TREE;
tree tmp_m = NULL_TREE;
gsi_next (&agsi);
while (gsi_end_p (agsi))
{
ass_var = propagate_through_phis (ass_var, single_succ_edge (abb));
abb = single_succ (abb);
agsi = gsi_start_bb (abb);
}
stmt = gsi_stmt (agsi);
if (gimple_code (stmt) == GIMPLE_LABEL)
continue;
if (gimple_code (stmt) == GIMPLE_RETURN)
break;
if (gimple_clobber_p (stmt))
continue;
if (is_gimple_debug (stmt))
continue;
if (gimple_code (stmt) != GIMPLE_ASSIGN)
return;
/* This is a gimple assign. */
if (! process_assignment (stmt, gsi, &tmp_m, &tmp_a, &ass_var))
return;
if (tmp_a)
{
tree type = TREE_TYPE (tmp_a);
if (a)
a = fold_build2 (PLUS_EXPR, type, fold_convert (type, a), tmp_a);
else
a = tmp_a;
}
if (tmp_m)
{
tree type = TREE_TYPE (tmp_m);
if (m)
m = fold_build2 (MULT_EXPR, type, fold_convert (type, m), tmp_m);
else
m = tmp_m;
if (a)
a = fold_build2 (MULT_EXPR, type, fold_convert (type, a), tmp_m);
}
}
/* See if this is a tail call we can handle. */
ret_var = gimple_return_retval (stmt);
/* We may proceed if there either is no return value, or the return value
is identical to the call's return. */
if (ret_var
&& (ret_var != ass_var))
return;
/* If this is not a tail recursive call, we cannot handle addends or
multiplicands. */
if (!tail_recursion && (m || a))
return;
/* For pointers only allow additions. */
if (m && POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl))))
return;
nw = XNEW (struct tailcall);
nw->call_gsi = gsi;
nw->tail_recursion = tail_recursion;
nw->mult = m;
nw->add = a;
nw->next = *ret;
*ret = nw;
}
static bool
gimple_find_edge_insert_loc (edge e, gimple_stmt_iterator *gsi,
basic_block *new_bb)
{
basic_block dest, src;
gimple *tmp;
dest = e->dest;
/* If the destination has one predecessor which has no PHI nodes,
insert there. Except for the exit block.
The requirement for no PHI nodes could be relaxed. Basically we
would have to examine the PHIs to prove that none of them used
the value set by the statement we want to insert on E. That
hardly seems worth the effort. */
restart:
if (single_pred_p (dest)
&& gimple_seq_empty_p (phi_nodes (dest))
&& dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
{
*gsi = gsi_start_bb (dest);
if (gsi_end_p (*gsi))
return true;
/* Make sure we insert after any leading labels. */
tmp = gsi_stmt (*gsi);
while (gimple_code (tmp) == GIMPLE_LABEL)
{
gsi_next (gsi);
if (gsi_end_p (*gsi))
break;
tmp = gsi_stmt (*gsi);
}
if (gsi_end_p (*gsi))
{
*gsi = gsi_last_bb (dest);
return true;
}
else
return false;
}
/* If the source has one successor, the edge is not abnormal and
the last statement does not end a basic block, insert there.
Except for the entry block. */
src = e->src;
if ((e->flags & EDGE_ABNORMAL) == 0
&& single_succ_p (src)
&& src != ENTRY_BLOCK_PTR_FOR_FN (cfun))
{
*gsi = gsi_last_bb (src);
if (gsi_end_p (*gsi))
return true;
tmp = gsi_stmt (*gsi);
if (!stmt_ends_bb_p (tmp))
return true;
switch (gimple_code (tmp))
{
case GIMPLE_RETURN:
case GIMPLE_RESX:
return false;
default:
break;
}
}
/* Otherwise, create a new basic block, and split this edge. */
dest = split_edge (e);
if (new_bb)
*new_bb = dest;
e = single_pred_edge (dest);
goto restart;
}
/* The core routine of conditional store replacement and normal
phi optimizations. Both share much of the infrastructure in how
to match applicable basic block patterns. DO_STORE_ELIM is true
when we want to do conditional store replacement, false otherwise.
DO_HOIST_LOADS is true when we want to hoist adjacent loads out
of diamond control flow patterns, false otherwise. */
static unsigned int
tree_ssa_phiopt_worker (bool do_store_elim, bool do_hoist_loads)
{
basic_block bb;
basic_block *bb_order;
unsigned n, i;
bool cfgchanged = false;
hash_set<tree> *nontrap = 0;
if (do_store_elim)
/* Calculate the set of non-trapping memory accesses. */
nontrap = get_non_trapping ();
/* Search every basic block for COND_EXPR we may be able to optimize.
We walk the blocks in order that guarantees that a block with
a single predecessor is processed before the predecessor.
This ensures that we collapse inner ifs before visiting the
outer ones, and also that we do not try to visit a removed
block. */
bb_order = single_pred_before_succ_order ();
n = n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS;
for (i = 0; i < n; i++)
{
gimple cond_stmt;
gphi *phi;
basic_block bb1, bb2;
edge e1, e2;
tree arg0, arg1;
bb = bb_order[i];
cond_stmt = last_stmt (bb);
/* Check to see if the last statement is a GIMPLE_COND. */
if (!cond_stmt
|| gimple_code (cond_stmt) != GIMPLE_COND)
continue;
e1 = EDGE_SUCC (bb, 0);
bb1 = e1->dest;
e2 = EDGE_SUCC (bb, 1);
bb2 = e2->dest;
/* We cannot do the optimization on abnormal edges. */
if ((e1->flags & EDGE_ABNORMAL) != 0
|| (e2->flags & EDGE_ABNORMAL) != 0)
continue;
/* If either bb1's succ or bb2 or bb2's succ is non NULL. */
if (EDGE_COUNT (bb1->succs) == 0
|| bb2 == NULL
|| EDGE_COUNT (bb2->succs) == 0)
continue;
/* Find the bb which is the fall through to the other. */
if (EDGE_SUCC (bb1, 0)->dest == bb2)
;
else if (EDGE_SUCC (bb2, 0)->dest == bb1)
{
std::swap (bb1, bb2);
std::swap (e1, e2);
}
else if (do_store_elim
&& EDGE_SUCC (bb1, 0)->dest == EDGE_SUCC (bb2, 0)->dest)
{
basic_block bb3 = EDGE_SUCC (bb1, 0)->dest;
if (!single_succ_p (bb1)
|| (EDGE_SUCC (bb1, 0)->flags & EDGE_FALLTHRU) == 0
|| !single_succ_p (bb2)
|| (EDGE_SUCC (bb2, 0)->flags & EDGE_FALLTHRU) == 0
|| EDGE_COUNT (bb3->preds) != 2)
continue;
if (cond_if_else_store_replacement (bb1, bb2, bb3))
cfgchanged = true;
continue;
}
else if (do_hoist_loads
&& EDGE_SUCC (bb1, 0)->dest == EDGE_SUCC (bb2, 0)->dest)
{
basic_block bb3 = EDGE_SUCC (bb1, 0)->dest;
if (!FLOAT_TYPE_P (TREE_TYPE (gimple_cond_lhs (cond_stmt)))
&& single_succ_p (bb1)
&& single_succ_p (bb2)
&& single_pred_p (bb1)
&& single_pred_p (bb2)
&& EDGE_COUNT (bb->succs) == 2
&& EDGE_COUNT (bb3->preds) == 2
/* If one edge or the other is dominant, a conditional move
is likely to perform worse than the well-predicted branch. */
&& !predictable_edge_p (EDGE_SUCC (bb, 0))
&& !predictable_edge_p (EDGE_SUCC (bb, 1)))
hoist_adjacent_loads (bb, bb1, bb2, bb3);
continue;
}
else
continue;
e1 = EDGE_SUCC (bb1, 0);
/* Make sure that bb1 is just a fall through. */
if (!single_succ_p (bb1)
|| (e1->flags & EDGE_FALLTHRU) == 0)
continue;
/* Also make sure that bb1 only have one predecessor and that it
is bb. */
if (!single_pred_p (bb1)
|| single_pred (bb1) != bb)
continue;
if (do_store_elim)
{
/* bb1 is the middle block, bb2 the join block, bb the split block,
e1 the fallthrough edge from bb1 to bb2. We can't do the
optimization if the join block has more than two predecessors. */
if (EDGE_COUNT (bb2->preds) > 2)
continue;
if (cond_store_replacement (bb1, bb2, e1, e2, nontrap))
cfgchanged = true;
}
else
{
gimple_seq phis = phi_nodes (bb2);
gimple_stmt_iterator gsi;
bool candorest = true;
/* Value replacement can work with more than one PHI
so try that first. */
for (gsi = gsi_start (phis); !gsi_end_p (gsi); gsi_next (&gsi))
{
phi = as_a <gphi *> (gsi_stmt (gsi));
arg0 = gimple_phi_arg_def (phi, e1->dest_idx);
arg1 = gimple_phi_arg_def (phi, e2->dest_idx);
if (value_replacement (bb, bb1, e1, e2, phi, arg0, arg1) == 2)
{
candorest = false;
cfgchanged = true;
break;
}
}
if (!candorest)
continue;
phi = single_non_singleton_phi_for_edges (phis, e1, e2);
if (!phi)
continue;
arg0 = gimple_phi_arg_def (phi, e1->dest_idx);
arg1 = gimple_phi_arg_def (phi, e2->dest_idx);
/* Something is wrong if we cannot find the arguments in the PHI
node. */
gcc_assert (arg0 != NULL && arg1 != NULL);
if (factor_out_conditional_conversion (e1, e2, phi, arg0, arg1))
{
/* factor_out_conditional_conversion may create a new PHI in
BB2 and eliminate an existing PHI in BB2. Recompute values
that may be affected by that change. */
phis = phi_nodes (bb2);
phi = single_non_singleton_phi_for_edges (phis, e1, e2);
gcc_assert (phi);
arg0 = gimple_phi_arg_def (phi, e1->dest_idx);
arg1 = gimple_phi_arg_def (phi, e2->dest_idx);
gcc_assert (arg0 != NULL && arg1 != NULL);
}
/* Do the replacement of conditional if it can be done. */
if (conditional_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
else if (abs_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
else if (minmax_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
}
}
free (bb_order);
if (do_store_elim)
delete nontrap;
/* If the CFG has changed, we should cleanup the CFG. */
if (cfgchanged && do_store_elim)
{
/* In cond-store replacement we have added some loads on edges
and new VOPS (as we moved the store, and created a load). */
gsi_commit_edge_inserts ();
return TODO_cleanup_cfg | TODO_update_ssa_only_virtuals;
}
else if (cfgchanged)
return TODO_cleanup_cfg;
return 0;
}
static unsigned int
tree_ssa_phiopt (void)
{
basic_block bb;
basic_block *bb_order;
unsigned n, i;
bool cfgchanged = false;
/* Search every basic block for COND_EXPR we may be able to optimize.
We walk the blocks in order that guarantees that a block with
a single predecessor is processed before the predecessor.
This ensures that we collapse inner ifs before visiting the
outer ones, and also that we do not try to visit a removed
block. */
bb_order = blocks_in_phiopt_order ();
n = n_basic_blocks - NUM_FIXED_BLOCKS;
for (i = 0; i < n; i++)
{
tree cond_expr;
tree phi;
basic_block bb1, bb2;
edge e1, e2;
tree arg0, arg1;
bb = bb_order[i];
cond_expr = last_stmt (bb);
/* Check to see if the last statement is a COND_EXPR. */
if (!cond_expr
|| TREE_CODE (cond_expr) != COND_EXPR)
continue;
e1 = EDGE_SUCC (bb, 0);
bb1 = e1->dest;
e2 = EDGE_SUCC (bb, 1);
bb2 = e2->dest;
/* We cannot do the optimization on abnormal edges. */
if ((e1->flags & EDGE_ABNORMAL) != 0
|| (e2->flags & EDGE_ABNORMAL) != 0)
continue;
/* If either bb1's succ or bb2 or bb2's succ is non NULL. */
if (EDGE_COUNT (bb1->succs) == 0
|| bb2 == NULL
|| EDGE_COUNT (bb2->succs) == 0)
continue;
/* Find the bb which is the fall through to the other. */
if (EDGE_SUCC (bb1, 0)->dest == bb2)
;
else if (EDGE_SUCC (bb2, 0)->dest == bb1)
{
basic_block bb_tmp = bb1;
edge e_tmp = e1;
bb1 = bb2;
bb2 = bb_tmp;
e1 = e2;
e2 = e_tmp;
}
else
continue;
e1 = EDGE_SUCC (bb1, 0);
/* Make sure that bb1 is just a fall through. */
if (!single_succ_p (bb1)
|| (e1->flags & EDGE_FALLTHRU) == 0)
continue;
/* Also make sure that bb1 only have one predecessor and that it
is bb. */
if (!single_pred_p (bb1)
|| single_pred (bb1) != bb)
continue;
phi = phi_nodes (bb2);
/* Check to make sure that there is only one PHI node.
TODO: we could do it with more than one iff the other PHI nodes
have the same elements for these two edges. */
if (!phi || PHI_CHAIN (phi) != NULL)
continue;
arg0 = PHI_ARG_DEF_TREE (phi, e1->dest_idx);
arg1 = PHI_ARG_DEF_TREE (phi, e2->dest_idx);
/* Something is wrong if we cannot find the arguments in the PHI
node. */
gcc_assert (arg0 != NULL && arg1 != NULL);
/* Do the replacement of conditional if it can be done. */
if (conditional_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
else if (value_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
else if (abs_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
else if (minmax_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
}
free (bb_order);
/* If the CFG has changed, we should cleanup the CFG. */
return cfgchanged ? TODO_cleanup_cfg : 0;
}
static bool
tree_if_conversion (struct loop *loop, bool for_vectorizer)
{
basic_block bb;
block_stmt_iterator itr;
unsigned int i;
ifc_bbs = NULL;
/* if-conversion is not appropriate for all loops. First, check if loop is
if-convertible or not. */
if (!if_convertible_loop_p (loop, for_vectorizer))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,"-------------------------\n");
if (ifc_bbs)
{
free (ifc_bbs);
ifc_bbs = NULL;
}
free_dominance_info (CDI_POST_DOMINATORS);
return false;
}
/* Do actual work now. */
for (i = 0; i < loop->num_nodes; i++)
{
tree cond;
bb = ifc_bbs [i];
/* Update condition using predicate list. */
cond = bb->aux;
/* Process all statements in this basic block.
Remove conditional expression, if any, and annotate
destination basic block(s) appropriately. */
for (itr = bsi_start (bb); !bsi_end_p (itr); /* empty */)
{
tree t = bsi_stmt (itr);
cond = tree_if_convert_stmt (loop, t, cond, &itr);
if (!bsi_end_p (itr))
bsi_next (&itr);
}
/* If current bb has only one successor, then consider it as an
unconditional goto. */
if (single_succ_p (bb))
{
basic_block bb_n = single_succ (bb);
if (cond != NULL_TREE)
add_to_predicate_list (bb_n, cond);
}
}
/* Now, all statements are if-converted and basic blocks are
annotated appropriately. Combine all basic block into one huge
basic block. */
combine_blocks (loop);
/* clean up */
clean_predicate_lists (loop);
free (ifc_bbs);
ifc_bbs = NULL;
return true;
}
/* The core routine of conditional store replacement and normal
phi optimizations. Both share much of the infrastructure in how
to match applicable basic block patterns. DO_STORE_ELIM is true
when we want to do conditional store replacement, false otherwise. */
static unsigned int
tree_ssa_phiopt_worker (bool do_store_elim)
{
basic_block bb;
basic_block *bb_order;
unsigned n, i;
bool cfgchanged = false;
struct pointer_set_t *nontrap = 0;
if (do_store_elim)
{
condstoretemp = NULL_TREE;
/* Calculate the set of non-trapping memory accesses. */
nontrap = get_non_trapping ();
}
/* Search every basic block for COND_EXPR we may be able to optimize.
We walk the blocks in order that guarantees that a block with
a single predecessor is processed before the predecessor.
This ensures that we collapse inner ifs before visiting the
outer ones, and also that we do not try to visit a removed
block. */
bb_order = blocks_in_phiopt_order ();
n = n_basic_blocks - NUM_FIXED_BLOCKS;
for (i = 0; i < n; i++)
{
gimple cond_stmt, phi;
basic_block bb1, bb2;
edge e1, e2;
tree arg0, arg1;
bb = bb_order[i];
cond_stmt = last_stmt (bb);
/* Check to see if the last statement is a GIMPLE_COND. */
if (!cond_stmt
|| gimple_code (cond_stmt) != GIMPLE_COND)
continue;
e1 = EDGE_SUCC (bb, 0);
bb1 = e1->dest;
e2 = EDGE_SUCC (bb, 1);
bb2 = e2->dest;
/* We cannot do the optimization on abnormal edges. */
if ((e1->flags & EDGE_ABNORMAL) != 0
|| (e2->flags & EDGE_ABNORMAL) != 0)
continue;
/* If either bb1's succ or bb2 or bb2's succ is non NULL. */
if (EDGE_COUNT (bb1->succs) == 0
|| bb2 == NULL
|| EDGE_COUNT (bb2->succs) == 0)
continue;
/* Find the bb which is the fall through to the other. */
if (EDGE_SUCC (bb1, 0)->dest == bb2)
;
else if (EDGE_SUCC (bb2, 0)->dest == bb1)
{
basic_block bb_tmp = bb1;
edge e_tmp = e1;
bb1 = bb2;
bb2 = bb_tmp;
e1 = e2;
e2 = e_tmp;
}
else
continue;
e1 = EDGE_SUCC (bb1, 0);
/* Make sure that bb1 is just a fall through. */
if (!single_succ_p (bb1)
|| (e1->flags & EDGE_FALLTHRU) == 0)
continue;
/* Also make sure that bb1 only have one predecessor and that it
is bb. */
if (!single_pred_p (bb1)
|| single_pred (bb1) != bb)
continue;
if (do_store_elim)
{
/* bb1 is the middle block, bb2 the join block, bb the split block,
e1 the fallthrough edge from bb1 to bb2. We can't do the
optimization if the join block has more than two predecessors. */
if (EDGE_COUNT (bb2->preds) > 2)
continue;
if (cond_store_replacement (bb1, bb2, e1, e2, nontrap))
cfgchanged = true;
}
else
{
gimple_seq phis = phi_nodes (bb2);
/* Check to make sure that there is only one PHI node.
TODO: we could do it with more than one iff the other PHI nodes
have the same elements for these two edges. */
if (! gimple_seq_singleton_p (phis))
continue;
phi = gsi_stmt (gsi_start (phis));
arg0 = gimple_phi_arg_def (phi, e1->dest_idx);
arg1 = gimple_phi_arg_def (phi, e2->dest_idx);
/* Something is wrong if we cannot find the arguments in the PHI
node. */
gcc_assert (arg0 != NULL && arg1 != NULL);
/* Do the replacement of conditional if it can be done. */
if (conditional_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
else if (value_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
else if (abs_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
else if (minmax_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
cfgchanged = true;
}
}
free (bb_order);
if (do_store_elim)
pointer_set_destroy (nontrap);
/* If the CFG has changed, we should cleanup the CFG. */
if (cfgchanged && do_store_elim)
{
/* In cond-store replacement we have added some loads on edges
and new VOPS (as we moved the store, and created a load). */
gsi_commit_edge_inserts ();
return TODO_cleanup_cfg | TODO_update_ssa_only_virtuals;
}
else if (cfgchanged)
return TODO_cleanup_cfg;
return 0;
}
