Fourier-Motzkin elimination is used to compute the bounds of the base space
of the lattice. */
-static bool perfect_nestify (struct loops *,
- struct loop *, VEC(tree,heap) *,
+static bool perfect_nestify (struct loop *, VEC(tree,heap) *,
VEC(tree,heap) *, VEC(int,heap) *,
VEC(tree,heap) *);
/* Lattice stuff that is internal to the code generation algorithm. */
during this process. */
lambda_loopnest
-gcc_loopnest_to_lambda_loopnest (struct loops *currloops,
- struct loop *loop_nest,
+gcc_loopnest_to_lambda_loopnest (struct loop *loop_nest,
VEC(tree,heap) **inductionvars,
VEC(tree,heap) **invariants)
{
if (!perfect_nest)
{
- if (!perfect_nestify (currloops, loop_nest,
- lboundvars, uboundvars, steps, *inductionvars))
+ if (!perfect_nestify (loop_nest, lboundvars, uboundvars, steps,
+ *inductionvars))
{
if (dump_file)
fprintf (dump_file,
add_referenced_var (resvar);
/* Start at 0. */
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar, integer_zero_node);
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
+ integer_zero_node);
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
/* newname = coefficient * induction_variable */
coeffmult = build_int_cst (type, LBV_COEFFICIENTS (lbv)[i]);
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
fold_build2 (MULT_EXPR, type, iv, coeffmult));
newname = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = newname;
+ GIMPLE_STMT_OPERAND (stmt, 0) = newname;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
/* name = name + newname */
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
build2 (PLUS_EXPR, type, name, newname));
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
if (LBV_DENOMINATOR (lbv) != 1)
{
tree denominator = build_int_cst (type, LBV_DENOMINATOR (lbv));
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
build2 (CEIL_DIV_EXPR, type, name, denominator));
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
for (; lle != NULL; lle = LLE_NEXT (lle))
{
/* Start at name = 0. */
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar, integer_zero_node);
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
+ integer_zero_node);
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
}
/* newname = mult */
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar, mult);
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar, mult);
newname = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = newname;
+ GIMPLE_STMT_OPERAND (stmt, 0) = newname;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
/* name = name + newname */
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
build2 (PLUS_EXPR, type, name, newname));
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
}
/* newname = mult */
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar, mult);
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar, mult);
newname = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = newname;
+ GIMPLE_STMT_OPERAND (stmt, 0) = newname;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
/* name = name + newname */
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
build2 (PLUS_EXPR, type, name, newname));
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
name = name + constant. */
if (LLE_CONSTANT (lle) != 0)
{
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
build2 (PLUS_EXPR, type, name,
build_int_cst (type, LLE_CONSTANT (lle))));
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
name = name + linear offset. */
if (LLE_CONSTANT (offset) != 0)
{
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
build2 (PLUS_EXPR, type, name,
build_int_cst (type, LLE_CONSTANT (offset))));
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
fold_stmt (&stmt);
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
stmt = build_int_cst (type, LLE_DENOMINATOR (lle));
stmt = build2 (wrap == MAX_EXPR ? CEIL_DIV_EXPR : FLOOR_DIV_EXPR,
type, name, stmt);
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar, stmt);
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar, stmt);
/* name = {ceil, floor}(name/denominator) */
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
}
{
tree op1 = VEC_index (tree, results, 0);
tree op2 = VEC_index (tree, results, 1);
- stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
build2 (wrap, type, op1, op2));
name = make_ssa_name (resvar, stmt);
- TREE_OPERAND (stmt, 0) = name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = name;
tsi = tsi_last (stmts);
tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
}
type,
new_ivs,
invariants, MIN_EXPR, &stmts);
- exit = temp->single_exit;
+ exit = single_exit (temp);
exitcond = get_loop_exit_condition (temp);
bb = bb_for_stmt (exitcond);
bsi = bsi_start (bb);
test, and let redundancy elimination sort it out. */
inc_stmt = build2 (PLUS_EXPR, type,
ivvar, build_int_cst (type, LL_STEP (newloop)));
- inc_stmt = build2 (MODIFY_EXPR, void_type_node, SSA_NAME_VAR (ivvar),
- inc_stmt);
+ inc_stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node,
+ SSA_NAME_VAR (ivvar), inc_stmt);
ivvarinced = make_ssa_name (SSA_NAME_VAR (ivvar), inc_stmt);
- TREE_OPERAND (inc_stmt, 0) = ivvarinced;
+ GIMPLE_STMT_OPERAND (inc_stmt, 0) = ivvarinced;
bsi = bsi_for_stmt (exitcond);
bsi_insert_before (&bsi, inc_stmt, BSI_SAME_STMT);
var = create_tmp_var (TREE_TYPE (use), "perfecttmp");
add_referenced_var (var);
val = force_gimple_operand_bsi (firstbsi, val, false, NULL);
- setstmt = build2 (MODIFY_EXPR, void_type_node, var, val);
+ setstmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, var, val);
var = make_ssa_name (var, setstmt);
- TREE_OPERAND (setstmt, 0) = var;
+ GIMPLE_STMT_OPERAND (setstmt, 0) = var;
bsi_insert_before (firstbsi, setstmt, BSI_SAME_STMT);
update_stmt (setstmt);
SET_USE (use_p, var);
if (TREE_CODE (stmt) != PHI_NODE
|| PHI_NUM_ARGS (stmt) != 1
- || bb_for_stmt (stmt) != loop->single_exit->dest)
+ || bb_for_stmt (stmt) != single_exit (loop)->dest)
return false;
return true;
imm_use_iterator imm_iter;
use_operand_p use_p;
- gcc_assert (TREE_CODE (stmt) == MODIFY_EXPR);
+ gcc_assert (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT);
if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)
- || !expr_invariant_in_loop_p (inner, TREE_OPERAND (stmt, 1)))
+ || !expr_invariant_in_loop_p (inner, GIMPLE_STMT_OPERAND (stmt, 1)))
return false;
- FOR_EACH_IMM_USE_FAST (use_p, imm_iter, TREE_OPERAND (stmt, 0))
+ FOR_EACH_IMM_USE_FAST (use_p, imm_iter, GIMPLE_STMT_OPERAND (stmt, 0))
{
if (!exit_phi_for_loop_p (inner, USE_STMT (use_p)))
{
if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
return false;
- FOR_EACH_IMM_USE_FAST (use_p, imm_iter, TREE_OPERAND (stmt, 0))
+ FOR_EACH_IMM_USE_FAST (use_p, imm_iter, GIMPLE_STMT_OPERAND (stmt, 0))
{
if (!exit_phi_for_loop_p (loop, USE_STMT (use_p)))
{
win we get from rearranging the memory walk
the loop is doing so that it has better
cache behavior. */
- if (TREE_CODE (stmt) == MODIFY_EXPR)
+ if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
{
use_operand_p use_a, use_b;
imm_use_iterator imm_iter;
ssa_op_iter op_iter, op_iter1;
- tree op0 = TREE_OPERAND (stmt, 0);
+ tree op0 = GIMPLE_STMT_OPERAND (stmt, 0);
tree scev = instantiate_parameters
(loop, analyze_scalar_evolution (loop, op0));
/* We also need to make sure the loop exit only has simple copy phis in it,
otherwise we don't know how to transform it into a perfect nest right
now. */
- exitdest = loop->single_exit->dest;
+ exitdest = single_exit (loop)->dest;
for (phi = phi_nodes (exitdest); phi; phi = PHI_CHAIN (phi))
if (PHI_NUM_ARGS (phi) != 1)
}
/* Transform the loop nest into a perfect nest, if possible.
- LOOPS is the current struct loops *
LOOP is the loop nest to transform into a perfect nest
LBOUNDS are the lower bounds for the loops to transform
UBOUNDS are the upper bounds for the loops to transform
Return FALSE if we can't make this loop into a perfect nest. */
static bool
-perfect_nestify (struct loops *loops,
- struct loop *loop,
+perfect_nestify (struct loop *loop,
VEC(tree,heap) *lbounds,
VEC(tree,heap) *ubounds,
VEC(int,heap) *steps,
htab_t replacements = NULL;
/* Create the new loop. */
- olddest = loop->single_exit->dest;
- preheaderbb = split_edge (loop->single_exit);
+ olddest = single_exit (loop)->dest;
+ preheaderbb = split_edge (single_exit (loop));
headerbb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
/* Push the exit phi nodes that we are moving. */
}
e = redirect_edge_and_branch (single_succ_edge (preheaderbb), headerbb);
- /* Remove the exit phis from the old basic block. Make sure to set
- PHI_RESULT to null so it doesn't get released. */
+ /* Remove the exit phis from the old basic block. */
while (phi_nodes (olddest) != NULL)
- {
- SET_PHI_RESULT (phi_nodes (olddest), NULL);
- remove_phi_node (phi_nodes (olddest), NULL);
- }
+ remove_phi_node (phi_nodes (olddest), NULL, false);
/* and add them back to the new basic block. */
while (VEC_length (tree, phis) != 0)
make_edge (latchbb, headerbb, EDGE_FALLTHRU);
/* Update the loop structures. */
- newloop = duplicate_loop (loops, loop, olddest->loop_father);
+ newloop = duplicate_loop (loop, olddest->loop_father);
newloop->header = headerbb;
newloop->latch = latchbb;
- newloop->single_exit = e;
+ set_single_exit (newloop, e);
add_bb_to_loop (latchbb, newloop);
add_bb_to_loop (bodybb, newloop);
add_bb_to_loop (headerbb, newloop);
set_immediate_dominator (CDI_DOMINATORS, bodybb, headerbb);
set_immediate_dominator (CDI_DOMINATORS, headerbb, preheaderbb);
set_immediate_dominator (CDI_DOMINATORS, preheaderbb,
- loop->single_exit->src);
+ single_exit (loop)->src);
set_immediate_dominator (CDI_DOMINATORS, latchbb, bodybb);
set_immediate_dominator (CDI_DOMINATORS, olddest, bodybb);
/* Create the new iv. */
exit_condition = get_loop_exit_condition (newloop);
uboundvar = create_tmp_var (integer_type_node, "uboundvar");
add_referenced_var (uboundvar);
- stmt = build2 (MODIFY_EXPR, void_type_node, uboundvar,
+ stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, uboundvar,
VEC_index (tree, ubounds, 0));
uboundvar = make_ssa_name (uboundvar, stmt);
- TREE_OPERAND (stmt, 0) = uboundvar;
+ GIMPLE_STMT_OPERAND (stmt, 0) = uboundvar;
if (insert_after)
bsi_insert_after (&bsi, stmt, BSI_SAME_STMT);