/* CFG cleanup for trees.
|
/* CFG cleanup for trees.
|
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify
|
GCC is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3, or (at your option)
|
the Free Software Foundation; either version 3, or (at your option)
|
any later version.
|
any later version.
|
|
|
GCC is distributed in the hope that it will be useful,
|
GCC is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "output.h"
|
#include "output.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "function.h"
|
#include "function.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "except.h"
|
#include "except.h"
|
#include "cfgloop.h"
|
#include "cfgloop.h"
|
#include "cfglayout.h"
|
#include "cfglayout.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "tree-ssa-propagate.h"
|
#include "tree-ssa-propagate.h"
|
#include "tree-scalar-evolution.h"
|
#include "tree-scalar-evolution.h"
|
|
|
/* Remove any fallthru edge from EV. Return true if an edge was removed. */
|
/* Remove any fallthru edge from EV. Return true if an edge was removed. */
|
|
|
static bool
|
static bool
|
remove_fallthru_edge (VEC(edge,gc) *ev)
|
remove_fallthru_edge (VEC(edge,gc) *ev)
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
FOR_EACH_EDGE (e, ei, ev)
|
FOR_EACH_EDGE (e, ei, ev)
|
if ((e->flags & EDGE_FALLTHRU) != 0)
|
if ((e->flags & EDGE_FALLTHRU) != 0)
|
{
|
{
|
remove_edge (e);
|
remove_edge (e);
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Disconnect an unreachable block in the control expression starting
|
/* Disconnect an unreachable block in the control expression starting
|
at block BB. */
|
at block BB. */
|
|
|
static bool
|
static bool
|
cleanup_control_expr_graph (basic_block bb, block_stmt_iterator bsi)
|
cleanup_control_expr_graph (basic_block bb, block_stmt_iterator bsi)
|
{
|
{
|
edge taken_edge;
|
edge taken_edge;
|
bool retval = false;
|
bool retval = false;
|
tree expr = bsi_stmt (bsi), val;
|
tree expr = bsi_stmt (bsi), val;
|
|
|
if (!single_succ_p (bb))
|
if (!single_succ_p (bb))
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
bool warned;
|
bool warned;
|
|
|
fold_defer_overflow_warnings ();
|
fold_defer_overflow_warnings ();
|
|
|
switch (TREE_CODE (expr))
|
switch (TREE_CODE (expr))
|
{
|
{
|
case COND_EXPR:
|
case COND_EXPR:
|
val = fold (COND_EXPR_COND (expr));
|
val = fold (COND_EXPR_COND (expr));
|
break;
|
break;
|
|
|
case SWITCH_EXPR:
|
case SWITCH_EXPR:
|
val = fold (SWITCH_COND (expr));
|
val = fold (SWITCH_COND (expr));
|
if (TREE_CODE (val) != INTEGER_CST)
|
if (TREE_CODE (val) != INTEGER_CST)
|
{
|
{
|
fold_undefer_and_ignore_overflow_warnings ();
|
fold_undefer_and_ignore_overflow_warnings ();
|
return false;
|
return false;
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
taken_edge = find_taken_edge (bb, val);
|
taken_edge = find_taken_edge (bb, val);
|
if (!taken_edge)
|
if (!taken_edge)
|
{
|
{
|
fold_undefer_and_ignore_overflow_warnings ();
|
fold_undefer_and_ignore_overflow_warnings ();
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Remove all the edges except the one that is always executed. */
|
/* Remove all the edges except the one that is always executed. */
|
warned = false;
|
warned = false;
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
{
|
{
|
if (e != taken_edge)
|
if (e != taken_edge)
|
{
|
{
|
if (!warned)
|
if (!warned)
|
{
|
{
|
fold_undefer_overflow_warnings
|
fold_undefer_overflow_warnings
|
(true, expr, WARN_STRICT_OVERFLOW_CONDITIONAL);
|
(true, expr, WARN_STRICT_OVERFLOW_CONDITIONAL);
|
warned = true;
|
warned = true;
|
}
|
}
|
|
|
taken_edge->probability += e->probability;
|
taken_edge->probability += e->probability;
|
taken_edge->count += e->count;
|
taken_edge->count += e->count;
|
remove_edge (e);
|
remove_edge (e);
|
retval = true;
|
retval = true;
|
}
|
}
|
else
|
else
|
ei_next (&ei);
|
ei_next (&ei);
|
}
|
}
|
if (!warned)
|
if (!warned)
|
fold_undefer_and_ignore_overflow_warnings ();
|
fold_undefer_and_ignore_overflow_warnings ();
|
if (taken_edge->probability > REG_BR_PROB_BASE)
|
if (taken_edge->probability > REG_BR_PROB_BASE)
|
taken_edge->probability = REG_BR_PROB_BASE;
|
taken_edge->probability = REG_BR_PROB_BASE;
|
}
|
}
|
else
|
else
|
taken_edge = single_succ_edge (bb);
|
taken_edge = single_succ_edge (bb);
|
|
|
bsi_remove (&bsi, true);
|
bsi_remove (&bsi, true);
|
taken_edge->flags = EDGE_FALLTHRU;
|
taken_edge->flags = EDGE_FALLTHRU;
|
|
|
/* We removed some paths from the cfg. */
|
/* We removed some paths from the cfg. */
|
free_dominance_info (CDI_DOMINATORS);
|
free_dominance_info (CDI_DOMINATORS);
|
|
|
return retval;
|
return retval;
|
}
|
}
|
|
|
/* A list of all the noreturn calls passed to modify_stmt.
|
/* A list of all the noreturn calls passed to modify_stmt.
|
cleanup_control_flow uses it to detect cases where a mid-block
|
cleanup_control_flow uses it to detect cases where a mid-block
|
indirect call has been turned into a noreturn call. When this
|
indirect call has been turned into a noreturn call. When this
|
happens, all the instructions after the call are no longer
|
happens, all the instructions after the call are no longer
|
reachable and must be deleted as dead. */
|
reachable and must be deleted as dead. */
|
|
|
VEC(tree,gc) *modified_noreturn_calls;
|
VEC(tree,gc) *modified_noreturn_calls;
|
|
|
/* Try to remove superfluous control structures. */
|
/* Try to remove superfluous control structures. */
|
|
|
static bool
|
static bool
|
cleanup_control_flow (void)
|
cleanup_control_flow (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
block_stmt_iterator bsi;
|
block_stmt_iterator bsi;
|
bool retval = false;
|
bool retval = false;
|
tree stmt;
|
tree stmt;
|
|
|
/* Detect cases where a mid-block call is now known not to return. */
|
/* Detect cases where a mid-block call is now known not to return. */
|
while (VEC_length (tree, modified_noreturn_calls))
|
while (VEC_length (tree, modified_noreturn_calls))
|
{
|
{
|
stmt = VEC_pop (tree, modified_noreturn_calls);
|
stmt = VEC_pop (tree, modified_noreturn_calls);
|
bb = bb_for_stmt (stmt);
|
bb = bb_for_stmt (stmt);
|
if (bb != NULL && last_stmt (bb) != stmt && noreturn_call_p (stmt))
|
if (bb != NULL && last_stmt (bb) != stmt && noreturn_call_p (stmt))
|
split_block (bb, stmt);
|
split_block (bb, stmt);
|
}
|
}
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
bsi = bsi_last (bb);
|
bsi = bsi_last (bb);
|
|
|
/* If the last statement of the block could throw and now cannot,
|
/* If the last statement of the block could throw and now cannot,
|
we need to prune cfg. */
|
we need to prune cfg. */
|
retval |= tree_purge_dead_eh_edges (bb);
|
retval |= tree_purge_dead_eh_edges (bb);
|
|
|
if (bsi_end_p (bsi))
|
if (bsi_end_p (bsi))
|
continue;
|
continue;
|
|
|
stmt = bsi_stmt (bsi);
|
stmt = bsi_stmt (bsi);
|
|
|
if (TREE_CODE (stmt) == COND_EXPR
|
if (TREE_CODE (stmt) == COND_EXPR
|
|| TREE_CODE (stmt) == SWITCH_EXPR)
|
|| TREE_CODE (stmt) == SWITCH_EXPR)
|
retval |= cleanup_control_expr_graph (bb, bsi);
|
retval |= cleanup_control_expr_graph (bb, bsi);
|
/* If we had a computed goto which has a compile-time determinable
|
/* If we had a computed goto which has a compile-time determinable
|
destination, then we can eliminate the goto. */
|
destination, then we can eliminate the goto. */
|
else if (TREE_CODE (stmt) == GOTO_EXPR
|
else if (TREE_CODE (stmt) == GOTO_EXPR
|
&& TREE_CODE (GOTO_DESTINATION (stmt)) == ADDR_EXPR
|
&& TREE_CODE (GOTO_DESTINATION (stmt)) == ADDR_EXPR
|
&& (TREE_CODE (TREE_OPERAND (GOTO_DESTINATION (stmt), 0))
|
&& (TREE_CODE (TREE_OPERAND (GOTO_DESTINATION (stmt), 0))
|
== LABEL_DECL))
|
== LABEL_DECL))
|
{
|
{
|
edge e;
|
edge e;
|
tree label;
|
tree label;
|
edge_iterator ei;
|
edge_iterator ei;
|
basic_block target_block;
|
basic_block target_block;
|
bool removed_edge = false;
|
bool removed_edge = false;
|
|
|
/* First look at all the outgoing edges. Delete any outgoing
|
/* First look at all the outgoing edges. Delete any outgoing
|
edges which do not go to the right block. For the one
|
edges which do not go to the right block. For the one
|
edge which goes to the right block, fix up its flags. */
|
edge which goes to the right block, fix up its flags. */
|
label = TREE_OPERAND (GOTO_DESTINATION (stmt), 0);
|
label = TREE_OPERAND (GOTO_DESTINATION (stmt), 0);
|
target_block = label_to_block (label);
|
target_block = label_to_block (label);
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
{
|
{
|
if (e->dest != target_block)
|
if (e->dest != target_block)
|
{
|
{
|
removed_edge = true;
|
removed_edge = true;
|
remove_edge (e);
|
remove_edge (e);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Turn off the EDGE_ABNORMAL flag. */
|
/* Turn off the EDGE_ABNORMAL flag. */
|
e->flags &= ~EDGE_ABNORMAL;
|
e->flags &= ~EDGE_ABNORMAL;
|
|
|
/* And set EDGE_FALLTHRU. */
|
/* And set EDGE_FALLTHRU. */
|
e->flags |= EDGE_FALLTHRU;
|
e->flags |= EDGE_FALLTHRU;
|
ei_next (&ei);
|
ei_next (&ei);
|
}
|
}
|
}
|
}
|
|
|
/* If we removed one or more edges, then we will need to fix the
|
/* If we removed one or more edges, then we will need to fix the
|
dominators. It may be possible to incrementally update them. */
|
dominators. It may be possible to incrementally update them. */
|
if (removed_edge)
|
if (removed_edge)
|
free_dominance_info (CDI_DOMINATORS);
|
free_dominance_info (CDI_DOMINATORS);
|
|
|
/* Remove the GOTO_EXPR as it is not needed. The CFG has all the
|
/* Remove the GOTO_EXPR as it is not needed. The CFG has all the
|
relevant information we need. */
|
relevant information we need. */
|
bsi_remove (&bsi, true);
|
bsi_remove (&bsi, true);
|
retval = true;
|
retval = true;
|
}
|
}
|
|
|
/* Check for indirect calls that have been turned into
|
/* Check for indirect calls that have been turned into
|
noreturn calls. */
|
noreturn calls. */
|
else if (noreturn_call_p (stmt) && remove_fallthru_edge (bb->succs))
|
else if (noreturn_call_p (stmt) && remove_fallthru_edge (bb->succs))
|
{
|
{
|
free_dominance_info (CDI_DOMINATORS);
|
free_dominance_info (CDI_DOMINATORS);
|
retval = true;
|
retval = true;
|
}
|
}
|
}
|
}
|
return retval;
|
return retval;
|
}
|
}
|
|
|
/* Return true if basic block BB does nothing except pass control
|
/* Return true if basic block BB does nothing except pass control
|
flow to another block and that we can safely insert a label at
|
flow to another block and that we can safely insert a label at
|
the start of the successor block.
|
the start of the successor block.
|
|
|
As a precondition, we require that BB be not equal to
|
As a precondition, we require that BB be not equal to
|
ENTRY_BLOCK_PTR. */
|
ENTRY_BLOCK_PTR. */
|
|
|
static bool
|
static bool
|
tree_forwarder_block_p (basic_block bb, bool phi_wanted)
|
tree_forwarder_block_p (basic_block bb, bool phi_wanted)
|
{
|
{
|
block_stmt_iterator bsi;
|
block_stmt_iterator bsi;
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e, succ;
|
edge e, succ;
|
basic_block dest;
|
basic_block dest;
|
|
|
/* BB must have a single outgoing edge. */
|
/* BB must have a single outgoing edge. */
|
if (single_succ_p (bb) != 1
|
if (single_succ_p (bb) != 1
|
/* If PHI_WANTED is false, BB must not have any PHI nodes.
|
/* If PHI_WANTED is false, BB must not have any PHI nodes.
|
Otherwise, BB must have PHI nodes. */
|
Otherwise, BB must have PHI nodes. */
|
|| (phi_nodes (bb) != NULL_TREE) != phi_wanted
|
|| (phi_nodes (bb) != NULL_TREE) != phi_wanted
|
/* BB may not be a predecessor of EXIT_BLOCK_PTR. */
|
/* BB may not be a predecessor of EXIT_BLOCK_PTR. */
|
|| single_succ (bb) == EXIT_BLOCK_PTR
|
|| single_succ (bb) == EXIT_BLOCK_PTR
|
/* Nor should this be an infinite loop. */
|
/* Nor should this be an infinite loop. */
|
|| single_succ (bb) == bb
|
|| single_succ (bb) == bb
|
/* BB may not have an abnormal outgoing edge. */
|
/* BB may not have an abnormal outgoing edge. */
|
|| (single_succ_edge (bb)->flags & EDGE_ABNORMAL))
|
|| (single_succ_edge (bb)->flags & EDGE_ABNORMAL))
|
return false;
|
return false;
|
|
|
#if ENABLE_CHECKING
|
#if ENABLE_CHECKING
|
gcc_assert (bb != ENTRY_BLOCK_PTR);
|
gcc_assert (bb != ENTRY_BLOCK_PTR);
|
#endif
|
#endif
|
|
|
/* Now walk through the statements backward. We can ignore labels,
|
/* Now walk through the statements backward. We can ignore labels,
|
anything else means this is not a forwarder block. */
|
anything else means this is not a forwarder block. */
|
for (bsi = bsi_last (bb); !bsi_end_p (bsi); bsi_prev (&bsi))
|
for (bsi = bsi_last (bb); !bsi_end_p (bsi); bsi_prev (&bsi))
|
{
|
{
|
tree stmt = bsi_stmt (bsi);
|
tree stmt = bsi_stmt (bsi);
|
|
|
switch (TREE_CODE (stmt))
|
switch (TREE_CODE (stmt))
|
{
|
{
|
case LABEL_EXPR:
|
case LABEL_EXPR:
|
if (DECL_NONLOCAL (LABEL_EXPR_LABEL (stmt)))
|
if (DECL_NONLOCAL (LABEL_EXPR_LABEL (stmt)))
|
return false;
|
return false;
|
break;
|
break;
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
if (find_edge (ENTRY_BLOCK_PTR, bb))
|
if (find_edge (ENTRY_BLOCK_PTR, bb))
|
return false;
|
return false;
|
|
|
if (current_loops)
|
if (current_loops)
|
{
|
{
|
basic_block dest;
|
basic_block dest;
|
/* Protect loop latches, headers and preheaders. */
|
/* Protect loop latches, headers and preheaders. */
|
if (bb->loop_father->header == bb)
|
if (bb->loop_father->header == bb)
|
return false;
|
return false;
|
dest = EDGE_SUCC (bb, 0)->dest;
|
dest = EDGE_SUCC (bb, 0)->dest;
|
|
|
if (dest->loop_father->header == dest)
|
if (dest->loop_father->header == dest)
|
return false;
|
return false;
|
}
|
}
|
|
|
/* If we have an EH edge leaving this block, make sure that the
|
/* If we have an EH edge leaving this block, make sure that the
|
destination of this block has only one predecessor. This ensures
|
destination of this block has only one predecessor. This ensures
|
that we don't get into the situation where we try to remove two
|
that we don't get into the situation where we try to remove two
|
forwarders that go to the same basic block but are handlers for
|
forwarders that go to the same basic block but are handlers for
|
different EH regions. */
|
different EH regions. */
|
succ = single_succ_edge (bb);
|
succ = single_succ_edge (bb);
|
dest = succ->dest;
|
dest = succ->dest;
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
{
|
{
|
if (e->flags & EDGE_EH)
|
if (e->flags & EDGE_EH)
|
{
|
{
|
if (!single_pred_p (dest))
|
if (!single_pred_p (dest))
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Return true if BB has at least one abnormal incoming edge. */
|
/* Return true if BB has at least one abnormal incoming edge. */
|
|
|
static inline bool
|
static inline bool
|
has_abnormal_incoming_edge_p (basic_block bb)
|
has_abnormal_incoming_edge_p (basic_block bb)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
if (e->flags & EDGE_ABNORMAL)
|
if (e->flags & EDGE_ABNORMAL)
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* If all the PHI nodes in DEST have alternatives for E1 and E2 and
|
/* If all the PHI nodes in DEST have alternatives for E1 and E2 and
|
those alternatives are equal in each of the PHI nodes, then return
|
those alternatives are equal in each of the PHI nodes, then return
|
true, else return false. */
|
true, else return false. */
|
|
|
static bool
|
static bool
|
phi_alternatives_equal (basic_block dest, edge e1, edge e2)
|
phi_alternatives_equal (basic_block dest, edge e1, edge e2)
|
{
|
{
|
int n1 = e1->dest_idx;
|
int n1 = e1->dest_idx;
|
int n2 = e2->dest_idx;
|
int n2 = e2->dest_idx;
|
tree phi;
|
tree phi;
|
|
|
for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
|
for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
|
{
|
{
|
tree val1 = PHI_ARG_DEF (phi, n1);
|
tree val1 = PHI_ARG_DEF (phi, n1);
|
tree val2 = PHI_ARG_DEF (phi, n2);
|
tree val2 = PHI_ARG_DEF (phi, n2);
|
|
|
gcc_assert (val1 != NULL_TREE);
|
gcc_assert (val1 != NULL_TREE);
|
gcc_assert (val2 != NULL_TREE);
|
gcc_assert (val2 != NULL_TREE);
|
|
|
if (!operand_equal_for_phi_arg_p (val1, val2))
|
if (!operand_equal_for_phi_arg_p (val1, val2))
|
return false;
|
return false;
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Removes forwarder block BB. Returns false if this failed. If a new
|
/* Removes forwarder block BB. Returns false if this failed. If a new
|
forwarder block is created due to redirection of edges, it is
|
forwarder block is created due to redirection of edges, it is
|
stored to worklist. */
|
stored to worklist. */
|
|
|
static bool
|
static bool
|
remove_forwarder_block (basic_block bb, basic_block **worklist)
|
remove_forwarder_block (basic_block bb, basic_block **worklist)
|
{
|
{
|
edge succ = single_succ_edge (bb), e, s;
|
edge succ = single_succ_edge (bb), e, s;
|
basic_block dest = succ->dest;
|
basic_block dest = succ->dest;
|
tree label;
|
tree label;
|
tree phi;
|
tree phi;
|
edge_iterator ei;
|
edge_iterator ei;
|
block_stmt_iterator bsi, bsi_to;
|
block_stmt_iterator bsi, bsi_to;
|
bool seen_abnormal_edge = false;
|
bool seen_abnormal_edge = false;
|
|
|
/* We check for infinite loops already in tree_forwarder_block_p.
|
/* We check for infinite loops already in tree_forwarder_block_p.
|
However it may happen that the infinite loop is created
|
However it may happen that the infinite loop is created
|
afterwards due to removal of forwarders. */
|
afterwards due to removal of forwarders. */
|
if (dest == bb)
|
if (dest == bb)
|
return false;
|
return false;
|
|
|
/* If the destination block consists of a nonlocal label, do not merge
|
/* If the destination block consists of a nonlocal label, do not merge
|
it. */
|
it. */
|
label = first_stmt (dest);
|
label = first_stmt (dest);
|
if (label
|
if (label
|
&& TREE_CODE (label) == LABEL_EXPR
|
&& TREE_CODE (label) == LABEL_EXPR
|
&& DECL_NONLOCAL (LABEL_EXPR_LABEL (label)))
|
&& DECL_NONLOCAL (LABEL_EXPR_LABEL (label)))
|
return false;
|
return false;
|
|
|
/* If there is an abnormal edge to basic block BB, but not into
|
/* If there is an abnormal edge to basic block BB, but not into
|
dest, problems might occur during removal of the phi node at out
|
dest, problems might occur during removal of the phi node at out
|
of ssa due to overlapping live ranges of registers.
|
of ssa due to overlapping live ranges of registers.
|
|
|
If there is an abnormal edge in DEST, the problems would occur
|
If there is an abnormal edge in DEST, the problems would occur
|
anyway since cleanup_dead_labels would then merge the labels for
|
anyway since cleanup_dead_labels would then merge the labels for
|
two different eh regions, and rest of exception handling code
|
two different eh regions, and rest of exception handling code
|
does not like it.
|
does not like it.
|
|
|
So if there is an abnormal edge to BB, proceed only if there is
|
So if there is an abnormal edge to BB, proceed only if there is
|
no abnormal edge to DEST and there are no phi nodes in DEST. */
|
no abnormal edge to DEST and there are no phi nodes in DEST. */
|
if (has_abnormal_incoming_edge_p (bb))
|
if (has_abnormal_incoming_edge_p (bb))
|
{
|
{
|
seen_abnormal_edge = true;
|
seen_abnormal_edge = true;
|
|
|
if (has_abnormal_incoming_edge_p (dest)
|
if (has_abnormal_incoming_edge_p (dest)
|
|| phi_nodes (dest) != NULL_TREE)
|
|| phi_nodes (dest) != NULL_TREE)
|
return false;
|
return false;
|
}
|
}
|
|
|
/* If there are phi nodes in DEST, and some of the blocks that are
|
/* If there are phi nodes in DEST, and some of the blocks that are
|
predecessors of BB are also predecessors of DEST, check that the
|
predecessors of BB are also predecessors of DEST, check that the
|
phi node arguments match. */
|
phi node arguments match. */
|
if (phi_nodes (dest))
|
if (phi_nodes (dest))
|
{
|
{
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
{
|
{
|
s = find_edge (e->src, dest);
|
s = find_edge (e->src, dest);
|
if (!s)
|
if (!s)
|
continue;
|
continue;
|
|
|
if (!phi_alternatives_equal (dest, succ, s))
|
if (!phi_alternatives_equal (dest, succ, s))
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Redirect the edges. */
|
/* Redirect the edges. */
|
for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
|
for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
|
{
|
{
|
if (e->flags & EDGE_ABNORMAL)
|
if (e->flags & EDGE_ABNORMAL)
|
{
|
{
|
/* If there is an abnormal edge, redirect it anyway, and
|
/* If there is an abnormal edge, redirect it anyway, and
|
move the labels to the new block to make it legal. */
|
move the labels to the new block to make it legal. */
|
s = redirect_edge_succ_nodup (e, dest);
|
s = redirect_edge_succ_nodup (e, dest);
|
}
|
}
|
else
|
else
|
s = redirect_edge_and_branch (e, dest);
|
s = redirect_edge_and_branch (e, dest);
|
|
|
if (s == e)
|
if (s == e)
|
{
|
{
|
/* Create arguments for the phi nodes, since the edge was not
|
/* Create arguments for the phi nodes, since the edge was not
|
here before. */
|
here before. */
|
for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
|
for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
|
add_phi_arg (phi, PHI_ARG_DEF (phi, succ->dest_idx), s);
|
add_phi_arg (phi, PHI_ARG_DEF (phi, succ->dest_idx), s);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* The source basic block might become a forwarder. We know
|
/* The source basic block might become a forwarder. We know
|
that it was not a forwarder before, since it used to have
|
that it was not a forwarder before, since it used to have
|
at least two outgoing edges, so we may just add it to
|
at least two outgoing edges, so we may just add it to
|
worklist. */
|
worklist. */
|
if (tree_forwarder_block_p (s->src, false))
|
if (tree_forwarder_block_p (s->src, false))
|
*(*worklist)++ = s->src;
|
*(*worklist)++ = s->src;
|
}
|
}
|
}
|
}
|
|
|
if (seen_abnormal_edge)
|
if (seen_abnormal_edge)
|
{
|
{
|
/* Move the labels to the new block, so that the redirection of
|
/* Move the labels to the new block, so that the redirection of
|
the abnormal edges works. */
|
the abnormal edges works. */
|
|
|
bsi_to = bsi_start (dest);
|
bsi_to = bsi_start (dest);
|
for (bsi = bsi_start (bb); !bsi_end_p (bsi); )
|
for (bsi = bsi_start (bb); !bsi_end_p (bsi); )
|
{
|
{
|
label = bsi_stmt (bsi);
|
label = bsi_stmt (bsi);
|
gcc_assert (TREE_CODE (label) == LABEL_EXPR);
|
gcc_assert (TREE_CODE (label) == LABEL_EXPR);
|
bsi_remove (&bsi, false);
|
bsi_remove (&bsi, false);
|
bsi_insert_before (&bsi_to, label, BSI_CONTINUE_LINKING);
|
bsi_insert_before (&bsi_to, label, BSI_CONTINUE_LINKING);
|
}
|
}
|
}
|
}
|
|
|
/* Update the dominators. */
|
/* Update the dominators. */
|
if (dom_info_available_p (CDI_DOMINATORS))
|
if (dom_info_available_p (CDI_DOMINATORS))
|
{
|
{
|
basic_block dom, dombb, domdest;
|
basic_block dom, dombb, domdest;
|
|
|
dombb = get_immediate_dominator (CDI_DOMINATORS, bb);
|
dombb = get_immediate_dominator (CDI_DOMINATORS, bb);
|
domdest = get_immediate_dominator (CDI_DOMINATORS, dest);
|
domdest = get_immediate_dominator (CDI_DOMINATORS, dest);
|
if (domdest == bb)
|
if (domdest == bb)
|
{
|
{
|
/* Shortcut to avoid calling (relatively expensive)
|
/* Shortcut to avoid calling (relatively expensive)
|
nearest_common_dominator unless necessary. */
|
nearest_common_dominator unless necessary. */
|
dom = dombb;
|
dom = dombb;
|
}
|
}
|
else
|
else
|
dom = nearest_common_dominator (CDI_DOMINATORS, domdest, dombb);
|
dom = nearest_common_dominator (CDI_DOMINATORS, domdest, dombb);
|
|
|
set_immediate_dominator (CDI_DOMINATORS, dest, dom);
|
set_immediate_dominator (CDI_DOMINATORS, dest, dom);
|
}
|
}
|
|
|
/* And kill the forwarder block. */
|
/* And kill the forwarder block. */
|
delete_basic_block (bb);
|
delete_basic_block (bb);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Removes forwarder blocks. */
|
/* Removes forwarder blocks. */
|
|
|
static bool
|
static bool
|
cleanup_forwarder_blocks (void)
|
cleanup_forwarder_blocks (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
bool changed = false;
|
bool changed = false;
|
basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks);
|
basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks);
|
basic_block *current = worklist;
|
basic_block *current = worklist;
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
if (tree_forwarder_block_p (bb, false))
|
if (tree_forwarder_block_p (bb, false))
|
*current++ = bb;
|
*current++ = bb;
|
}
|
}
|
|
|
while (current != worklist)
|
while (current != worklist)
|
{
|
{
|
bb = *--current;
|
bb = *--current;
|
changed |= remove_forwarder_block (bb, ¤t);
|
changed |= remove_forwarder_block (bb, ¤t);
|
}
|
}
|
|
|
free (worklist);
|
free (worklist);
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Do one round of CFG cleanup. */
|
/* Do one round of CFG cleanup. */
|
|
|
static bool
|
static bool
|
cleanup_tree_cfg_1 (void)
|
cleanup_tree_cfg_1 (void)
|
{
|
{
|
bool retval;
|
bool retval;
|
|
|
retval = cleanup_control_flow ();
|
retval = cleanup_control_flow ();
|
retval |= delete_unreachable_blocks ();
|
retval |= delete_unreachable_blocks ();
|
|
|
/* Forwarder blocks can carry line number information which is
|
/* Forwarder blocks can carry line number information which is
|
useful when debugging, so we only clean them up when
|
useful when debugging, so we only clean them up when
|
optimizing. */
|
optimizing. */
|
|
|
if (optimize > 0)
|
if (optimize > 0)
|
{
|
{
|
/* cleanup_forwarder_blocks can redirect edges out of
|
/* cleanup_forwarder_blocks can redirect edges out of
|
SWITCH_EXPRs, which can get expensive. So we want to enable
|
SWITCH_EXPRs, which can get expensive. So we want to enable
|
recording of edge to CASE_LABEL_EXPR mappings around the call
|
recording of edge to CASE_LABEL_EXPR mappings around the call
|
to cleanup_forwarder_blocks. */
|
to cleanup_forwarder_blocks. */
|
start_recording_case_labels ();
|
start_recording_case_labels ();
|
retval |= cleanup_forwarder_blocks ();
|
retval |= cleanup_forwarder_blocks ();
|
end_recording_case_labels ();
|
end_recording_case_labels ();
|
}
|
}
|
|
|
/* Merging the blocks may create new opportunities for folding
|
/* Merging the blocks may create new opportunities for folding
|
conditional branches (due to the elimination of single-valued PHI
|
conditional branches (due to the elimination of single-valued PHI
|
nodes). */
|
nodes). */
|
retval |= merge_seq_blocks ();
|
retval |= merge_seq_blocks ();
|
|
|
return retval;
|
return retval;
|
}
|
}
|
|
|
|
|
/* Remove unreachable blocks and other miscellaneous clean up work.
|
/* Remove unreachable blocks and other miscellaneous clean up work.
|
Return true if the flowgraph was modified, false otherwise. */
|
Return true if the flowgraph was modified, false otherwise. */
|
|
|
bool
|
bool
|
cleanup_tree_cfg (void)
|
cleanup_tree_cfg (void)
|
{
|
{
|
bool retval, changed;
|
bool retval, changed;
|
|
|
timevar_push (TV_TREE_CLEANUP_CFG);
|
timevar_push (TV_TREE_CLEANUP_CFG);
|
|
|
/* Iterate until there are no more cleanups left to do. If any
|
/* Iterate until there are no more cleanups left to do. If any
|
iteration changed the flowgraph, set CHANGED to true. */
|
iteration changed the flowgraph, set CHANGED to true. */
|
changed = false;
|
changed = false;
|
do
|
do
|
{
|
{
|
retval = cleanup_tree_cfg_1 ();
|
retval = cleanup_tree_cfg_1 ();
|
changed |= retval;
|
changed |= retval;
|
}
|
}
|
while (retval);
|
while (retval);
|
|
|
compact_blocks ();
|
compact_blocks ();
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
verify_flow_info ();
|
verify_flow_info ();
|
#endif
|
#endif
|
|
|
timevar_pop (TV_TREE_CLEANUP_CFG);
|
timevar_pop (TV_TREE_CLEANUP_CFG);
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Cleanup cfg and repair loop structures. */
|
/* Cleanup cfg and repair loop structures. */
|
|
|
void
|
void
|
cleanup_tree_cfg_loop (void)
|
cleanup_tree_cfg_loop (void)
|
{
|
{
|
bool changed = cleanup_tree_cfg ();
|
bool changed = cleanup_tree_cfg ();
|
|
|
if (changed)
|
if (changed)
|
{
|
{
|
bitmap changed_bbs = BITMAP_ALLOC (NULL);
|
bitmap changed_bbs = BITMAP_ALLOC (NULL);
|
fix_loop_structure (current_loops, changed_bbs);
|
fix_loop_structure (current_loops, changed_bbs);
|
calculate_dominance_info (CDI_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
|
|
/* This usually does nothing. But sometimes parts of cfg that originally
|
/* This usually does nothing. But sometimes parts of cfg that originally
|
were inside a loop get out of it due to edge removal (since they
|
were inside a loop get out of it due to edge removal (since they
|
become unreachable by back edges from latch). */
|
become unreachable by back edges from latch). */
|
rewrite_into_loop_closed_ssa (changed_bbs, TODO_update_ssa);
|
rewrite_into_loop_closed_ssa (changed_bbs, TODO_update_ssa);
|
|
|
BITMAP_FREE (changed_bbs);
|
BITMAP_FREE (changed_bbs);
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
verify_loop_structure (current_loops);
|
verify_loop_structure (current_loops);
|
#endif
|
#endif
|
scev_reset ();
|
scev_reset ();
|
}
|
}
|
}
|
}
|
|
|
/* Merge the PHI nodes at BB into those at BB's sole successor. */
|
/* Merge the PHI nodes at BB into those at BB's sole successor. */
|
|
|
static void
|
static void
|
remove_forwarder_block_with_phi (basic_block bb)
|
remove_forwarder_block_with_phi (basic_block bb)
|
{
|
{
|
edge succ = single_succ_edge (bb);
|
edge succ = single_succ_edge (bb);
|
basic_block dest = succ->dest;
|
basic_block dest = succ->dest;
|
tree label;
|
tree label;
|
basic_block dombb, domdest, dom;
|
basic_block dombb, domdest, dom;
|
|
|
/* We check for infinite loops already in tree_forwarder_block_p.
|
/* We check for infinite loops already in tree_forwarder_block_p.
|
However it may happen that the infinite loop is created
|
However it may happen that the infinite loop is created
|
afterwards due to removal of forwarders. */
|
afterwards due to removal of forwarders. */
|
if (dest == bb)
|
if (dest == bb)
|
return;
|
return;
|
|
|
/* If the destination block consists of a nonlocal label, do not
|
/* If the destination block consists of a nonlocal label, do not
|
merge it. */
|
merge it. */
|
label = first_stmt (dest);
|
label = first_stmt (dest);
|
if (label
|
if (label
|
&& TREE_CODE (label) == LABEL_EXPR
|
&& TREE_CODE (label) == LABEL_EXPR
|
&& DECL_NONLOCAL (LABEL_EXPR_LABEL (label)))
|
&& DECL_NONLOCAL (LABEL_EXPR_LABEL (label)))
|
return;
|
return;
|
|
|
/* Redirect each incoming edge to BB to DEST. */
|
/* Redirect each incoming edge to BB to DEST. */
|
while (EDGE_COUNT (bb->preds) > 0)
|
while (EDGE_COUNT (bb->preds) > 0)
|
{
|
{
|
edge e = EDGE_PRED (bb, 0), s;
|
edge e = EDGE_PRED (bb, 0), s;
|
tree phi;
|
tree phi;
|
|
|
s = find_edge (e->src, dest);
|
s = find_edge (e->src, dest);
|
if (s)
|
if (s)
|
{
|
{
|
/* We already have an edge S from E->src to DEST. If S and
|
/* We already have an edge S from E->src to DEST. If S and
|
E->dest's sole successor edge have the same PHI arguments
|
E->dest's sole successor edge have the same PHI arguments
|
at DEST, redirect S to DEST. */
|
at DEST, redirect S to DEST. */
|
if (phi_alternatives_equal (dest, s, succ))
|
if (phi_alternatives_equal (dest, s, succ))
|
{
|
{
|
e = redirect_edge_and_branch (e, dest);
|
e = redirect_edge_and_branch (e, dest);
|
PENDING_STMT (e) = NULL_TREE;
|
PENDING_STMT (e) = NULL_TREE;
|
continue;
|
continue;
|
}
|
}
|
|
|
/* PHI arguments are different. Create a forwarder block by
|
/* PHI arguments are different. Create a forwarder block by
|
splitting E so that we can merge PHI arguments on E to
|
splitting E so that we can merge PHI arguments on E to
|
DEST. */
|
DEST. */
|
e = single_succ_edge (split_edge (e));
|
e = single_succ_edge (split_edge (e));
|
}
|
}
|
|
|
s = redirect_edge_and_branch (e, dest);
|
s = redirect_edge_and_branch (e, dest);
|
|
|
/* redirect_edge_and_branch must not create a new edge. */
|
/* redirect_edge_and_branch must not create a new edge. */
|
gcc_assert (s == e);
|
gcc_assert (s == e);
|
|
|
/* Add to the PHI nodes at DEST each PHI argument removed at the
|
/* Add to the PHI nodes at DEST each PHI argument removed at the
|
destination of E. */
|
destination of E. */
|
for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
|
for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
|
{
|
{
|
tree def = PHI_ARG_DEF (phi, succ->dest_idx);
|
tree def = PHI_ARG_DEF (phi, succ->dest_idx);
|
|
|
if (TREE_CODE (def) == SSA_NAME)
|
if (TREE_CODE (def) == SSA_NAME)
|
{
|
{
|
tree var;
|
tree var;
|
|
|
/* If DEF is one of the results of PHI nodes removed during
|
/* If DEF is one of the results of PHI nodes removed during
|
redirection, replace it with the PHI argument that used
|
redirection, replace it with the PHI argument that used
|
to be on E. */
|
to be on E. */
|
for (var = PENDING_STMT (e); var; var = TREE_CHAIN (var))
|
for (var = PENDING_STMT (e); var; var = TREE_CHAIN (var))
|
{
|
{
|
tree old_arg = TREE_PURPOSE (var);
|
tree old_arg = TREE_PURPOSE (var);
|
tree new_arg = TREE_VALUE (var);
|
tree new_arg = TREE_VALUE (var);
|
|
|
if (def == old_arg)
|
if (def == old_arg)
|
{
|
{
|
def = new_arg;
|
def = new_arg;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
add_phi_arg (phi, def, s);
|
add_phi_arg (phi, def, s);
|
}
|
}
|
|
|
PENDING_STMT (e) = NULL;
|
PENDING_STMT (e) = NULL;
|
}
|
}
|
|
|
/* Update the dominators. */
|
/* Update the dominators. */
|
dombb = get_immediate_dominator (CDI_DOMINATORS, bb);
|
dombb = get_immediate_dominator (CDI_DOMINATORS, bb);
|
domdest = get_immediate_dominator (CDI_DOMINATORS, dest);
|
domdest = get_immediate_dominator (CDI_DOMINATORS, dest);
|
if (domdest == bb)
|
if (domdest == bb)
|
{
|
{
|
/* Shortcut to avoid calling (relatively expensive)
|
/* Shortcut to avoid calling (relatively expensive)
|
nearest_common_dominator unless necessary. */
|
nearest_common_dominator unless necessary. */
|
dom = dombb;
|
dom = dombb;
|
}
|
}
|
else
|
else
|
dom = nearest_common_dominator (CDI_DOMINATORS, domdest, dombb);
|
dom = nearest_common_dominator (CDI_DOMINATORS, domdest, dombb);
|
|
|
set_immediate_dominator (CDI_DOMINATORS, dest, dom);
|
set_immediate_dominator (CDI_DOMINATORS, dest, dom);
|
|
|
/* Remove BB since all of BB's incoming edges have been redirected
|
/* Remove BB since all of BB's incoming edges have been redirected
|
to DEST. */
|
to DEST. */
|
delete_basic_block (bb);
|
delete_basic_block (bb);
|
}
|
}
|
|
|
/* This pass merges PHI nodes if one feeds into another. For example,
|
/* This pass merges PHI nodes if one feeds into another. For example,
|
suppose we have the following:
|
suppose we have the following:
|
|
|
goto <bb 9> (<L9>);
|
goto <bb 9> (<L9>);
|
|
|
<L8>:;
|
<L8>:;
|
tem_17 = foo ();
|
tem_17 = foo ();
|
|
|
# tem_6 = PHI <tem_17(8), tem_23(7)>;
|
# tem_6 = PHI <tem_17(8), tem_23(7)>;
|
<L9>:;
|
<L9>:;
|
|
|
# tem_3 = PHI <tem_6(9), tem_2(5)>;
|
# tem_3 = PHI <tem_6(9), tem_2(5)>;
|
<L10>:;
|
<L10>:;
|
|
|
Then we merge the first PHI node into the second one like so:
|
Then we merge the first PHI node into the second one like so:
|
|
|
goto <bb 9> (<L10>);
|
goto <bb 9> (<L10>);
|
|
|
<L8>:;
|
<L8>:;
|
tem_17 = foo ();
|
tem_17 = foo ();
|
|
|
# tem_3 = PHI <tem_23(7), tem_2(5), tem_17(8)>;
|
# tem_3 = PHI <tem_23(7), tem_2(5), tem_17(8)>;
|
<L10>:;
|
<L10>:;
|
*/
|
*/
|
|
|
static unsigned int
|
static unsigned int
|
merge_phi_nodes (void)
|
merge_phi_nodes (void)
|
{
|
{
|
basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks);
|
basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks);
|
basic_block *current = worklist;
|
basic_block *current = worklist;
|
basic_block bb;
|
basic_block bb;
|
|
|
calculate_dominance_info (CDI_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
|
|
/* Find all PHI nodes that we may be able to merge. */
|
/* Find all PHI nodes that we may be able to merge. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
basic_block dest;
|
basic_block dest;
|
|
|
/* Look for a forwarder block with PHI nodes. */
|
/* Look for a forwarder block with PHI nodes. */
|
if (!tree_forwarder_block_p (bb, true))
|
if (!tree_forwarder_block_p (bb, true))
|
continue;
|
continue;
|
|
|
dest = single_succ (bb);
|
dest = single_succ (bb);
|
|
|
/* We have to feed into another basic block with PHI
|
/* We have to feed into another basic block with PHI
|
nodes. */
|
nodes. */
|
if (!phi_nodes (dest)
|
if (!phi_nodes (dest)
|
/* We don't want to deal with a basic block with
|
/* We don't want to deal with a basic block with
|
abnormal edges. */
|
abnormal edges. */
|
|| has_abnormal_incoming_edge_p (bb))
|
|| has_abnormal_incoming_edge_p (bb))
|
continue;
|
continue;
|
|
|
if (!dominated_by_p (CDI_DOMINATORS, dest, bb))
|
if (!dominated_by_p (CDI_DOMINATORS, dest, bb))
|
{
|
{
|
/* If BB does not dominate DEST, then the PHI nodes at
|
/* If BB does not dominate DEST, then the PHI nodes at
|
DEST must be the only users of the results of the PHI
|
DEST must be the only users of the results of the PHI
|
nodes at BB. */
|
nodes at BB. */
|
*current++ = bb;
|
*current++ = bb;
|
}
|
}
|
else
|
else
|
{
|
{
|
tree phi;
|
tree phi;
|
unsigned int dest_idx = single_succ_edge (bb)->dest_idx;
|
unsigned int dest_idx = single_succ_edge (bb)->dest_idx;
|
|
|
/* BB dominates DEST. There may be many users of the PHI
|
/* BB dominates DEST. There may be many users of the PHI
|
nodes in BB. However, there is still a trivial case we
|
nodes in BB. However, there is still a trivial case we
|
can handle. If the result of every PHI in BB is used
|
can handle. If the result of every PHI in BB is used
|
only by a PHI in DEST, then we can trivially merge the
|
only by a PHI in DEST, then we can trivially merge the
|
PHI nodes from BB into DEST. */
|
PHI nodes from BB into DEST. */
|
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
{
|
{
|
tree result = PHI_RESULT (phi);
|
tree result = PHI_RESULT (phi);
|
use_operand_p imm_use;
|
use_operand_p imm_use;
|
tree use_stmt;
|
tree use_stmt;
|
|
|
/* If the PHI's result is never used, then we can just
|
/* If the PHI's result is never used, then we can just
|
ignore it. */
|
ignore it. */
|
if (has_zero_uses (result))
|
if (has_zero_uses (result))
|
continue;
|
continue;
|
|
|
/* Get the single use of the result of this PHI node. */
|
/* Get the single use of the result of this PHI node. */
|
if (!single_imm_use (result, &imm_use, &use_stmt)
|
if (!single_imm_use (result, &imm_use, &use_stmt)
|
|| TREE_CODE (use_stmt) != PHI_NODE
|
|| TREE_CODE (use_stmt) != PHI_NODE
|
|| bb_for_stmt (use_stmt) != dest
|
|| bb_for_stmt (use_stmt) != dest
|
|| PHI_ARG_DEF (use_stmt, dest_idx) != result)
|
|| PHI_ARG_DEF (use_stmt, dest_idx) != result)
|
break;
|
break;
|
}
|
}
|
|
|
/* If the loop above iterated through all the PHI nodes
|
/* If the loop above iterated through all the PHI nodes
|
in BB, then we can merge the PHIs from BB into DEST. */
|
in BB, then we can merge the PHIs from BB into DEST. */
|
if (!phi)
|
if (!phi)
|
*current++ = bb;
|
*current++ = bb;
|
}
|
}
|
}
|
}
|
|
|
/* Now let's drain WORKLIST. */
|
/* Now let's drain WORKLIST. */
|
while (current != worklist)
|
while (current != worklist)
|
{
|
{
|
bb = *--current;
|
bb = *--current;
|
remove_forwarder_block_with_phi (bb);
|
remove_forwarder_block_with_phi (bb);
|
}
|
}
|
|
|
free (worklist);
|
free (worklist);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static bool
|
static bool
|
gate_merge_phi (void)
|
gate_merge_phi (void)
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
struct tree_opt_pass pass_merge_phi = {
|
struct tree_opt_pass pass_merge_phi = {
|
"mergephi", /* name */
|
"mergephi", /* name */
|
gate_merge_phi, /* gate */
|
gate_merge_phi, /* gate */
|
merge_phi_nodes, /* execute */
|
merge_phi_nodes, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_TREE_MERGE_PHI, /* tv_id */
|
TV_TREE_MERGE_PHI, /* tv_id */
|
PROP_cfg | PROP_ssa, /* properties_required */
|
PROP_cfg | PROP_ssa, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func | TODO_ggc_collect /* todo_flags_finish */
|
TODO_dump_func | TODO_ggc_collect /* todo_flags_finish */
|
| TODO_verify_ssa,
|
| TODO_verify_ssa,
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
