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;
}
unsigned int
tree_ssa_unswitch_loops (void)
{
loop_iterator li;
struct loop *loop;
bool changed = false;
HOST_WIDE_INT iterations;
/* Go through inner loops (only original ones). */
FOR_EACH_LOOP (li, loop, LI_ONLY_INNERMOST)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, ";; Considering loop %d\n", loop->num);
/* Do not unswitch in cold regions. */
if (optimize_loop_for_size_p (loop))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, ";; Not unswitching cold loops\n");
continue;
}
/* The loop should not be too large, to limit code growth. */
if (tree_num_loop_insns (loop, &eni_size_weights)
> (unsigned) PARAM_VALUE (PARAM_MAX_UNSWITCH_INSNS))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, ";; Not unswitching, loop too big\n");
continue;
}
/* If the loop is not expected to iterate, there is no need
for unswitching. */
iterations = estimated_loop_iterations_int (loop);
if (iterations >= 0 && iterations <= 1)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, ";; Not unswitching, loop is not expected to iterate\n");
continue;
}
changed |= tree_unswitch_single_loop (loop, 0);
}
if (changed)
return TODO_cleanup_cfg;
return 0;
}
/* Unswitch single LOOP. COND_CHECKED holds list of conditions we already
unswitched on and are therefore known to be true in this LOOP. NUM is
number of unswitchings done; do not allow it to grow too much, it is too
easy to create example on that the code would grow exponentially.
Returns true LOOP was unswitched. */
static bool
unswitch_single_loop (struct loop *loop, rtx cond_checked, int num)
{
basic_block *bbs;
struct loop *nloop;
unsigned i;
rtx cond, rcond = NULL_RTX, conds, rconds, acond, cinsn;
int repeat;
edge e;
HOST_WIDE_INT iterations;
/* Do not unswitch too much. */
if (num > PARAM_VALUE (PARAM_MAX_UNSWITCH_LEVEL))
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching anymore, hit max level\n");
return false;
}
/* Only unswitch innermost loops. */
if (loop->inner)
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, not innermost loop\n");
return false;
}
/* We must be able to duplicate loop body. */
if (!can_duplicate_loop_p (loop))
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, can't duplicate loop\n");
return false;
}
/* The loop should not be too large, to limit code growth. */
if (num_loop_insns (loop) > PARAM_VALUE (PARAM_MAX_UNSWITCH_INSNS))
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, loop too big\n");
return false;
}
/* Do not unswitch in cold areas. */
if (optimize_loop_for_size_p (loop))
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, not hot area\n");
return false;
}
/* Nor if the loop usually does not roll. */
iterations = estimated_loop_iterations_int (loop);
if (iterations >= 0 && iterations <= 1)
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, loop iterations < 1\n");
return false;
}
do
{
repeat = 0;
cinsn = NULL_RTX;
/* Find a bb to unswitch on. */
bbs = get_loop_body (loop);
iv_analysis_loop_init (loop);
for (i = 0; i < loop->num_nodes; i++)
if ((cond = may_unswitch_on (bbs[i], loop, &cinsn)))
break;
if (i == loop->num_nodes)
{
free (bbs);
return false;
}
if (cond != const0_rtx
&& cond != const_true_rtx)
{
rcond = reversed_condition (cond);
if (rcond)
rcond = canon_condition (rcond);
/* Check whether the result can be predicted. */
for (acond = cond_checked; acond; acond = XEXP (acond, 1))
simplify_using_condition (XEXP (acond, 0), &cond, NULL);
}
if (cond == const_true_rtx)
{
/* Remove false path. */
e = FALLTHRU_EDGE (bbs[i]);
remove_path (e);
free (bbs);
repeat = 1;
}
else if (cond == const0_rtx)
{
/* Remove true path. */
e = BRANCH_EDGE (bbs[i]);
remove_path (e);
free (bbs);
repeat = 1;
}
} while (repeat);
/* We found the condition we can unswitch on. */
conds = alloc_EXPR_LIST (0, cond, cond_checked);
if (rcond)
rconds = alloc_EXPR_LIST (0, rcond, cond_checked);
else
rconds = cond_checked;
if (dump_file)
fprintf (dump_file, ";; Unswitching loop\n");
/* Unswitch the loop on this condition. */
nloop = unswitch_loop (loop, bbs[i], copy_rtx_if_shared (cond), cinsn);
gcc_assert (nloop);
/* Invoke itself on modified loops. */
unswitch_single_loop (nloop, rconds, num + 1);
unswitch_single_loop (loop, conds, num + 1);
free_EXPR_LIST_node (conds);
if (rcond)
free_EXPR_LIST_node (rconds);
free (bbs);
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;
}
