static void
lower_cond_expr (tree_stmt_iterator *tsi, struct lower_data *data)
{
tree stmt = tsi_stmt (*tsi);
bool then_is_goto, else_is_goto;
tree then_branch, else_branch;
tree then_goto, else_goto;
then_branch = COND_EXPR_THEN (stmt);
else_branch = COND_EXPR_ELSE (stmt);
lower_stmt_body (then_branch, data);
lower_stmt_body (else_branch, data);
then_goto = expr_only (then_branch);
then_is_goto = then_goto && simple_goto_p (then_goto);
else_goto = expr_only (else_branch);
else_is_goto = else_goto && simple_goto_p (else_goto);
if (!then_is_goto || !else_is_goto)
{
tree then_label, else_label, end_label, t;
then_label = NULL_TREE;
else_label = NULL_TREE;
end_label = NULL_TREE;
/* Replace the cond_expr with explicit gotos. */
if (!then_is_goto)
{
t = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
if (TREE_SIDE_EFFECTS (then_branch))
then_label = t;
else
end_label = t;
then_goto = build_and_jump (&LABEL_EXPR_LABEL (t));
}
if (!else_is_goto)
{
t = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
if (TREE_SIDE_EFFECTS (else_branch))
else_label = t;
else
{
/* Both THEN and ELSE can be no-ops if one or both contained an
empty BIND_EXPR that was associated with the toplevel block
of an inlined function. In that case remove_useless_stmts
can't have cleaned things up for us; kill the whole
conditional now. */
if (end_label)
{
tsi_delink (tsi);
return;
}
else
end_label = t;
}
else_goto = build_and_jump (&LABEL_EXPR_LABEL (t));
}
if (then_label)
{
bool may_fallthru = block_may_fallthru (then_branch);
tsi_link_after (tsi, then_label, TSI_CONTINUE_LINKING);
tsi_link_after (tsi, then_branch, TSI_CONTINUE_LINKING);
if (else_label && may_fallthru)
{
end_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
t = build_and_jump (&LABEL_EXPR_LABEL (end_label));
tsi_link_after (tsi, t, TSI_CONTINUE_LINKING);
}
}
if (else_label)
{
tsi_link_after (tsi, else_label, TSI_CONTINUE_LINKING);
tsi_link_after (tsi, else_branch, TSI_CONTINUE_LINKING);
}
if (end_label)
tsi_link_after (tsi, end_label, TSI_CONTINUE_LINKING);
}
COND_EXPR_THEN (stmt) = then_goto;
COND_EXPR_ELSE (stmt) = else_goto;
tsi_next (tsi);
}
static void
genericize_cp_loop (tree *stmt_p, location_t start_locus, tree cond, tree body,
tree incr, bool cond_is_first, int *walk_subtrees,
void *data)
{
tree blab, clab;
tree entry = NULL, exit = NULL, t;
tree stmt_list = NULL;
blab = begin_bc_block (bc_break, start_locus);
clab = begin_bc_block (bc_continue, start_locus);
if (incr && EXPR_P (incr))
SET_EXPR_LOCATION (incr, start_locus);
cp_walk_tree (&cond, cp_genericize_r, data, NULL);
cp_walk_tree (&body, cp_genericize_r, data, NULL);
cp_walk_tree (&incr, cp_genericize_r, data, NULL);
*walk_subtrees = 0;
/* If condition is zero don't generate a loop construct. */
if (cond && integer_zerop (cond))
{
if (cond_is_first)
{
t = build1_loc (start_locus, GOTO_EXPR, void_type_node,
get_bc_label (bc_break));
append_to_statement_list (t, &stmt_list);
}
}
else
{
/* Expand to gotos, just like c_finish_loop. TODO: Use LOOP_EXPR. */
tree top = build1 (LABEL_EXPR, void_type_node,
create_artificial_label (start_locus));
/* If we have an exit condition, then we build an IF with gotos either
out of the loop, or to the top of it. If there's no exit condition,
then we just build a jump back to the top. */
exit = build1 (GOTO_EXPR, void_type_node, LABEL_EXPR_LABEL (top));
if (cond && !integer_nonzerop (cond))
{
/* Canonicalize the loop condition to the end. This means
generating a branch to the loop condition. Reuse the
continue label, if possible. */
if (cond_is_first)
{
if (incr)
{
entry = build1 (LABEL_EXPR, void_type_node,
create_artificial_label (start_locus));
t = build1_loc (start_locus, GOTO_EXPR, void_type_node,
LABEL_EXPR_LABEL (entry));
}
else
t = build1_loc (start_locus, GOTO_EXPR, void_type_node,
get_bc_label (bc_continue));
append_to_statement_list (t, &stmt_list);
}
t = build1 (GOTO_EXPR, void_type_node, get_bc_label (bc_break));
exit = fold_build3_loc (start_locus,
COND_EXPR, void_type_node, cond, exit, t);
}
append_to_statement_list (top, &stmt_list);
}
append_to_statement_list (body, &stmt_list);
finish_bc_block (&stmt_list, bc_continue, clab);
append_to_statement_list (incr, &stmt_list);
append_to_statement_list (entry, &stmt_list);
append_to_statement_list (exit, &stmt_list);
finish_bc_block (&stmt_list, bc_break, blab);
if (stmt_list == NULL_TREE)
stmt_list = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*stmt_p = stmt_list;
}
static tree
gimplify_cp_loop (tree cond, tree body, tree incr, bool cond_is_first)
{
tree top, entry, exit, cont_block, break_block, stmt_list, t;
location_t stmt_locus;
stmt_locus = input_location;
stmt_list = NULL_TREE;
entry = NULL_TREE;
break_block = begin_bc_block (bc_break);
cont_block = begin_bc_block (bc_continue);
/* If condition is zero don't generate a loop construct. */
if (cond && integer_zerop (cond))
{
top = NULL_TREE;
exit = NULL_TREE;
if (cond_is_first)
{
t = build_bc_goto (bc_break);
append_to_statement_list (t, &stmt_list);
}
}
else
{
/* If we use a LOOP_EXPR here, we have to feed the whole thing
back through the main gimplifier to lower it. Given that we
have to gimplify the loop body NOW so that we can resolve
break/continue stmts, seems easier to just expand to gotos. */
top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
/* If we have an exit condition, then we build an IF with gotos either
out of the loop, or to the top of it. If there's no exit condition,
then we just build a jump back to the top. */
exit = build_and_jump (&LABEL_EXPR_LABEL (top));
if (cond && !integer_nonzerop (cond))
{
t = build_bc_goto (bc_break);
exit = build3 (COND_EXPR, void_type_node, cond, exit, t);
exit = fold (exit);
gimplify_stmt (&exit);
if (cond_is_first)
{
if (incr)
{
entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
t = build_and_jump (&LABEL_EXPR_LABEL (entry));
}
else
t = build_bc_goto (bc_continue);
append_to_statement_list (t, &stmt_list);
}
}
}
gimplify_stmt (&body);
gimplify_stmt (&incr);
body = finish_bc_block (bc_continue, cont_block, body);
append_to_statement_list (top, &stmt_list);
append_to_statement_list (body, &stmt_list);
append_to_statement_list (incr, &stmt_list);
append_to_statement_list (entry, &stmt_list);
append_to_statement_list (exit, &stmt_list);
annotate_all_with_locus (&stmt_list, stmt_locus);
return finish_bc_block (bc_break, break_block, stmt_list);
}
static tree
/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
gimplify_cp_loop (tree cond, tree body, tree incr, tree attrs,
bool cond_is_first, tree inner_foreach)
/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
{
tree top, entry, exit, cont_block, break_block, stmt_list, t;
location_t stmt_locus;
stmt_locus = input_location;
stmt_list = NULL_TREE;
entry = NULL_TREE;
/* APPLE LOCAL begin C* language */
/* Order of label addition to stack is important for objc's foreach-stmt. */
/* APPLE LOCAL radar 4667060 */
if (inner_foreach == integer_zero_node)
{
cont_block = begin_bc_block (bc_continue);
break_block = begin_bc_block (bc_break);
}
else
{
break_block = begin_bc_block (bc_break);
cont_block = begin_bc_block (bc_continue);
}
/* APPLE LOCAL end C* language */
/* If condition is zero don't generate a loop construct. */
if (cond && integer_zerop (cond))
{
top = NULL_TREE;
exit = NULL_TREE;
if (cond_is_first)
{
t = build_bc_goto (bc_break);
append_to_statement_list (t, &stmt_list);
}
}
else
{
/* If we use a LOOP_EXPR here, we have to feed the whole thing
back through the main gimplifier to lower it. Given that we
have to gimplify the loop body NOW so that we can resolve
break/continue stmts, seems easier to just expand to gotos. */
top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
/* If we have an exit condition, then we build an IF with gotos either
out of the loop, or to the top of it. If there's no exit condition,
then we just build a jump back to the top. */
exit = build_and_jump (&LABEL_EXPR_LABEL (top));
/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
/* Add the attributes to the 'top' label. */
decl_attributes (&LABEL_EXPR_LABEL (top), attrs, 0);
/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
if (cond && !integer_nonzerop (cond))
{
t = build_bc_goto (bc_break);
exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t);
gimplify_stmt (&exit);
if (cond_is_first)
{
if (incr)
{
entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
t = build_and_jump (&LABEL_EXPR_LABEL (entry));
}
else
t = build_bc_goto (bc_continue);
append_to_statement_list (t, &stmt_list);
}
}
}
/* APPLE LOCAL begin radar 4547045 */
/* Pop foreach's inner loop break label so outer loop's
break label becomes target of inner loop body's break statements.
*/
t = NULL_TREE;
gimplify_stmt (&body);
gimplify_stmt (&incr);
body = finish_bc_block (bc_continue, cont_block, body);
/* APPLE LOCAL begin radar 4547045 */
/* Push back inner loop's own 'break' label so rest
of code works seemlessly. */
/* APPLE LOCAL radar 4667060 */
append_to_statement_list (top, &stmt_list);
append_to_statement_list (body, &stmt_list);
append_to_statement_list (incr, &stmt_list);
append_to_statement_list (entry, &stmt_list);
append_to_statement_list (exit, &stmt_list);
annotate_all_with_locus (&stmt_list, stmt_locus);
return finish_bc_block (bc_break, break_block, stmt_list);
}
