static bool
forward_propagate_addr_expr (tree name, tree rhs)
{
int stmt_loop_depth = gimple_bb (SSA_NAME_DEF_STMT (name))->loop_depth;
imm_use_iterator iter;
gimple use_stmt;
bool all = true;
bool single_use_p = has_single_use (name);
FOR_EACH_IMM_USE_STMT (use_stmt, iter, name)
{
bool result;
tree use_rhs;
/* If the use is not in a simple assignment statement, then
there is nothing we can do. */
if (gimple_code (use_stmt) != GIMPLE_ASSIGN)
{
if (!is_gimple_debug (use_stmt))
all = false;
continue;
}
/* If the use is in a deeper loop nest, then we do not want
to propagate the ADDR_EXPR into the loop as that is likely
adding expression evaluations into the loop. */
if (gimple_bb (use_stmt)->loop_depth > stmt_loop_depth)
{
all = false;
continue;
}
{
gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
result = forward_propagate_addr_expr_1 (name, rhs, &gsi,
single_use_p);
/* If the use has moved to a different statement adjust
the update machinery for the old statement too. */
if (use_stmt != gsi_stmt (gsi))
{
update_stmt (use_stmt);
use_stmt = gsi_stmt (gsi);
}
update_stmt (use_stmt);
}
all &= result;
/* Remove intermediate now unused copy and conversion chains. */
use_rhs = gimple_assign_rhs1 (use_stmt);
if (result
&& TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME
&& TREE_CODE (use_rhs) == SSA_NAME
&& has_zero_uses (gimple_assign_lhs (use_stmt)))
{
gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
release_defs (use_stmt);
gsi_remove (&gsi, true);
}
}
static bool
generate_loops_for_partition (struct loop *loop, bitmap partition, bool copy_p)
{
unsigned i, x;
gimple_stmt_iterator bsi;
basic_block *bbs;
if (copy_p)
{
loop = copy_loop_before (loop);
create_preheader (loop, CP_SIMPLE_PREHEADERS);
create_bb_after_loop (loop);
}
if (loop == NULL)
return false;
/* Remove stmts not in the PARTITION bitmap. The order in which we
visit the phi nodes and the statements is exactly as in
stmts_from_loop. */
bbs = get_loop_body_in_dom_order (loop);
for (x = 0, i = 0; i < loop->num_nodes; i++)
{
basic_block bb = bbs[i];
for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi);)
if (!bitmap_bit_p (partition, x++))
{
gimple phi = gsi_stmt (bsi);
if (!is_gimple_reg (gimple_phi_result (phi)))
mark_virtual_phi_result_for_renaming (phi);
remove_phi_node (&bsi, true);
}
else
gsi_next (&bsi);
for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi);)
{
gimple stmt = gsi_stmt (bsi);
if (gimple_code (gsi_stmt (bsi)) != GIMPLE_LABEL
&& !bitmap_bit_p (partition, x++))
{
unlink_stmt_vdef (stmt);
gsi_remove (&bsi, true);
release_defs (stmt);
}
else
gsi_next (&bsi);
}
}
free (bbs);
return true;
}
static void
insert_trap_and_remove_trailing_statements (gimple_stmt_iterator *si_p, tree op)
{
/* We want the NULL pointer dereference to actually occur so that
code that wishes to catch the signal can do so.
If the dereference is a load, then there's nothing to do as the
LHS will be a throw-away SSA_NAME and the RHS is the NULL dereference.
If the dereference is a store and we can easily transform the RHS,
then simplify the RHS to enable more DCE. Note that we require the
statement to be a GIMPLE_ASSIGN which filters out calls on the RHS. */
gimple stmt = gsi_stmt (*si_p);
if (walk_stmt_load_store_ops (stmt, (void *)op, NULL, check_loadstore)
&& is_gimple_assign (stmt)
&& INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
{
/* We just need to turn the RHS into zero converted to the proper
type. */
tree type = TREE_TYPE (gimple_assign_lhs (stmt));
gimple_assign_set_rhs_code (stmt, INTEGER_CST);
gimple_assign_set_rhs1 (stmt, fold_convert (type, integer_zero_node));
update_stmt (stmt);
}
gimple new_stmt
= gimple_build_call (builtin_decl_explicit (BUILT_IN_TRAP), 0);
gimple_seq seq = NULL;
gimple_seq_add_stmt (&seq, new_stmt);
/* If we had a NULL pointer dereference, then we want to insert the
__builtin_trap after the statement, for the other cases we want
to insert before the statement. */
if (walk_stmt_load_store_ops (stmt, (void *)op,
check_loadstore,
check_loadstore))
gsi_insert_after (si_p, seq, GSI_NEW_STMT);
else
gsi_insert_before (si_p, seq, GSI_NEW_STMT);
/* We must remove statements from the end of the block so that we
never reference a released SSA_NAME. */
basic_block bb = gimple_bb (gsi_stmt (*si_p));
for (gimple_stmt_iterator si = gsi_last_bb (bb);
gsi_stmt (si) != gsi_stmt (*si_p);
si = gsi_last_bb (bb))
{
stmt = gsi_stmt (si);
unlink_stmt_vdef (stmt);
gsi_remove (&si, true);
release_defs (stmt);
}
}
static void
remove_unused_var (tree var)
{
gimple *stmt = SSA_NAME_DEF_STMT (var);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Deleting ");
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
gsi_remove (&gsi, true);
release_defs (stmt);
}
/* Try to compare bounds value and address value
used in the check CI. If we can prove that check
always pass then remove it. */
static void
chkp_remove_check_if_pass (struct check_info *ci)
{
int result = 0;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Trying to remove check: ");
print_gimple_stmt (dump_file, ci->stmt, 0, 0);
}
result = chkp_get_check_result (ci, ci->bounds);
if (result == 1)
{
gimple_stmt_iterator i = gsi_for_stmt (ci->stmt);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " action: delete check (always pass)\n");
gsi_remove (&i, true);
unlink_stmt_vdef (ci->stmt);
release_defs (ci->stmt);
ci->stmt = NULL;
}
else if (result == -1)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " action: keep check (always fail)\n");
warning_at (gimple_location (ci->stmt), OPT_Wchkp,
"memory access check always fail");
}
else if (result == 0)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " action: keep check (cannot compute result)\n");
}
}
static bool
remove_prop_source_from_use (tree name, gimple up_to_stmt)
{
gimple_stmt_iterator gsi;
gimple stmt;
do {
if (!has_zero_uses (name))
return false;
stmt = SSA_NAME_DEF_STMT (name);
if (stmt == up_to_stmt)
return true;
gsi = gsi_for_stmt (stmt);
release_defs (stmt);
gsi_remove (&gsi, true);
name = (gimple_assign_copy_p (stmt)) ? gimple_assign_rhs1 (stmt) : NULL;
} while (name && TREE_CODE (name) == SSA_NAME);
return false;
}
static void
eliminate_tail_call (struct tailcall *t)
{
tree param, rslt;
gimple stmt, call;
tree arg;
size_t idx;
basic_block bb, first;
edge e;
gimple phi;
gimple_stmt_iterator gsi;
gimple orig_stmt;
stmt = orig_stmt = gsi_stmt (t->call_gsi);
bb = gsi_bb (t->call_gsi);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Eliminated tail recursion in bb %d : ",
bb->index);
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
fprintf (dump_file, "\n");
}
gcc_assert (is_gimple_call (stmt));
first = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
/* Remove the code after call_gsi that will become unreachable. The
possibly unreachable code in other blocks is removed later in
cfg cleanup. */
gsi = t->call_gsi;
gsi_next (&gsi);
while (!gsi_end_p (gsi))
{
gimple t = gsi_stmt (gsi);
/* Do not remove the return statement, so that redirect_edge_and_branch
sees how the block ends. */
if (gimple_code (t) == GIMPLE_RETURN)
break;
gsi_remove (&gsi, true);
release_defs (t);
}
/* Number of executions of function has reduced by the tailcall. */
e = single_succ_edge (gsi_bb (t->call_gsi));
decrease_profile (EXIT_BLOCK_PTR_FOR_FN (cfun), e->count, EDGE_FREQUENCY (e));
decrease_profile (ENTRY_BLOCK_PTR_FOR_FN (cfun), e->count,
EDGE_FREQUENCY (e));
if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
decrease_profile (e->dest, e->count, EDGE_FREQUENCY (e));
/* Replace the call by a jump to the start of function. */
e = redirect_edge_and_branch (single_succ_edge (gsi_bb (t->call_gsi)),
first);
gcc_assert (e);
PENDING_STMT (e) = NULL;
/* Add phi node entries for arguments. The ordering of the phi nodes should
be the same as the ordering of the arguments. */
for (param = DECL_ARGUMENTS (current_function_decl),
idx = 0, gsi = gsi_start_phis (first);
param;
param = DECL_CHAIN (param), idx++)
{
if (!arg_needs_copy_p (param))
continue;
arg = gimple_call_arg (stmt, idx);
phi = gsi_stmt (gsi);
gcc_assert (param == SSA_NAME_VAR (PHI_RESULT (phi)));
add_phi_arg (phi, arg, e, gimple_location (stmt));
gsi_next (&gsi);
}
/* Update the values of accumulators. */
adjust_accumulator_values (t->call_gsi, t->mult, t->add, e);
call = gsi_stmt (t->call_gsi);
rslt = gimple_call_lhs (call);
if (rslt != NULL_TREE)
{
/* Result of the call will no longer be defined. So adjust the
SSA_NAME_DEF_STMT accordingly. */
SSA_NAME_DEF_STMT (rslt) = gimple_build_nop ();
}
gsi_remove (&t->call_gsi, true);
release_defs (call);
}
