static enum ssa_prop_result
copy_prop_visit_cond_stmt (gimple *stmt, edge *taken_edge_p)
{
enum ssa_prop_result retval = SSA_PROP_VARYING;
location_t loc = gimple_location (stmt);
tree op0 = valueize_val (gimple_cond_lhs (stmt));
tree op1 = valueize_val (gimple_cond_rhs (stmt));
/* See if we can determine the predicate's value. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Trying to determine truth value of ");
fprintf (dump_file, "predicate ");
print_gimple_stmt (dump_file, stmt, 0, 0);
}
/* Fold COND and see whether we get a useful result. */
tree folded_cond = fold_binary_loc (loc, gimple_cond_code (stmt),
boolean_type_node, op0, op1);
if (folded_cond)
{
basic_block bb = gimple_bb (stmt);
*taken_edge_p = find_taken_edge (bb, folded_cond);
if (*taken_edge_p)
retval = SSA_PROP_INTERESTING;
}
if (dump_file && (dump_flags & TDF_DETAILS) && *taken_edge_p)
fprintf (dump_file, "\nConditional will always take edge %d->%d\n",
(*taken_edge_p)->src->index, (*taken_edge_p)->dest->index);
return retval;
}
static enum ssa_prop_result
copy_prop_visit_cond_stmt (gimple stmt, edge *taken_edge_p)
{
enum ssa_prop_result retval = SSA_PROP_VARYING;
location_t loc = gimple_location (stmt);
tree op0 = gimple_cond_lhs (stmt);
tree op1 = gimple_cond_rhs (stmt);
/* The only conditionals that we may be able to compute statically
are predicates involving two SSA_NAMEs. */
if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME)
{
op0 = valueize_val (op0);
op1 = valueize_val (op1);
/* See if we can determine the predicate's value. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Trying to determine truth value of ");
fprintf (dump_file, "predicate ");
print_gimple_stmt (dump_file, stmt, 0, 0);
}
/* We can fold COND and get a useful result only when we have
the same SSA_NAME on both sides of a comparison operator. */
if (op0 == op1)
{
tree folded_cond = fold_binary_loc (loc, gimple_cond_code (stmt),
boolean_type_node, op0, op1);
if (folded_cond)
{
basic_block bb = gimple_bb (stmt);
*taken_edge_p = find_taken_edge (bb, folded_cond);
if (*taken_edge_p)
retval = SSA_PROP_INTERESTING;
}
}
}
if (dump_file && (dump_flags & TDF_DETAILS) && *taken_edge_p)
fprintf (dump_file, "\nConditional will always take edge %d->%d\n",
(*taken_edge_p)->src->index, (*taken_edge_p)->dest->index);
return retval;
}
static enum ssa_prop_result
copy_prop_visit_assignment (gimple stmt, tree *result_p)
{
tree lhs, rhs;
lhs = gimple_assign_lhs (stmt);
rhs = valueize_val (gimple_assign_rhs1 (stmt));
if (TREE_CODE (lhs) == SSA_NAME)
{
/* Straight copy between two SSA names. First, make sure that
we can propagate the RHS into uses of LHS. */
if (!may_propagate_copy (lhs, rhs))
return SSA_PROP_VARYING;
*result_p = lhs;
if (set_copy_of_val (*result_p, rhs))
return SSA_PROP_INTERESTING;
else
return SSA_PROP_NOT_INTERESTING;
}
return SSA_PROP_VARYING;
}
static enum ssa_prop_result
copy_prop_visit_phi_node (gimple phi)
{
enum ssa_prop_result retval;
unsigned i;
prop_value_t phi_val = { NULL_TREE };
tree lhs = gimple_phi_result (phi);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\nVisiting PHI node: ");
print_gimple_stmt (dump_file, phi, 0, dump_flags);
}
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
prop_value_t *arg_val;
tree arg_value;
tree arg = gimple_phi_arg_def (phi, i);
edge e = gimple_phi_arg_edge (phi, i);
/* We don't care about values flowing through non-executable
edges. */
if (!(e->flags & EDGE_EXECUTABLE))
continue;
/* Names that flow through abnormal edges cannot be used to
derive copies. */
if (TREE_CODE (arg) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (arg))
{
phi_val.value = lhs;
break;
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\tArgument #%d: ", i);
dump_copy_of (dump_file, arg);
fprintf (dump_file, "\n");
}
if (TREE_CODE (arg) == SSA_NAME)
{
arg_val = get_copy_of_val (arg);
/* If we didn't visit the definition of arg yet treat it as
UNDEFINED. This also handles PHI arguments that are the
same as lhs. We'll come here again. */
if (!arg_val->value)
continue;
arg_value = arg_val->value;
}
else
arg_value = valueize_val (arg);
/* Avoid copy propagation from an inner into an outer loop.
Otherwise, this may move loop variant variables outside of
their loops and prevent coalescing opportunities. If the
value was loop invariant, it will be hoisted by LICM and
exposed for copy propagation.
??? The value will be always loop invariant.
In loop-closed SSA form do not copy-propagate through
PHI nodes in blocks with a loop exit edge predecessor. */
if (current_loops
&& TREE_CODE (arg_value) == SSA_NAME
&& (loop_depth_of_name (arg_value) > loop_depth_of_name (lhs)
|| (loops_state_satisfies_p (LOOP_CLOSED_SSA)
&& loop_exit_edge_p (e->src->loop_father, e))))
{
phi_val.value = lhs;
break;
}
/* If the LHS didn't have a value yet, make it a copy of the
first argument we find. */
if (phi_val.value == NULL_TREE)
{
phi_val.value = arg_value;
continue;
}
/* If PHI_VAL and ARG don't have a common copy-of chain, then
this PHI node cannot be a copy operation. */
if (phi_val.value != arg_value
&& !operand_equal_p (phi_val.value, arg_value, 0))
{
phi_val.value = lhs;
break;
}
}
if (phi_val.value
&& may_propagate_copy (lhs, phi_val.value)
&& set_copy_of_val (lhs, phi_val.value))
retval = (phi_val.value != lhs) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING;
else
retval = SSA_PROP_NOT_INTERESTING;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "PHI node ");
dump_copy_of (dump_file, lhs);
fprintf (dump_file, "\nTelling the propagator to ");
if (retval == SSA_PROP_INTERESTING)
fprintf (dump_file, "add SSA edges out of this PHI and continue.");
else if (retval == SSA_PROP_VARYING)
fprintf (dump_file, "add SSA edges out of this PHI and never visit again.");
else
fprintf (dump_file, "do nothing with SSA edges and keep iterating.");
fprintf (dump_file, "\n\n");
}
return retval;
}
