static void
add_ssa_edge (tree var, bool is_varying)
{
imm_use_iterator iter;
use_operand_p use_p;
FOR_EACH_IMM_USE_FAST (use_p, iter, var)
{
tree use_stmt = USE_STMT (use_p);
if (!DONT_SIMULATE_AGAIN (use_stmt)
&& !STMT_IN_SSA_EDGE_WORKLIST (use_stmt))
{
STMT_IN_SSA_EDGE_WORKLIST (use_stmt) = 1;
if (is_varying)
VEC_safe_push (tree, gc, varying_ssa_edges, use_stmt);
else
VEC_safe_push (tree, gc, interesting_ssa_edges, use_stmt);
}
}
static bool
init_dont_simulate_again (void)
{
basic_block bb;
block_stmt_iterator bsi;
tree phi;
bool saw_a_complex_op = false;
FOR_EACH_BB (bb)
{
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
DONT_SIMULATE_AGAIN (phi) = !is_complex_reg (PHI_RESULT (phi));
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree orig_stmt, stmt, rhs = NULL;
bool dsa;
orig_stmt = stmt = bsi_stmt (bsi);
/* Most control-altering statements must be initially
simulated, else we won't cover the entire cfg. */
dsa = !stmt_ends_bb_p (stmt);
switch (TREE_CODE (stmt))
{
case RETURN_EXPR:
/* We don't care what the lattice value of <retval> is,
since it's never used as an input to another computation. */
dsa = true;
stmt = TREE_OPERAND (stmt, 0);
if (!stmt || TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
break;
/* FALLTHRU */
case GIMPLE_MODIFY_STMT:
dsa = !is_complex_reg (GIMPLE_STMT_OPERAND (stmt, 0));
rhs = GIMPLE_STMT_OPERAND (stmt, 1);
break;
case COND_EXPR:
rhs = TREE_OPERAND (stmt, 0);
break;
default:
break;
}
if (rhs)
switch (TREE_CODE (rhs))
{
case EQ_EXPR:
case NE_EXPR:
rhs = TREE_OPERAND (rhs, 0);
/* FALLTHRU */
case PLUS_EXPR:
case MINUS_EXPR:
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case CEIL_DIV_EXPR:
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
case RDIV_EXPR:
case NEGATE_EXPR:
case CONJ_EXPR:
if (TREE_CODE (TREE_TYPE (rhs)) == COMPLEX_TYPE)
saw_a_complex_op = true;
break;
case REALPART_EXPR:
case IMAGPART_EXPR:
/* The total store transformation performed during
gimplification creates such uninitialized loads
and we need to lower the statement to be able
to fix things up. */
if (TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
&& ssa_undefined_value_p (TREE_OPERAND (rhs, 0)))
saw_a_complex_op = true;
break;
default:
break;
}
DONT_SIMULATE_AGAIN (orig_stmt) = dsa;
}
}
return saw_a_complex_op;
}
static bool
init_dont_simulate_again (void)
{
basic_block bb;
block_stmt_iterator bsi;
tree phi;
bool saw_a_complex_op = false;
FOR_EACH_BB (bb)
{
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
DONT_SIMULATE_AGAIN (phi) = !is_complex_reg (PHI_RESULT (phi));
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree orig_stmt, stmt, rhs = NULL;
bool dsa;
orig_stmt = stmt = bsi_stmt (bsi);
/* Most control-altering statements must be initially
simulated, else we won't cover the entire cfg. */
dsa = !stmt_ends_bb_p (stmt);
switch (TREE_CODE (stmt))
{
case RETURN_EXPR:
/* We don't care what the lattice value of <retval> is,
since it's never used as an input to another computation. */
dsa = true;
stmt = TREE_OPERAND (stmt, 0);
if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
break;
/* FALLTHRU */
case MODIFY_EXPR:
dsa = !is_complex_reg (TREE_OPERAND (stmt, 0));
rhs = TREE_OPERAND (stmt, 1);
break;
case COND_EXPR:
rhs = TREE_OPERAND (stmt, 0);
break;
default:
break;
}
if (rhs)
switch (TREE_CODE (rhs))
{
case EQ_EXPR:
case NE_EXPR:
rhs = TREE_OPERAND (rhs, 0);
/* FALLTHRU */
case PLUS_EXPR:
case MINUS_EXPR:
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case CEIL_DIV_EXPR:
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
case RDIV_EXPR:
case NEGATE_EXPR:
case CONJ_EXPR:
if (TREE_CODE (TREE_TYPE (rhs)) == COMPLEX_TYPE)
saw_a_complex_op = true;
break;
default:
break;
}
DONT_SIMULATE_AGAIN (orig_stmt) = dsa;
}
}
return saw_a_complex_op;
}
