590 lines
18 KiB
C
590 lines
18 KiB
C
/* Const/Copy propagation originating from degenerate PHIs
|
|
Copyright (C) 2001-2017 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3, or (at your option)
|
|
any later version.
|
|
|
|
GCC is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "backend.h"
|
|
#include "cfghooks.h"
|
|
#include "tree.h"
|
|
#include "gimple.h"
|
|
#include "ssa.h"
|
|
#include "fold-const.h"
|
|
#include "cfgloop.h"
|
|
#include "gimple-pretty-print.h"
|
|
#include "gimple-fold.h"
|
|
#include "tree-eh.h"
|
|
#include "gimple-iterator.h"
|
|
#include "tree-cfg.h"
|
|
#include "tree-pass.h"
|
|
#include "tree-ssa-propagate.h"
|
|
|
|
|
|
/* PHI-ONLY copy and constant propagation. This pass is meant to clean
|
|
up degenerate PHIs created by or exposed by jump threading. */
|
|
|
|
/* Given a statement STMT, which is either a PHI node or an assignment,
|
|
remove it from the IL. */
|
|
|
|
static void
|
|
remove_stmt_or_phi (gimple *stmt)
|
|
{
|
|
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
|
|
if (gimple_code (stmt) == GIMPLE_PHI)
|
|
remove_phi_node (&gsi, true);
|
|
else
|
|
{
|
|
gsi_remove (&gsi, true);
|
|
release_defs (stmt);
|
|
}
|
|
}
|
|
|
|
/* Given a statement STMT, which is either a PHI node or an assignment,
|
|
return the "rhs" of the node, in the case of a non-degenerate
|
|
phi, NULL is returned. */
|
|
|
|
static tree
|
|
get_rhs_or_phi_arg (gimple *stmt)
|
|
{
|
|
if (gimple_code (stmt) == GIMPLE_PHI)
|
|
return degenerate_phi_result (as_a <gphi *> (stmt));
|
|
else if (gimple_assign_single_p (stmt))
|
|
return gimple_assign_rhs1 (stmt);
|
|
else
|
|
gcc_unreachable ();
|
|
}
|
|
|
|
|
|
/* Given a statement STMT, which is either a PHI node or an assignment,
|
|
return the "lhs" of the node. */
|
|
|
|
static tree
|
|
get_lhs_or_phi_result (gimple *stmt)
|
|
{
|
|
if (gimple_code (stmt) == GIMPLE_PHI)
|
|
return gimple_phi_result (stmt);
|
|
else if (is_gimple_assign (stmt))
|
|
return gimple_assign_lhs (stmt);
|
|
else
|
|
gcc_unreachable ();
|
|
}
|
|
|
|
/* Propagate RHS into all uses of LHS (when possible).
|
|
|
|
RHS and LHS are derived from STMT, which is passed in solely so
|
|
that we can remove it if propagation is successful.
|
|
|
|
When propagating into a PHI node or into a statement which turns
|
|
into a trivial copy or constant initialization, set the
|
|
appropriate bit in INTERESTING_NAMEs so that we will visit those
|
|
nodes as well in an effort to pick up secondary optimization
|
|
opportunities.
|
|
|
|
NEED_EH_CLEANUP tracks blocks that need their EH information
|
|
cleaned up after changing EH information on a statement. */
|
|
|
|
static bool
|
|
propagate_rhs_into_lhs (gimple *stmt, tree lhs, tree rhs,
|
|
bitmap interesting_names, bitmap need_eh_cleanup)
|
|
{
|
|
bool cfg_altered = false;
|
|
|
|
/* First verify that propagation is valid. */
|
|
if (may_propagate_copy (lhs, rhs))
|
|
{
|
|
use_operand_p use_p;
|
|
imm_use_iterator iter;
|
|
gimple *use_stmt;
|
|
bool all = true;
|
|
|
|
/* Dump details. */
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
{
|
|
fprintf (dump_file, " Replacing '");
|
|
print_generic_expr (dump_file, lhs, dump_flags);
|
|
fprintf (dump_file, "' with %s '",
|
|
(TREE_CODE (rhs) != SSA_NAME ? "constant" : "variable"));
|
|
print_generic_expr (dump_file, rhs, dump_flags);
|
|
fprintf (dump_file, "'\n");
|
|
}
|
|
|
|
/* Walk over every use of LHS and try to replace the use with RHS.
|
|
At this point the only reason why such a propagation would not
|
|
be successful would be if the use occurs in an ASM_EXPR. */
|
|
FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
|
|
{
|
|
/* Leave debug stmts alone. If we succeed in propagating
|
|
all non-debug uses, we'll drop the DEF, and propagation
|
|
into debug stmts will occur then. */
|
|
if (gimple_debug_bind_p (use_stmt))
|
|
continue;
|
|
|
|
/* It's not always safe to propagate into an ASM_EXPR. */
|
|
if (gimple_code (use_stmt) == GIMPLE_ASM
|
|
&& ! may_propagate_copy_into_asm (lhs))
|
|
{
|
|
all = false;
|
|
continue;
|
|
}
|
|
|
|
/* It's not ok to propagate into the definition stmt of RHS.
|
|
<bb 9>:
|
|
# prephitmp.12_36 = PHI <g_67.1_6(9)>
|
|
g_67.1_6 = prephitmp.12_36;
|
|
goto <bb 9>;
|
|
While this is strictly all dead code we do not want to
|
|
deal with this here. */
|
|
if (TREE_CODE (rhs) == SSA_NAME
|
|
&& SSA_NAME_DEF_STMT (rhs) == use_stmt)
|
|
{
|
|
all = false;
|
|
continue;
|
|
}
|
|
|
|
/* Dump details. */
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
{
|
|
fprintf (dump_file, " Original statement:");
|
|
print_gimple_stmt (dump_file, use_stmt, 0, dump_flags);
|
|
}
|
|
|
|
/* Propagate the RHS into this use of the LHS. */
|
|
FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
|
|
propagate_value (use_p, rhs);
|
|
|
|
/* Special cases to avoid useless calls into the folding
|
|
routines, operand scanning, etc.
|
|
|
|
Propagation into a PHI may cause the PHI to become
|
|
a degenerate, so mark the PHI as interesting. No other
|
|
actions are necessary. */
|
|
if (gimple_code (use_stmt) == GIMPLE_PHI)
|
|
{
|
|
tree result;
|
|
|
|
/* Dump details. */
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
{
|
|
fprintf (dump_file, " Updated statement:");
|
|
print_gimple_stmt (dump_file, use_stmt, 0, dump_flags);
|
|
}
|
|
|
|
result = get_lhs_or_phi_result (use_stmt);
|
|
bitmap_set_bit (interesting_names, SSA_NAME_VERSION (result));
|
|
continue;
|
|
}
|
|
|
|
/* From this point onward we are propagating into a
|
|
real statement. Folding may (or may not) be possible,
|
|
we may expose new operands, expose dead EH edges,
|
|
etc. */
|
|
/* NOTE tuples. In the tuples world, fold_stmt_inplace
|
|
cannot fold a call that simplifies to a constant,
|
|
because the GIMPLE_CALL must be replaced by a
|
|
GIMPLE_ASSIGN, and there is no way to effect such a
|
|
transformation in-place. We might want to consider
|
|
using the more general fold_stmt here. */
|
|
{
|
|
gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
|
|
fold_stmt_inplace (&gsi);
|
|
}
|
|
|
|
/* Sometimes propagation can expose new operands to the
|
|
renamer. */
|
|
update_stmt (use_stmt);
|
|
|
|
/* Dump details. */
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
{
|
|
fprintf (dump_file, " Updated statement:");
|
|
print_gimple_stmt (dump_file, use_stmt, 0, dump_flags);
|
|
}
|
|
|
|
/* If we replaced a variable index with a constant, then
|
|
we would need to update the invariant flag for ADDR_EXPRs. */
|
|
if (gimple_assign_single_p (use_stmt)
|
|
&& TREE_CODE (gimple_assign_rhs1 (use_stmt)) == ADDR_EXPR)
|
|
recompute_tree_invariant_for_addr_expr
|
|
(gimple_assign_rhs1 (use_stmt));
|
|
|
|
/* If we cleaned up EH information from the statement,
|
|
mark its containing block as needing EH cleanups. */
|
|
if (maybe_clean_or_replace_eh_stmt (use_stmt, use_stmt))
|
|
{
|
|
bitmap_set_bit (need_eh_cleanup, gimple_bb (use_stmt)->index);
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
fprintf (dump_file, " Flagged to clear EH edges.\n");
|
|
}
|
|
|
|
/* Propagation may expose new trivial copy/constant propagation
|
|
opportunities. */
|
|
if (gimple_assign_single_p (use_stmt)
|
|
&& TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME
|
|
&& (TREE_CODE (gimple_assign_rhs1 (use_stmt)) == SSA_NAME
|
|
|| is_gimple_min_invariant (gimple_assign_rhs1 (use_stmt))))
|
|
{
|
|
tree result = get_lhs_or_phi_result (use_stmt);
|
|
bitmap_set_bit (interesting_names, SSA_NAME_VERSION (result));
|
|
}
|
|
|
|
/* Propagation into these nodes may make certain edges in
|
|
the CFG unexecutable. We want to identify them as PHI nodes
|
|
at the destination of those unexecutable edges may become
|
|
degenerates. */
|
|
else if (gimple_code (use_stmt) == GIMPLE_COND
|
|
|| gimple_code (use_stmt) == GIMPLE_SWITCH
|
|
|| gimple_code (use_stmt) == GIMPLE_GOTO)
|
|
{
|
|
tree val;
|
|
|
|
if (gimple_code (use_stmt) == GIMPLE_COND)
|
|
val = fold_binary_loc (gimple_location (use_stmt),
|
|
gimple_cond_code (use_stmt),
|
|
boolean_type_node,
|
|
gimple_cond_lhs (use_stmt),
|
|
gimple_cond_rhs (use_stmt));
|
|
else if (gimple_code (use_stmt) == GIMPLE_SWITCH)
|
|
val = gimple_switch_index (as_a <gswitch *> (use_stmt));
|
|
else
|
|
val = gimple_goto_dest (use_stmt);
|
|
|
|
if (val && is_gimple_min_invariant (val))
|
|
{
|
|
basic_block bb = gimple_bb (use_stmt);
|
|
edge te = find_taken_edge (bb, val);
|
|
if (!te)
|
|
continue;
|
|
|
|
edge_iterator ei;
|
|
edge e;
|
|
gimple_stmt_iterator gsi;
|
|
gphi_iterator psi;
|
|
|
|
/* Remove all outgoing edges except TE. */
|
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei));)
|
|
{
|
|
if (e != te)
|
|
{
|
|
/* Mark all the PHI nodes at the destination of
|
|
the unexecutable edge as interesting. */
|
|
for (psi = gsi_start_phis (e->dest);
|
|
!gsi_end_p (psi);
|
|
gsi_next (&psi))
|
|
{
|
|
gphi *phi = psi.phi ();
|
|
|
|
tree result = gimple_phi_result (phi);
|
|
int version = SSA_NAME_VERSION (result);
|
|
|
|
bitmap_set_bit (interesting_names, version);
|
|
}
|
|
|
|
te->probability += e->probability;
|
|
|
|
te->count += e->count;
|
|
remove_edge (e);
|
|
cfg_altered = true;
|
|
}
|
|
else
|
|
ei_next (&ei);
|
|
}
|
|
|
|
gsi = gsi_last_bb (gimple_bb (use_stmt));
|
|
gsi_remove (&gsi, true);
|
|
|
|
/* And fixup the flags on the single remaining edge. */
|
|
te->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);
|
|
te->flags &= ~EDGE_ABNORMAL;
|
|
te->flags |= EDGE_FALLTHRU;
|
|
if (te->probability > REG_BR_PROB_BASE)
|
|
te->probability = REG_BR_PROB_BASE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Ensure there is nothing else to do. */
|
|
gcc_assert (!all || has_zero_uses (lhs));
|
|
|
|
/* If we were able to propagate away all uses of LHS, then
|
|
we can remove STMT. */
|
|
if (all)
|
|
remove_stmt_or_phi (stmt);
|
|
}
|
|
return cfg_altered;
|
|
}
|
|
|
|
/* STMT is either a PHI node (potentially a degenerate PHI node) or
|
|
a statement that is a trivial copy or constant initialization.
|
|
|
|
Attempt to eliminate STMT by propagating its RHS into all uses of
|
|
its LHS. This may in turn set new bits in INTERESTING_NAMES
|
|
for nodes we want to revisit later.
|
|
|
|
All exit paths should clear INTERESTING_NAMES for the result
|
|
of STMT.
|
|
|
|
NEED_EH_CLEANUP tracks blocks that need their EH information
|
|
cleaned up after changing EH information on a statement. It is
|
|
not set or queried here, but passed along to children. */
|
|
|
|
static bool
|
|
eliminate_const_or_copy (gimple *stmt, bitmap interesting_names,
|
|
bitmap need_eh_cleanup)
|
|
{
|
|
tree lhs = get_lhs_or_phi_result (stmt);
|
|
tree rhs;
|
|
int version = SSA_NAME_VERSION (lhs);
|
|
bool cfg_altered = false;
|
|
|
|
/* If the LHS of this statement or PHI has no uses, then we can
|
|
just eliminate it. This can occur if, for example, the PHI
|
|
was created by block duplication due to threading and its only
|
|
use was in the conditional at the end of the block which was
|
|
deleted. */
|
|
if (has_zero_uses (lhs))
|
|
{
|
|
bitmap_clear_bit (interesting_names, version);
|
|
remove_stmt_or_phi (stmt);
|
|
return cfg_altered;
|
|
}
|
|
|
|
/* Get the RHS of the assignment or PHI node if the PHI is a
|
|
degenerate. */
|
|
rhs = get_rhs_or_phi_arg (stmt);
|
|
if (!rhs)
|
|
{
|
|
bitmap_clear_bit (interesting_names, version);
|
|
return cfg_altered;
|
|
}
|
|
|
|
if (!virtual_operand_p (lhs))
|
|
cfg_altered = propagate_rhs_into_lhs (stmt, lhs, rhs,
|
|
interesting_names, need_eh_cleanup);
|
|
else
|
|
{
|
|
gimple *use_stmt;
|
|
imm_use_iterator iter;
|
|
use_operand_p use_p;
|
|
/* For virtual operands we have to propagate into all uses as
|
|
otherwise we will create overlapping life-ranges. */
|
|
FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
|
|
FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
|
|
SET_USE (use_p, rhs);
|
|
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
|
|
SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs) = 1;
|
|
remove_stmt_or_phi (stmt);
|
|
}
|
|
|
|
/* Note that STMT may well have been deleted by now, so do
|
|
not access it, instead use the saved version # to clear
|
|
T's entry in the worklist. */
|
|
bitmap_clear_bit (interesting_names, version);
|
|
return cfg_altered;
|
|
}
|
|
|
|
/* The first phase in degenerate PHI elimination.
|
|
|
|
Eliminate the degenerate PHIs in BB, then recurse on the
|
|
dominator children of BB.
|
|
|
|
INTERESTING_NAMES tracks SSA_NAMEs that we may want to revisit
|
|
in the future. It is not set or queried here, but passed along
|
|
to children.
|
|
|
|
NEED_EH_CLEANUP tracks blocks that need their EH information
|
|
cleaned up after changing EH information on a statement. It is
|
|
not set or queried here, but passed along to children. */
|
|
|
|
static bool
|
|
eliminate_degenerate_phis_1 (basic_block bb, bitmap interesting_names,
|
|
bitmap need_eh_cleanup)
|
|
{
|
|
gphi_iterator gsi;
|
|
basic_block son;
|
|
bool cfg_altered = false;
|
|
|
|
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
|
{
|
|
gphi *phi = gsi.phi ();
|
|
|
|
cfg_altered |= eliminate_const_or_copy (phi, interesting_names,
|
|
need_eh_cleanup);
|
|
}
|
|
|
|
/* Recurse into the dominator children of BB. */
|
|
for (son = first_dom_son (CDI_DOMINATORS, bb);
|
|
son;
|
|
son = next_dom_son (CDI_DOMINATORS, son))
|
|
cfg_altered |= eliminate_degenerate_phis_1 (son, interesting_names,
|
|
need_eh_cleanup);
|
|
|
|
return cfg_altered;
|
|
}
|
|
|
|
|
|
/* A very simple pass to eliminate degenerate PHI nodes from the
|
|
IL. This is meant to be fast enough to be able to be run several
|
|
times in the optimization pipeline.
|
|
|
|
Certain optimizations, particularly those which duplicate blocks
|
|
or remove edges from the CFG can create or expose PHIs which are
|
|
trivial copies or constant initializations.
|
|
|
|
While we could pick up these optimizations in DOM or with the
|
|
combination of copy-prop and CCP, those solutions are far too
|
|
heavy-weight for our needs.
|
|
|
|
This implementation has two phases so that we can efficiently
|
|
eliminate the first order degenerate PHIs and second order
|
|
degenerate PHIs.
|
|
|
|
The first phase performs a dominator walk to identify and eliminate
|
|
the vast majority of the degenerate PHIs. When a degenerate PHI
|
|
is identified and eliminated any affected statements or PHIs
|
|
are put on a worklist.
|
|
|
|
The second phase eliminates degenerate PHIs and trivial copies
|
|
or constant initializations using the worklist. This is how we
|
|
pick up the secondary optimization opportunities with minimal
|
|
cost. */
|
|
|
|
namespace {
|
|
|
|
const pass_data pass_data_phi_only_cprop =
|
|
{
|
|
GIMPLE_PASS, /* type */
|
|
"phicprop", /* name */
|
|
OPTGROUP_NONE, /* optinfo_flags */
|
|
TV_TREE_PHI_CPROP, /* tv_id */
|
|
( PROP_cfg | PROP_ssa ), /* properties_required */
|
|
0, /* properties_provided */
|
|
0, /* properties_destroyed */
|
|
0, /* todo_flags_start */
|
|
( TODO_cleanup_cfg | TODO_update_ssa ), /* todo_flags_finish */
|
|
};
|
|
|
|
class pass_phi_only_cprop : public gimple_opt_pass
|
|
{
|
|
public:
|
|
pass_phi_only_cprop (gcc::context *ctxt)
|
|
: gimple_opt_pass (pass_data_phi_only_cprop, ctxt)
|
|
{}
|
|
|
|
/* opt_pass methods: */
|
|
opt_pass * clone () { return new pass_phi_only_cprop (m_ctxt); }
|
|
virtual bool gate (function *) { return flag_tree_dom != 0; }
|
|
virtual unsigned int execute (function *);
|
|
|
|
}; // class pass_phi_only_cprop
|
|
|
|
unsigned int
|
|
pass_phi_only_cprop::execute (function *fun)
|
|
{
|
|
bitmap interesting_names;
|
|
bitmap interesting_names1;
|
|
bool cfg_altered = false;
|
|
|
|
/* Bitmap of blocks which need EH information updated. We can not
|
|
update it on-the-fly as doing so invalidates the dominator tree. */
|
|
bitmap need_eh_cleanup = BITMAP_ALLOC (NULL);
|
|
|
|
/* INTERESTING_NAMES is effectively our worklist, indexed by
|
|
SSA_NAME_VERSION.
|
|
|
|
A set bit indicates that the statement or PHI node which
|
|
defines the SSA_NAME should be (re)examined to determine if
|
|
it has become a degenerate PHI or trivial const/copy propagation
|
|
opportunity.
|
|
|
|
Experiments have show we generally get better compilation
|
|
time behavior with bitmaps rather than sbitmaps. */
|
|
interesting_names = BITMAP_ALLOC (NULL);
|
|
interesting_names1 = BITMAP_ALLOC (NULL);
|
|
|
|
calculate_dominance_info (CDI_DOMINATORS);
|
|
cfg_altered = false;
|
|
|
|
/* First phase. Eliminate degenerate PHIs via a dominator
|
|
walk of the CFG.
|
|
|
|
Experiments have indicated that we generally get better
|
|
compile-time behavior by visiting blocks in the first
|
|
phase in dominator order. Presumably this is because walking
|
|
in dominator order leaves fewer PHIs for later examination
|
|
by the worklist phase. */
|
|
cfg_altered = eliminate_degenerate_phis_1 (ENTRY_BLOCK_PTR_FOR_FN (fun),
|
|
interesting_names,
|
|
need_eh_cleanup);
|
|
|
|
/* Second phase. Eliminate second order degenerate PHIs as well
|
|
as trivial copies or constant initializations identified by
|
|
the first phase or this phase. Basically we keep iterating
|
|
until our set of INTERESTING_NAMEs is empty. */
|
|
while (!bitmap_empty_p (interesting_names))
|
|
{
|
|
unsigned int i;
|
|
bitmap_iterator bi;
|
|
|
|
/* EXECUTE_IF_SET_IN_BITMAP does not like its bitmap
|
|
changed during the loop. Copy it to another bitmap and
|
|
use that. */
|
|
bitmap_copy (interesting_names1, interesting_names);
|
|
|
|
EXECUTE_IF_SET_IN_BITMAP (interesting_names1, 0, i, bi)
|
|
{
|
|
tree name = ssa_name (i);
|
|
|
|
/* Ignore SSA_NAMEs that have been released because
|
|
their defining statement was deleted (unreachable). */
|
|
if (name)
|
|
cfg_altered
|
|
|= eliminate_const_or_copy (SSA_NAME_DEF_STMT (ssa_name (i)),
|
|
interesting_names, need_eh_cleanup);
|
|
}
|
|
}
|
|
|
|
if (cfg_altered)
|
|
{
|
|
free_dominance_info (CDI_DOMINATORS);
|
|
/* If we changed the CFG schedule loops for fixup by cfgcleanup. */
|
|
loops_state_set (LOOPS_NEED_FIXUP);
|
|
}
|
|
|
|
/* Propagation of const and copies may make some EH edges dead. Purge
|
|
such edges from the CFG as needed. */
|
|
if (!bitmap_empty_p (need_eh_cleanup))
|
|
{
|
|
gimple_purge_all_dead_eh_edges (need_eh_cleanup);
|
|
BITMAP_FREE (need_eh_cleanup);
|
|
}
|
|
|
|
BITMAP_FREE (interesting_names);
|
|
BITMAP_FREE (interesting_names1);
|
|
return 0;
|
|
}
|
|
|
|
} // anon namespace
|
|
|
|
gimple_opt_pass *
|
|
make_pass_phi_only_cprop (gcc::context *ctxt)
|
|
{
|
|
return new pass_phi_only_cprop (ctxt);
|
|
}
|