void
dump_immediate_uses_for (FILE *file, tree var)
{
imm_use_iterator iter;
use_operand_p use_p;
gcc_assert (var && TREE_CODE (var) == SSA_NAME);
print_generic_expr (file, var, TDF_SLIM);
fprintf (file, " : -->");
if (has_zero_uses (var))
fprintf (file, " no uses.\n");
else
if (has_single_use (var))
fprintf (file, " single use.\n");
else
fprintf (file, "%d uses.\n", num_imm_uses (var));
FOR_EACH_IMM_USE_FAST (use_p, iter, var)
{
if (use_p->loc.stmt == NULL && use_p->use == NULL)
fprintf (file, "***end of stmt iterator marker***\n");
else
if (!is_gimple_reg (USE_FROM_PTR (use_p)))
print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_VOPS|TDF_MEMSYMS);
else
print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_SLIM);
}
fprintf(file, "\n");
}
static bool
if_convertible_phi_p (struct loop *loop, basic_block bb, tree phi)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "-------------------------\n");
print_generic_stmt (dump_file, phi, TDF_SLIM);
}
if (bb != loop->header && PHI_NUM_ARGS (phi) != 2)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "More than two phi node args.\n");
return false;
}
if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
{
imm_use_iterator imm_iter;
use_operand_p use_p;
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, PHI_RESULT (phi))
{
if (TREE_CODE (USE_STMT (use_p)) == PHI_NODE)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Difficult to handle this virtual phi.\n");
return false;
}
}
}
static bool
all_immediate_uses_same_place (def_operand_p def_p)
{
tree var = DEF_FROM_PTR (def_p);
imm_use_iterator imm_iter;
use_operand_p use_p;
gimple *firstuse = NULL;
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var)
{
if (is_gimple_debug (USE_STMT (use_p)))
continue;
if (firstuse == NULL)
firstuse = USE_STMT (use_p);
else
if (firstuse != USE_STMT (use_p))
return false;
}
return true;
}
static bool
ssa_name_has_uses_outside_loop_p (tree def, loop_p loop)
{
imm_use_iterator imm_iter;
use_operand_p use_p;
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
if (loop != loop_containing_stmt (USE_STMT (use_p)))
return true;
return false;
}
static inline void
replace_reciprocal (use_operand_p use_p)
{
gimple use_stmt = USE_STMT (use_p);
basic_block bb = gimple_bb (use_stmt);
struct occurrence *occ = (struct occurrence *) bb->aux;
if (optimize_bb_for_speed_p (bb)
&& occ->recip_def && use_stmt != occ->recip_def_stmt)
{
gimple_assign_set_rhs_code (use_stmt, MULT_EXPR);
SET_USE (use_p, occ->recip_def);
fold_stmt_inplace (use_stmt);
update_stmt (use_stmt);
}
}
static tree
lhs_of_dominating_assert (tree op, basic_block bb, gimple stmt)
{
imm_use_iterator imm_iter;
gimple use_stmt;
use_operand_p use_p;
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
{
use_stmt = USE_STMT (use_p);
if (use_stmt != stmt
&& gimple_assign_single_p (use_stmt)
&& TREE_CODE (gimple_assign_rhs1 (use_stmt)) == ASSERT_EXPR
&& TREE_OPERAND (gimple_assign_rhs1 (use_stmt), 0) == op
&& dominated_by_p (CDI_DOMINATORS, bb, gimple_bb (use_stmt)))
{
return gimple_assign_lhs (use_stmt);
}
}
static void
execute_cse_reciprocals_1 (gimple_stmt_iterator *def_gsi, tree def)
{
use_operand_p use_p;
imm_use_iterator use_iter;
struct occurrence *occ;
int count = 0, threshold;
gcc_assert (FLOAT_TYPE_P (TREE_TYPE (def)) && is_gimple_reg (def));
FOR_EACH_IMM_USE_FAST (use_p, use_iter, def)
{
gimple use_stmt = USE_STMT (use_p);
if (is_division_by (use_stmt, def))
{
register_division_in (gimple_bb (use_stmt));
count++;
}
}
static tree
lhs_of_dominating_assert (tree op, basic_block bb, tree stmt)
{
imm_use_iterator imm_iter;
tree use_stmt;
use_operand_p use_p;
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
{
use_stmt = USE_STMT (use_p);
if (use_stmt != stmt
&& TREE_CODE (use_stmt) == MODIFY_EXPR
&& TREE_CODE (TREE_OPERAND (use_stmt, 1)) == ASSERT_EXPR
&& TREE_OPERAND (TREE_OPERAND (use_stmt, 1), 0) == op
&& dominated_by_p (CDI_DOMINATORS, bb, bb_for_stmt (use_stmt)))
{
return TREE_OPERAND (use_stmt, 0);
}
}
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 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)
{
gimple use_stmt = USE_STMT (use_p);
if (prop_simulate_again_p (use_stmt)
&& !gimple_plf (use_stmt, STMT_IN_SSA_EDGE_WORKLIST))
{
gimple_set_plf (use_stmt, STMT_IN_SSA_EDGE_WORKLIST, true);
if (is_varying)
vec_safe_push (varying_ssa_edges, use_stmt);
else
vec_safe_push (interesting_ssa_edges, use_stmt);
}
}
static basic_block
nearest_common_dominator_of_uses (def_operand_p def_p, bool *debug_stmts)
{
tree var = DEF_FROM_PTR (def_p);
bitmap blocks = BITMAP_ALLOC (NULL);
basic_block commondom;
unsigned int j;
bitmap_iterator bi;
imm_use_iterator imm_iter;
use_operand_p use_p;
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var)
{
gimple *usestmt = USE_STMT (use_p);
basic_block useblock;
if (gphi *phi = dyn_cast <gphi *> (usestmt))
{
int idx = PHI_ARG_INDEX_FROM_USE (use_p);
useblock = gimple_phi_arg_edge (phi, idx)->src;
}
else if (is_gimple_debug (usestmt))
{
*debug_stmts = true;
continue;
}
else
{
useblock = gimple_bb (usestmt);
}
/* Short circuit. Nothing dominates the entry block. */
if (useblock == ENTRY_BLOCK_PTR_FOR_FN (cfun))
{
BITMAP_FREE (blocks);
return NULL;
}
bitmap_set_bit (blocks, useblock->index);
}
void
insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
{
imm_use_iterator imm_iter;
use_operand_p use_p;
gimple *stmt;
gimple *def_stmt = NULL;
int usecount = 0;
tree value = NULL;
if (!MAY_HAVE_DEBUG_STMTS)
return;
/* If this name has already been registered for replacement, do nothing
as anything that uses this name isn't in SSA form. */
if (name_registered_for_update_p (var))
return;
/* Check whether there are debug stmts that reference this variable and,
if there are, decide whether we should use a debug temp. */
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var)
{
stmt = USE_STMT (use_p);
if (!gimple_debug_bind_p (stmt))
continue;
if (usecount++)
break;
if (gimple_debug_bind_get_value (stmt) != var)
{
/* Count this as an additional use, so as to make sure we
use a temp unless VAR's definition has a SINGLE_RHS that
can be shared. */
usecount++;
break;
}
}