/* Generic SSA value propagation engine.
|
/* Generic SSA value propagation engine.
|
Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
|
Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
|
Contributed by Diego Novillo <dnovillo@redhat.com>
|
Contributed by Diego Novillo <dnovillo@redhat.com>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it
|
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
|
under the terms of the GNU General Public License as published by the
|
Free Software Foundation; either version 3, or (at your option) any
|
Free Software Foundation; either version 3, or (at your option) any
|
later version.
|
later version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
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 "flags.h"
|
#include "flags.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "output.h"
|
#include "output.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "function.h"
|
#include "function.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "tree-ssa-propagate.h"
|
#include "tree-ssa-propagate.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "varray.h"
|
#include "varray.h"
|
#include "vec.h"
|
#include "vec.h"
|
#include "value-prof.h"
|
#include "value-prof.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
|
|
/* This file implements a generic value propagation engine based on
|
/* This file implements a generic value propagation engine based on
|
the same propagation used by the SSA-CCP algorithm [1].
|
the same propagation used by the SSA-CCP algorithm [1].
|
|
|
Propagation is performed by simulating the execution of every
|
Propagation is performed by simulating the execution of every
|
statement that produces the value being propagated. Simulation
|
statement that produces the value being propagated. Simulation
|
proceeds as follows:
|
proceeds as follows:
|
|
|
1- Initially, all edges of the CFG are marked not executable and
|
1- Initially, all edges of the CFG are marked not executable and
|
the CFG worklist is seeded with all the statements in the entry
|
the CFG worklist is seeded with all the statements in the entry
|
basic block (block 0).
|
basic block (block 0).
|
|
|
2- Every statement S is simulated with a call to the call-back
|
2- Every statement S is simulated with a call to the call-back
|
function SSA_PROP_VISIT_STMT. This evaluation may produce 3
|
function SSA_PROP_VISIT_STMT. This evaluation may produce 3
|
results:
|
results:
|
|
|
SSA_PROP_NOT_INTERESTING: Statement S produces nothing of
|
SSA_PROP_NOT_INTERESTING: Statement S produces nothing of
|
interest and does not affect any of the work lists.
|
interest and does not affect any of the work lists.
|
|
|
SSA_PROP_VARYING: The value produced by S cannot be determined
|
SSA_PROP_VARYING: The value produced by S cannot be determined
|
at compile time. Further simulation of S is not required.
|
at compile time. Further simulation of S is not required.
|
If S is a conditional jump, all the outgoing edges for the
|
If S is a conditional jump, all the outgoing edges for the
|
block are considered executable and added to the work
|
block are considered executable and added to the work
|
list.
|
list.
|
|
|
SSA_PROP_INTERESTING: S produces a value that can be computed
|
SSA_PROP_INTERESTING: S produces a value that can be computed
|
at compile time. Its result can be propagated into the
|
at compile time. Its result can be propagated into the
|
statements that feed from S. Furthermore, if S is a
|
statements that feed from S. Furthermore, if S is a
|
conditional jump, only the edge known to be taken is added
|
conditional jump, only the edge known to be taken is added
|
to the work list. Edges that are known not to execute are
|
to the work list. Edges that are known not to execute are
|
never simulated.
|
never simulated.
|
|
|
3- PHI nodes are simulated with a call to SSA_PROP_VISIT_PHI. The
|
3- PHI nodes are simulated with a call to SSA_PROP_VISIT_PHI. The
|
return value from SSA_PROP_VISIT_PHI has the same semantics as
|
return value from SSA_PROP_VISIT_PHI has the same semantics as
|
described in #2.
|
described in #2.
|
|
|
4- Three work lists are kept. Statements are only added to these
|
4- Three work lists are kept. Statements are only added to these
|
lists if they produce one of SSA_PROP_INTERESTING or
|
lists if they produce one of SSA_PROP_INTERESTING or
|
SSA_PROP_VARYING.
|
SSA_PROP_VARYING.
|
|
|
CFG_BLOCKS contains the list of blocks to be simulated.
|
CFG_BLOCKS contains the list of blocks to be simulated.
|
Blocks are added to this list if their incoming edges are
|
Blocks are added to this list if their incoming edges are
|
found executable.
|
found executable.
|
|
|
VARYING_SSA_EDGES contains the list of statements that feed
|
VARYING_SSA_EDGES contains the list of statements that feed
|
from statements that produce an SSA_PROP_VARYING result.
|
from statements that produce an SSA_PROP_VARYING result.
|
These are simulated first to speed up processing.
|
These are simulated first to speed up processing.
|
|
|
INTERESTING_SSA_EDGES contains the list of statements that
|
INTERESTING_SSA_EDGES contains the list of statements that
|
feed from statements that produce an SSA_PROP_INTERESTING
|
feed from statements that produce an SSA_PROP_INTERESTING
|
result.
|
result.
|
|
|
5- Simulation terminates when all three work lists are drained.
|
5- Simulation terminates when all three work lists are drained.
|
|
|
Before calling ssa_propagate, it is important to clear
|
Before calling ssa_propagate, it is important to clear
|
prop_simulate_again_p for all the statements in the program that
|
prop_simulate_again_p for all the statements in the program that
|
should be simulated. This initialization allows an implementation
|
should be simulated. This initialization allows an implementation
|
to specify which statements should never be simulated.
|
to specify which statements should never be simulated.
|
|
|
It is also important to compute def-use information before calling
|
It is also important to compute def-use information before calling
|
ssa_propagate.
|
ssa_propagate.
|
|
|
References:
|
References:
|
|
|
[1] Constant propagation with conditional branches,
|
[1] Constant propagation with conditional branches,
|
Wegman and Zadeck, ACM TOPLAS 13(2):181-210.
|
Wegman and Zadeck, ACM TOPLAS 13(2):181-210.
|
|
|
[2] Building an Optimizing Compiler,
|
[2] Building an Optimizing Compiler,
|
Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
|
Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
|
|
|
[3] Advanced Compiler Design and Implementation,
|
[3] Advanced Compiler Design and Implementation,
|
Steven Muchnick, Morgan Kaufmann, 1997, Section 12.6 */
|
Steven Muchnick, Morgan Kaufmann, 1997, Section 12.6 */
|
|
|
/* Function pointers used to parameterize the propagation engine. */
|
/* Function pointers used to parameterize the propagation engine. */
|
static ssa_prop_visit_stmt_fn ssa_prop_visit_stmt;
|
static ssa_prop_visit_stmt_fn ssa_prop_visit_stmt;
|
static ssa_prop_visit_phi_fn ssa_prop_visit_phi;
|
static ssa_prop_visit_phi_fn ssa_prop_visit_phi;
|
|
|
/* Keep track of statements that have been added to one of the SSA
|
/* Keep track of statements that have been added to one of the SSA
|
edges worklists. This flag is used to avoid visiting statements
|
edges worklists. This flag is used to avoid visiting statements
|
unnecessarily when draining an SSA edge worklist. If while
|
unnecessarily when draining an SSA edge worklist. If while
|
simulating a basic block, we find a statement with
|
simulating a basic block, we find a statement with
|
STMT_IN_SSA_EDGE_WORKLIST set, we clear it to prevent SSA edge
|
STMT_IN_SSA_EDGE_WORKLIST set, we clear it to prevent SSA edge
|
processing from visiting it again.
|
processing from visiting it again.
|
|
|
NOTE: users of the propagation engine are not allowed to use
|
NOTE: users of the propagation engine are not allowed to use
|
the GF_PLF_1 flag. */
|
the GF_PLF_1 flag. */
|
#define STMT_IN_SSA_EDGE_WORKLIST GF_PLF_1
|
#define STMT_IN_SSA_EDGE_WORKLIST GF_PLF_1
|
|
|
/* A bitmap to keep track of executable blocks in the CFG. */
|
/* A bitmap to keep track of executable blocks in the CFG. */
|
static sbitmap executable_blocks;
|
static sbitmap executable_blocks;
|
|
|
/* Array of control flow edges on the worklist. */
|
/* Array of control flow edges on the worklist. */
|
static VEC(basic_block,heap) *cfg_blocks;
|
static VEC(basic_block,heap) *cfg_blocks;
|
|
|
static unsigned int cfg_blocks_num = 0;
|
static unsigned int cfg_blocks_num = 0;
|
static int cfg_blocks_tail;
|
static int cfg_blocks_tail;
|
static int cfg_blocks_head;
|
static int cfg_blocks_head;
|
|
|
static sbitmap bb_in_list;
|
static sbitmap bb_in_list;
|
|
|
/* Worklist of SSA edges which will need reexamination as their
|
/* Worklist of SSA edges which will need reexamination as their
|
definition has changed. SSA edges are def-use edges in the SSA
|
definition has changed. SSA edges are def-use edges in the SSA
|
web. For each D-U edge, we store the target statement or PHI node
|
web. For each D-U edge, we store the target statement or PHI node
|
U. */
|
U. */
|
static GTY(()) VEC(gimple,gc) *interesting_ssa_edges;
|
static GTY(()) VEC(gimple,gc) *interesting_ssa_edges;
|
|
|
/* Identical to INTERESTING_SSA_EDGES. For performance reasons, the
|
/* Identical to INTERESTING_SSA_EDGES. For performance reasons, the
|
list of SSA edges is split into two. One contains all SSA edges
|
list of SSA edges is split into two. One contains all SSA edges
|
who need to be reexamined because their lattice value changed to
|
who need to be reexamined because their lattice value changed to
|
varying (this worklist), and the other contains all other SSA edges
|
varying (this worklist), and the other contains all other SSA edges
|
to be reexamined (INTERESTING_SSA_EDGES).
|
to be reexamined (INTERESTING_SSA_EDGES).
|
|
|
Since most values in the program are VARYING, the ideal situation
|
Since most values in the program are VARYING, the ideal situation
|
is to move them to that lattice value as quickly as possible.
|
is to move them to that lattice value as quickly as possible.
|
Thus, it doesn't make sense to process any other type of lattice
|
Thus, it doesn't make sense to process any other type of lattice
|
value until all VARYING values are propagated fully, which is one
|
value until all VARYING values are propagated fully, which is one
|
thing using the VARYING worklist achieves. In addition, if we
|
thing using the VARYING worklist achieves. In addition, if we
|
don't use a separate worklist for VARYING edges, we end up with
|
don't use a separate worklist for VARYING edges, we end up with
|
situations where lattice values move from
|
situations where lattice values move from
|
UNDEFINED->INTERESTING->VARYING instead of UNDEFINED->VARYING. */
|
UNDEFINED->INTERESTING->VARYING instead of UNDEFINED->VARYING. */
|
static GTY(()) VEC(gimple,gc) *varying_ssa_edges;
|
static GTY(()) VEC(gimple,gc) *varying_ssa_edges;
|
|
|
|
|
/* Return true if the block worklist empty. */
|
/* Return true if the block worklist empty. */
|
|
|
static inline bool
|
static inline bool
|
cfg_blocks_empty_p (void)
|
cfg_blocks_empty_p (void)
|
{
|
{
|
return (cfg_blocks_num == 0);
|
return (cfg_blocks_num == 0);
|
}
|
}
|
|
|
|
|
/* Add a basic block to the worklist. The block must not be already
|
/* Add a basic block to the worklist. The block must not be already
|
in the worklist, and it must not be the ENTRY or EXIT block. */
|
in the worklist, and it must not be the ENTRY or EXIT block. */
|
|
|
static void
|
static void
|
cfg_blocks_add (basic_block bb)
|
cfg_blocks_add (basic_block bb)
|
{
|
{
|
bool head = false;
|
bool head = false;
|
|
|
gcc_assert (bb != ENTRY_BLOCK_PTR && bb != EXIT_BLOCK_PTR);
|
gcc_assert (bb != ENTRY_BLOCK_PTR && bb != EXIT_BLOCK_PTR);
|
gcc_assert (!TEST_BIT (bb_in_list, bb->index));
|
gcc_assert (!TEST_BIT (bb_in_list, bb->index));
|
|
|
if (cfg_blocks_empty_p ())
|
if (cfg_blocks_empty_p ())
|
{
|
{
|
cfg_blocks_tail = cfg_blocks_head = 0;
|
cfg_blocks_tail = cfg_blocks_head = 0;
|
cfg_blocks_num = 1;
|
cfg_blocks_num = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
cfg_blocks_num++;
|
cfg_blocks_num++;
|
if (cfg_blocks_num > VEC_length (basic_block, cfg_blocks))
|
if (cfg_blocks_num > VEC_length (basic_block, cfg_blocks))
|
{
|
{
|
/* We have to grow the array now. Adjust to queue to occupy
|
/* We have to grow the array now. Adjust to queue to occupy
|
the full space of the original array. We do not need to
|
the full space of the original array. We do not need to
|
initialize the newly allocated portion of the array
|
initialize the newly allocated portion of the array
|
because we keep track of CFG_BLOCKS_HEAD and
|
because we keep track of CFG_BLOCKS_HEAD and
|
CFG_BLOCKS_HEAD. */
|
CFG_BLOCKS_HEAD. */
|
cfg_blocks_tail = VEC_length (basic_block, cfg_blocks);
|
cfg_blocks_tail = VEC_length (basic_block, cfg_blocks);
|
cfg_blocks_head = 0;
|
cfg_blocks_head = 0;
|
VEC_safe_grow (basic_block, heap, cfg_blocks, 2 * cfg_blocks_tail);
|
VEC_safe_grow (basic_block, heap, cfg_blocks, 2 * cfg_blocks_tail);
|
}
|
}
|
/* Minor optimization: we prefer to see blocks with more
|
/* Minor optimization: we prefer to see blocks with more
|
predecessors later, because there is more of a chance that
|
predecessors later, because there is more of a chance that
|
the incoming edges will be executable. */
|
the incoming edges will be executable. */
|
else if (EDGE_COUNT (bb->preds)
|
else if (EDGE_COUNT (bb->preds)
|
>= EDGE_COUNT (VEC_index (basic_block, cfg_blocks,
|
>= EDGE_COUNT (VEC_index (basic_block, cfg_blocks,
|
cfg_blocks_head)->preds))
|
cfg_blocks_head)->preds))
|
cfg_blocks_tail = ((cfg_blocks_tail + 1)
|
cfg_blocks_tail = ((cfg_blocks_tail + 1)
|
% VEC_length (basic_block, cfg_blocks));
|
% VEC_length (basic_block, cfg_blocks));
|
else
|
else
|
{
|
{
|
if (cfg_blocks_head == 0)
|
if (cfg_blocks_head == 0)
|
cfg_blocks_head = VEC_length (basic_block, cfg_blocks);
|
cfg_blocks_head = VEC_length (basic_block, cfg_blocks);
|
--cfg_blocks_head;
|
--cfg_blocks_head;
|
head = true;
|
head = true;
|
}
|
}
|
}
|
}
|
|
|
VEC_replace (basic_block, cfg_blocks,
|
VEC_replace (basic_block, cfg_blocks,
|
head ? cfg_blocks_head : cfg_blocks_tail,
|
head ? cfg_blocks_head : cfg_blocks_tail,
|
bb);
|
bb);
|
SET_BIT (bb_in_list, bb->index);
|
SET_BIT (bb_in_list, bb->index);
|
}
|
}
|
|
|
|
|
/* Remove a block from the worklist. */
|
/* Remove a block from the worklist. */
|
|
|
static basic_block
|
static basic_block
|
cfg_blocks_get (void)
|
cfg_blocks_get (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
bb = VEC_index (basic_block, cfg_blocks, cfg_blocks_head);
|
bb = VEC_index (basic_block, cfg_blocks, cfg_blocks_head);
|
|
|
gcc_assert (!cfg_blocks_empty_p ());
|
gcc_assert (!cfg_blocks_empty_p ());
|
gcc_assert (bb);
|
gcc_assert (bb);
|
|
|
cfg_blocks_head = ((cfg_blocks_head + 1)
|
cfg_blocks_head = ((cfg_blocks_head + 1)
|
% VEC_length (basic_block, cfg_blocks));
|
% VEC_length (basic_block, cfg_blocks));
|
--cfg_blocks_num;
|
--cfg_blocks_num;
|
RESET_BIT (bb_in_list, bb->index);
|
RESET_BIT (bb_in_list, bb->index);
|
|
|
return bb;
|
return bb;
|
}
|
}
|
|
|
|
|
/* We have just defined a new value for VAR. If IS_VARYING is true,
|
/* We have just defined a new value for VAR. If IS_VARYING is true,
|
add all immediate uses of VAR to VARYING_SSA_EDGES, otherwise add
|
add all immediate uses of VAR to VARYING_SSA_EDGES, otherwise add
|
them to INTERESTING_SSA_EDGES. */
|
them to INTERESTING_SSA_EDGES. */
|
|
|
static void
|
static void
|
add_ssa_edge (tree var, bool is_varying)
|
add_ssa_edge (tree var, bool is_varying)
|
{
|
{
|
imm_use_iterator iter;
|
imm_use_iterator iter;
|
use_operand_p use_p;
|
use_operand_p use_p;
|
|
|
FOR_EACH_IMM_USE_FAST (use_p, iter, var)
|
FOR_EACH_IMM_USE_FAST (use_p, iter, var)
|
{
|
{
|
gimple use_stmt = USE_STMT (use_p);
|
gimple use_stmt = USE_STMT (use_p);
|
|
|
if (prop_simulate_again_p (use_stmt)
|
if (prop_simulate_again_p (use_stmt)
|
&& !gimple_plf (use_stmt, STMT_IN_SSA_EDGE_WORKLIST))
|
&& !gimple_plf (use_stmt, STMT_IN_SSA_EDGE_WORKLIST))
|
{
|
{
|
gimple_set_plf (use_stmt, STMT_IN_SSA_EDGE_WORKLIST, true);
|
gimple_set_plf (use_stmt, STMT_IN_SSA_EDGE_WORKLIST, true);
|
if (is_varying)
|
if (is_varying)
|
VEC_safe_push (gimple, gc, varying_ssa_edges, use_stmt);
|
VEC_safe_push (gimple, gc, varying_ssa_edges, use_stmt);
|
else
|
else
|
VEC_safe_push (gimple, gc, interesting_ssa_edges, use_stmt);
|
VEC_safe_push (gimple, gc, interesting_ssa_edges, use_stmt);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Add edge E to the control flow worklist. */
|
/* Add edge E to the control flow worklist. */
|
|
|
static void
|
static void
|
add_control_edge (edge e)
|
add_control_edge (edge e)
|
{
|
{
|
basic_block bb = e->dest;
|
basic_block bb = e->dest;
|
if (bb == EXIT_BLOCK_PTR)
|
if (bb == EXIT_BLOCK_PTR)
|
return;
|
return;
|
|
|
/* If the edge had already been executed, skip it. */
|
/* If the edge had already been executed, skip it. */
|
if (e->flags & EDGE_EXECUTABLE)
|
if (e->flags & EDGE_EXECUTABLE)
|
return;
|
return;
|
|
|
e->flags |= EDGE_EXECUTABLE;
|
e->flags |= EDGE_EXECUTABLE;
|
|
|
/* If the block is already in the list, we're done. */
|
/* If the block is already in the list, we're done. */
|
if (TEST_BIT (bb_in_list, bb->index))
|
if (TEST_BIT (bb_in_list, bb->index))
|
return;
|
return;
|
|
|
cfg_blocks_add (bb);
|
cfg_blocks_add (bb);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "Adding Destination of edge (%d -> %d) to worklist\n\n",
|
fprintf (dump_file, "Adding Destination of edge (%d -> %d) to worklist\n\n",
|
e->src->index, e->dest->index);
|
e->src->index, e->dest->index);
|
}
|
}
|
|
|
|
|
/* Simulate the execution of STMT and update the work lists accordingly. */
|
/* Simulate the execution of STMT and update the work lists accordingly. */
|
|
|
static void
|
static void
|
simulate_stmt (gimple stmt)
|
simulate_stmt (gimple stmt)
|
{
|
{
|
enum ssa_prop_result val = SSA_PROP_NOT_INTERESTING;
|
enum ssa_prop_result val = SSA_PROP_NOT_INTERESTING;
|
edge taken_edge = NULL;
|
edge taken_edge = NULL;
|
tree output_name = NULL_TREE;
|
tree output_name = NULL_TREE;
|
|
|
/* Don't bother visiting statements that are already
|
/* Don't bother visiting statements that are already
|
considered varying by the propagator. */
|
considered varying by the propagator. */
|
if (!prop_simulate_again_p (stmt))
|
if (!prop_simulate_again_p (stmt))
|
return;
|
return;
|
|
|
if (gimple_code (stmt) == GIMPLE_PHI)
|
if (gimple_code (stmt) == GIMPLE_PHI)
|
{
|
{
|
val = ssa_prop_visit_phi (stmt);
|
val = ssa_prop_visit_phi (stmt);
|
output_name = gimple_phi_result (stmt);
|
output_name = gimple_phi_result (stmt);
|
}
|
}
|
else
|
else
|
val = ssa_prop_visit_stmt (stmt, &taken_edge, &output_name);
|
val = ssa_prop_visit_stmt (stmt, &taken_edge, &output_name);
|
|
|
if (val == SSA_PROP_VARYING)
|
if (val == SSA_PROP_VARYING)
|
{
|
{
|
prop_set_simulate_again (stmt, false);
|
prop_set_simulate_again (stmt, false);
|
|
|
/* If the statement produced a new varying value, add the SSA
|
/* If the statement produced a new varying value, add the SSA
|
edges coming out of OUTPUT_NAME. */
|
edges coming out of OUTPUT_NAME. */
|
if (output_name)
|
if (output_name)
|
add_ssa_edge (output_name, true);
|
add_ssa_edge (output_name, true);
|
|
|
/* If STMT transfers control out of its basic block, add
|
/* If STMT transfers control out of its basic block, add
|
all outgoing edges to the work list. */
|
all outgoing edges to the work list. */
|
if (stmt_ends_bb_p (stmt))
|
if (stmt_ends_bb_p (stmt))
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
basic_block bb = gimple_bb (stmt);
|
basic_block bb = gimple_bb (stmt);
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
add_control_edge (e);
|
add_control_edge (e);
|
}
|
}
|
}
|
}
|
else if (val == SSA_PROP_INTERESTING)
|
else if (val == SSA_PROP_INTERESTING)
|
{
|
{
|
/* If the statement produced new value, add the SSA edges coming
|
/* If the statement produced new value, add the SSA edges coming
|
out of OUTPUT_NAME. */
|
out of OUTPUT_NAME. */
|
if (output_name)
|
if (output_name)
|
add_ssa_edge (output_name, false);
|
add_ssa_edge (output_name, false);
|
|
|
/* If we know which edge is going to be taken out of this block,
|
/* If we know which edge is going to be taken out of this block,
|
add it to the CFG work list. */
|
add it to the CFG work list. */
|
if (taken_edge)
|
if (taken_edge)
|
add_control_edge (taken_edge);
|
add_control_edge (taken_edge);
|
}
|
}
|
}
|
}
|
|
|
/* Process an SSA edge worklist. WORKLIST is the SSA edge worklist to
|
/* Process an SSA edge worklist. WORKLIST is the SSA edge worklist to
|
drain. This pops statements off the given WORKLIST and processes
|
drain. This pops statements off the given WORKLIST and processes
|
them until there are no more statements on WORKLIST.
|
them until there are no more statements on WORKLIST.
|
We take a pointer to WORKLIST because it may be reallocated when an
|
We take a pointer to WORKLIST because it may be reallocated when an
|
SSA edge is added to it in simulate_stmt. */
|
SSA edge is added to it in simulate_stmt. */
|
|
|
static void
|
static void
|
process_ssa_edge_worklist (VEC(gimple,gc) **worklist)
|
process_ssa_edge_worklist (VEC(gimple,gc) **worklist)
|
{
|
{
|
/* Drain the entire worklist. */
|
/* Drain the entire worklist. */
|
while (VEC_length (gimple, *worklist) > 0)
|
while (VEC_length (gimple, *worklist) > 0)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
/* Pull the statement to simulate off the worklist. */
|
/* Pull the statement to simulate off the worklist. */
|
gimple stmt = VEC_pop (gimple, *worklist);
|
gimple stmt = VEC_pop (gimple, *worklist);
|
|
|
/* If this statement was already visited by simulate_block, then
|
/* If this statement was already visited by simulate_block, then
|
we don't need to visit it again here. */
|
we don't need to visit it again here. */
|
if (!gimple_plf (stmt, STMT_IN_SSA_EDGE_WORKLIST))
|
if (!gimple_plf (stmt, STMT_IN_SSA_EDGE_WORKLIST))
|
continue;
|
continue;
|
|
|
/* STMT is no longer in a worklist. */
|
/* STMT is no longer in a worklist. */
|
gimple_set_plf (stmt, STMT_IN_SSA_EDGE_WORKLIST, false);
|
gimple_set_plf (stmt, STMT_IN_SSA_EDGE_WORKLIST, false);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "\nSimulating statement (from ssa_edges): ");
|
fprintf (dump_file, "\nSimulating statement (from ssa_edges): ");
|
print_gimple_stmt (dump_file, stmt, 0, dump_flags);
|
print_gimple_stmt (dump_file, stmt, 0, dump_flags);
|
}
|
}
|
|
|
bb = gimple_bb (stmt);
|
bb = gimple_bb (stmt);
|
|
|
/* PHI nodes are always visited, regardless of whether or not
|
/* PHI nodes are always visited, regardless of whether or not
|
the destination block is executable. Otherwise, visit the
|
the destination block is executable. Otherwise, visit the
|
statement only if its block is marked executable. */
|
statement only if its block is marked executable. */
|
if (gimple_code (stmt) == GIMPLE_PHI
|
if (gimple_code (stmt) == GIMPLE_PHI
|
|| TEST_BIT (executable_blocks, bb->index))
|
|| TEST_BIT (executable_blocks, bb->index))
|
simulate_stmt (stmt);
|
simulate_stmt (stmt);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Simulate the execution of BLOCK. Evaluate the statement associated
|
/* Simulate the execution of BLOCK. Evaluate the statement associated
|
with each variable reference inside the block. */
|
with each variable reference inside the block. */
|
|
|
static void
|
static void
|
simulate_block (basic_block block)
|
simulate_block (basic_block block)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
|
|
/* There is nothing to do for the exit block. */
|
/* There is nothing to do for the exit block. */
|
if (block == EXIT_BLOCK_PTR)
|
if (block == EXIT_BLOCK_PTR)
|
return;
|
return;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "\nSimulating block %d\n", block->index);
|
fprintf (dump_file, "\nSimulating block %d\n", block->index);
|
|
|
/* Always simulate PHI nodes, even if we have simulated this block
|
/* Always simulate PHI nodes, even if we have simulated this block
|
before. */
|
before. */
|
for (gsi = gsi_start_phis (block); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_phis (block); !gsi_end_p (gsi); gsi_next (&gsi))
|
simulate_stmt (gsi_stmt (gsi));
|
simulate_stmt (gsi_stmt (gsi));
|
|
|
/* If this is the first time we've simulated this block, then we
|
/* If this is the first time we've simulated this block, then we
|
must simulate each of its statements. */
|
must simulate each of its statements. */
|
if (!TEST_BIT (executable_blocks, block->index))
|
if (!TEST_BIT (executable_blocks, block->index))
|
{
|
{
|
gimple_stmt_iterator j;
|
gimple_stmt_iterator j;
|
unsigned int normal_edge_count;
|
unsigned int normal_edge_count;
|
edge e, normal_edge;
|
edge e, normal_edge;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
/* Note that we have simulated this block. */
|
/* Note that we have simulated this block. */
|
SET_BIT (executable_blocks, block->index);
|
SET_BIT (executable_blocks, block->index);
|
|
|
for (j = gsi_start_bb (block); !gsi_end_p (j); gsi_next (&j))
|
for (j = gsi_start_bb (block); !gsi_end_p (j); gsi_next (&j))
|
{
|
{
|
gimple stmt = gsi_stmt (j);
|
gimple stmt = gsi_stmt (j);
|
|
|
/* If this statement is already in the worklist then
|
/* If this statement is already in the worklist then
|
"cancel" it. The reevaluation implied by the worklist
|
"cancel" it. The reevaluation implied by the worklist
|
entry will produce the same value we generate here and
|
entry will produce the same value we generate here and
|
thus reevaluating it again from the worklist is
|
thus reevaluating it again from the worklist is
|
pointless. */
|
pointless. */
|
if (gimple_plf (stmt, STMT_IN_SSA_EDGE_WORKLIST))
|
if (gimple_plf (stmt, STMT_IN_SSA_EDGE_WORKLIST))
|
gimple_set_plf (stmt, STMT_IN_SSA_EDGE_WORKLIST, false);
|
gimple_set_plf (stmt, STMT_IN_SSA_EDGE_WORKLIST, false);
|
|
|
simulate_stmt (stmt);
|
simulate_stmt (stmt);
|
}
|
}
|
|
|
/* We can not predict when abnormal and EH edges will be executed, so
|
/* We can not predict when abnormal and EH edges will be executed, so
|
once a block is considered executable, we consider any
|
once a block is considered executable, we consider any
|
outgoing abnormal edges as executable.
|
outgoing abnormal edges as executable.
|
|
|
TODO: This is not exactly true. Simplifying statement might
|
TODO: This is not exactly true. Simplifying statement might
|
prove it non-throwing and also computed goto can be handled
|
prove it non-throwing and also computed goto can be handled
|
when destination is known.
|
when destination is known.
|
|
|
At the same time, if this block has only one successor that is
|
At the same time, if this block has only one successor that is
|
reached by non-abnormal edges, then add that successor to the
|
reached by non-abnormal edges, then add that successor to the
|
worklist. */
|
worklist. */
|
normal_edge_count = 0;
|
normal_edge_count = 0;
|
normal_edge = NULL;
|
normal_edge = NULL;
|
FOR_EACH_EDGE (e, ei, block->succs)
|
FOR_EACH_EDGE (e, ei, block->succs)
|
{
|
{
|
if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
|
if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
|
add_control_edge (e);
|
add_control_edge (e);
|
else
|
else
|
{
|
{
|
normal_edge_count++;
|
normal_edge_count++;
|
normal_edge = e;
|
normal_edge = e;
|
}
|
}
|
}
|
}
|
|
|
if (normal_edge_count == 1)
|
if (normal_edge_count == 1)
|
add_control_edge (normal_edge);
|
add_control_edge (normal_edge);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Initialize local data structures and work lists. */
|
/* Initialize local data structures and work lists. */
|
|
|
static void
|
static void
|
ssa_prop_init (void)
|
ssa_prop_init (void)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
basic_block bb;
|
basic_block bb;
|
|
|
/* Worklists of SSA edges. */
|
/* Worklists of SSA edges. */
|
interesting_ssa_edges = VEC_alloc (gimple, gc, 20);
|
interesting_ssa_edges = VEC_alloc (gimple, gc, 20);
|
varying_ssa_edges = VEC_alloc (gimple, gc, 20);
|
varying_ssa_edges = VEC_alloc (gimple, gc, 20);
|
|
|
executable_blocks = sbitmap_alloc (last_basic_block);
|
executable_blocks = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (executable_blocks);
|
sbitmap_zero (executable_blocks);
|
|
|
bb_in_list = sbitmap_alloc (last_basic_block);
|
bb_in_list = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (bb_in_list);
|
sbitmap_zero (bb_in_list);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
dump_immediate_uses (dump_file);
|
dump_immediate_uses (dump_file);
|
|
|
cfg_blocks = VEC_alloc (basic_block, heap, 20);
|
cfg_blocks = VEC_alloc (basic_block, heap, 20);
|
VEC_safe_grow (basic_block, heap, cfg_blocks, 20);
|
VEC_safe_grow (basic_block, heap, cfg_blocks, 20);
|
|
|
/* Initially assume that every edge in the CFG is not executable.
|
/* Initially assume that every edge in the CFG is not executable.
|
(including the edges coming out of ENTRY_BLOCK_PTR). */
|
(including the edges coming out of ENTRY_BLOCK_PTR). */
|
FOR_ALL_BB (bb)
|
FOR_ALL_BB (bb)
|
{
|
{
|
gimple_stmt_iterator si;
|
gimple_stmt_iterator si;
|
|
|
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
|
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
|
gimple_set_plf (gsi_stmt (si), STMT_IN_SSA_EDGE_WORKLIST, false);
|
gimple_set_plf (gsi_stmt (si), STMT_IN_SSA_EDGE_WORKLIST, false);
|
|
|
for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
|
for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
|
gimple_set_plf (gsi_stmt (si), STMT_IN_SSA_EDGE_WORKLIST, false);
|
gimple_set_plf (gsi_stmt (si), STMT_IN_SSA_EDGE_WORKLIST, false);
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
e->flags &= ~EDGE_EXECUTABLE;
|
e->flags &= ~EDGE_EXECUTABLE;
|
}
|
}
|
|
|
/* Seed the algorithm by adding the successors of the entry block to the
|
/* Seed the algorithm by adding the successors of the entry block to the
|
edge worklist. */
|
edge worklist. */
|
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
add_control_edge (e);
|
add_control_edge (e);
|
}
|
}
|
|
|
|
|
/* Free allocated storage. */
|
/* Free allocated storage. */
|
|
|
static void
|
static void
|
ssa_prop_fini (void)
|
ssa_prop_fini (void)
|
{
|
{
|
VEC_free (gimple, gc, interesting_ssa_edges);
|
VEC_free (gimple, gc, interesting_ssa_edges);
|
VEC_free (gimple, gc, varying_ssa_edges);
|
VEC_free (gimple, gc, varying_ssa_edges);
|
VEC_free (basic_block, heap, cfg_blocks);
|
VEC_free (basic_block, heap, cfg_blocks);
|
cfg_blocks = NULL;
|
cfg_blocks = NULL;
|
sbitmap_free (bb_in_list);
|
sbitmap_free (bb_in_list);
|
sbitmap_free (executable_blocks);
|
sbitmap_free (executable_blocks);
|
}
|
}
|
|
|
|
|
/* Return true if EXPR is an acceptable right-hand-side for a
|
/* Return true if EXPR is an acceptable right-hand-side for a
|
GIMPLE assignment. We validate the entire tree, not just
|
GIMPLE assignment. We validate the entire tree, not just
|
the root node, thus catching expressions that embed complex
|
the root node, thus catching expressions that embed complex
|
operands that are not permitted in GIMPLE. This function
|
operands that are not permitted in GIMPLE. This function
|
is needed because the folding routines in fold-const.c
|
is needed because the folding routines in fold-const.c
|
may return such expressions in some cases, e.g., an array
|
may return such expressions in some cases, e.g., an array
|
access with an embedded index addition. It may make more
|
access with an embedded index addition. It may make more
|
sense to have folding routines that are sensitive to the
|
sense to have folding routines that are sensitive to the
|
constraints on GIMPLE operands, rather than abandoning any
|
constraints on GIMPLE operands, rather than abandoning any
|
any attempt to fold if the usual folding turns out to be too
|
any attempt to fold if the usual folding turns out to be too
|
aggressive. */
|
aggressive. */
|
|
|
bool
|
bool
|
valid_gimple_rhs_p (tree expr)
|
valid_gimple_rhs_p (tree expr)
|
{
|
{
|
enum tree_code code = TREE_CODE (expr);
|
enum tree_code code = TREE_CODE (expr);
|
|
|
switch (TREE_CODE_CLASS (code))
|
switch (TREE_CODE_CLASS (code))
|
{
|
{
|
case tcc_declaration:
|
case tcc_declaration:
|
if (!is_gimple_variable (expr))
|
if (!is_gimple_variable (expr))
|
return false;
|
return false;
|
break;
|
break;
|
|
|
case tcc_constant:
|
case tcc_constant:
|
/* All constants are ok. */
|
/* All constants are ok. */
|
break;
|
break;
|
|
|
case tcc_binary:
|
case tcc_binary:
|
case tcc_comparison:
|
case tcc_comparison:
|
if (!is_gimple_val (TREE_OPERAND (expr, 0))
|
if (!is_gimple_val (TREE_OPERAND (expr, 0))
|
|| !is_gimple_val (TREE_OPERAND (expr, 1)))
|
|| !is_gimple_val (TREE_OPERAND (expr, 1)))
|
return false;
|
return false;
|
break;
|
break;
|
|
|
case tcc_unary:
|
case tcc_unary:
|
if (!is_gimple_val (TREE_OPERAND (expr, 0)))
|
if (!is_gimple_val (TREE_OPERAND (expr, 0)))
|
return false;
|
return false;
|
break;
|
break;
|
|
|
case tcc_expression:
|
case tcc_expression:
|
switch (code)
|
switch (code)
|
{
|
{
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
{
|
{
|
tree t;
|
tree t;
|
if (is_gimple_min_invariant (expr))
|
if (is_gimple_min_invariant (expr))
|
return true;
|
return true;
|
t = TREE_OPERAND (expr, 0);
|
t = TREE_OPERAND (expr, 0);
|
while (handled_component_p (t))
|
while (handled_component_p (t))
|
{
|
{
|
/* ??? More checks needed, see the GIMPLE verifier. */
|
/* ??? More checks needed, see the GIMPLE verifier. */
|
if ((TREE_CODE (t) == ARRAY_REF
|
if ((TREE_CODE (t) == ARRAY_REF
|
|| TREE_CODE (t) == ARRAY_RANGE_REF)
|
|| TREE_CODE (t) == ARRAY_RANGE_REF)
|
&& !is_gimple_val (TREE_OPERAND (t, 1)))
|
&& !is_gimple_val (TREE_OPERAND (t, 1)))
|
return false;
|
return false;
|
t = TREE_OPERAND (t, 0);
|
t = TREE_OPERAND (t, 0);
|
}
|
}
|
if (!is_gimple_id (t))
|
if (!is_gimple_id (t))
|
return false;
|
return false;
|
}
|
}
|
break;
|
break;
|
|
|
case TRUTH_NOT_EXPR:
|
case TRUTH_NOT_EXPR:
|
if (!is_gimple_val (TREE_OPERAND (expr, 0)))
|
if (!is_gimple_val (TREE_OPERAND (expr, 0)))
|
return false;
|
return false;
|
break;
|
break;
|
|
|
case TRUTH_AND_EXPR:
|
case TRUTH_AND_EXPR:
|
case TRUTH_XOR_EXPR:
|
case TRUTH_XOR_EXPR:
|
case TRUTH_OR_EXPR:
|
case TRUTH_OR_EXPR:
|
if (!is_gimple_val (TREE_OPERAND (expr, 0))
|
if (!is_gimple_val (TREE_OPERAND (expr, 0))
|
|| !is_gimple_val (TREE_OPERAND (expr, 1)))
|
|| !is_gimple_val (TREE_OPERAND (expr, 1)))
|
return false;
|
return false;
|
break;
|
break;
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
break;
|
break;
|
|
|
case tcc_vl_exp:
|
case tcc_vl_exp:
|
return false;
|
return false;
|
|
|
case tcc_exceptional:
|
case tcc_exceptional:
|
if (code != SSA_NAME)
|
if (code != SSA_NAME)
|
return false;
|
return false;
|
break;
|
break;
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Return true if EXPR is a CALL_EXPR suitable for representation
|
/* Return true if EXPR is a CALL_EXPR suitable for representation
|
as a single GIMPLE_CALL statement. If the arguments require
|
as a single GIMPLE_CALL statement. If the arguments require
|
further gimplification, return false. */
|
further gimplification, return false. */
|
|
|
bool
|
bool
|
valid_gimple_call_p (tree expr)
|
valid_gimple_call_p (tree expr)
|
{
|
{
|
unsigned i, nargs;
|
unsigned i, nargs;
|
|
|
if (TREE_CODE (expr) != CALL_EXPR)
|
if (TREE_CODE (expr) != CALL_EXPR)
|
return false;
|
return false;
|
|
|
nargs = call_expr_nargs (expr);
|
nargs = call_expr_nargs (expr);
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
if (! is_gimple_operand (CALL_EXPR_ARG (expr, i)))
|
if (! is_gimple_operand (CALL_EXPR_ARG (expr, i)))
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Make SSA names defined by OLD_STMT point to NEW_STMT
|
/* Make SSA names defined by OLD_STMT point to NEW_STMT
|
as their defining statement. */
|
as their defining statement. */
|
|
|
void
|
void
|
move_ssa_defining_stmt_for_defs (gimple new_stmt, gimple old_stmt)
|
move_ssa_defining_stmt_for_defs (gimple new_stmt, gimple old_stmt)
|
{
|
{
|
tree var;
|
tree var;
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
|
|
if (gimple_in_ssa_p (cfun))
|
if (gimple_in_ssa_p (cfun))
|
{
|
{
|
/* Make defined SSA_NAMEs point to the new
|
/* Make defined SSA_NAMEs point to the new
|
statement as their definition. */
|
statement as their definition. */
|
FOR_EACH_SSA_TREE_OPERAND (var, old_stmt, iter, SSA_OP_ALL_DEFS)
|
FOR_EACH_SSA_TREE_OPERAND (var, old_stmt, iter, SSA_OP_ALL_DEFS)
|
{
|
{
|
if (TREE_CODE (var) == SSA_NAME)
|
if (TREE_CODE (var) == SSA_NAME)
|
SSA_NAME_DEF_STMT (var) = new_stmt;
|
SSA_NAME_DEF_STMT (var) = new_stmt;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Update a GIMPLE_CALL statement at iterator *SI_P to reflect the
|
/* Update a GIMPLE_CALL statement at iterator *SI_P to reflect the
|
value of EXPR, which is expected to be the result of folding the
|
value of EXPR, which is expected to be the result of folding the
|
call. This can only be done if EXPR is a CALL_EXPR with valid
|
call. This can only be done if EXPR is a CALL_EXPR with valid
|
GIMPLE operands as arguments, or if it is a suitable RHS expression
|
GIMPLE operands as arguments, or if it is a suitable RHS expression
|
for a GIMPLE_ASSIGN. More complex expressions will require
|
for a GIMPLE_ASSIGN. More complex expressions will require
|
gimplification, which will introduce addtional statements. In this
|
gimplification, which will introduce addtional statements. In this
|
event, no update is performed, and the function returns false.
|
event, no update is performed, and the function returns false.
|
Note that we cannot mutate a GIMPLE_CALL in-place, so we always
|
Note that we cannot mutate a GIMPLE_CALL in-place, so we always
|
replace the statement at *SI_P with an entirely new statement.
|
replace the statement at *SI_P with an entirely new statement.
|
The new statement need not be a call, e.g., if the original call
|
The new statement need not be a call, e.g., if the original call
|
folded to a constant. */
|
folded to a constant. */
|
|
|
bool
|
bool
|
update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
|
update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
|
{
|
{
|
tree lhs;
|
tree lhs;
|
|
|
gimple stmt = gsi_stmt (*si_p);
|
gimple stmt = gsi_stmt (*si_p);
|
|
|
gcc_assert (is_gimple_call (stmt));
|
gcc_assert (is_gimple_call (stmt));
|
|
|
lhs = gimple_call_lhs (stmt);
|
lhs = gimple_call_lhs (stmt);
|
|
|
if (valid_gimple_call_p (expr))
|
if (valid_gimple_call_p (expr))
|
{
|
{
|
/* The call has simplified to another call. */
|
/* The call has simplified to another call. */
|
tree fn = CALL_EXPR_FN (expr);
|
tree fn = CALL_EXPR_FN (expr);
|
unsigned i;
|
unsigned i;
|
unsigned nargs = call_expr_nargs (expr);
|
unsigned nargs = call_expr_nargs (expr);
|
VEC(tree, heap) *args = NULL;
|
VEC(tree, heap) *args = NULL;
|
gimple new_stmt;
|
gimple new_stmt;
|
|
|
if (nargs > 0)
|
if (nargs > 0)
|
{
|
{
|
args = VEC_alloc (tree, heap, nargs);
|
args = VEC_alloc (tree, heap, nargs);
|
VEC_safe_grow (tree, heap, args, nargs);
|
VEC_safe_grow (tree, heap, args, nargs);
|
|
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
VEC_replace (tree, args, i, CALL_EXPR_ARG (expr, i));
|
VEC_replace (tree, args, i, CALL_EXPR_ARG (expr, i));
|
}
|
}
|
|
|
new_stmt = gimple_build_call_vec (fn, args);
|
new_stmt = gimple_build_call_vec (fn, args);
|
gimple_call_set_lhs (new_stmt, lhs);
|
gimple_call_set_lhs (new_stmt, lhs);
|
move_ssa_defining_stmt_for_defs (new_stmt, stmt);
|
move_ssa_defining_stmt_for_defs (new_stmt, stmt);
|
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
gimple_set_location (new_stmt, gimple_location (stmt));
|
gimple_set_location (new_stmt, gimple_location (stmt));
|
gsi_replace (si_p, new_stmt, false);
|
gsi_replace (si_p, new_stmt, false);
|
VEC_free (tree, heap, args);
|
VEC_free (tree, heap, args);
|
|
|
return true;
|
return true;
|
}
|
}
|
else if (valid_gimple_rhs_p (expr))
|
else if (valid_gimple_rhs_p (expr))
|
{
|
{
|
gimple new_stmt;
|
gimple new_stmt;
|
|
|
/* The call has simplified to an expression
|
/* The call has simplified to an expression
|
that cannot be represented as a GIMPLE_CALL. */
|
that cannot be represented as a GIMPLE_CALL. */
|
if (lhs)
|
if (lhs)
|
{
|
{
|
/* A value is expected.
|
/* A value is expected.
|
Introduce a new GIMPLE_ASSIGN statement. */
|
Introduce a new GIMPLE_ASSIGN statement. */
|
STRIP_USELESS_TYPE_CONVERSION (expr);
|
STRIP_USELESS_TYPE_CONVERSION (expr);
|
new_stmt = gimple_build_assign (lhs, expr);
|
new_stmt = gimple_build_assign (lhs, expr);
|
move_ssa_defining_stmt_for_defs (new_stmt, stmt);
|
move_ssa_defining_stmt_for_defs (new_stmt, stmt);
|
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
}
|
}
|
else if (!TREE_SIDE_EFFECTS (expr))
|
else if (!TREE_SIDE_EFFECTS (expr))
|
{
|
{
|
/* No value is expected, and EXPR has no effect.
|
/* No value is expected, and EXPR has no effect.
|
Replace it with an empty statement. */
|
Replace it with an empty statement. */
|
new_stmt = gimple_build_nop ();
|
new_stmt = gimple_build_nop ();
|
unlink_stmt_vdef (stmt);
|
unlink_stmt_vdef (stmt);
|
release_defs (stmt);
|
release_defs (stmt);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* No value is expected, but EXPR has an effect,
|
/* No value is expected, but EXPR has an effect,
|
e.g., it could be a reference to a volatile
|
e.g., it could be a reference to a volatile
|
variable. Create an assignment statement
|
variable. Create an assignment statement
|
with a dummy (unused) lhs variable. */
|
with a dummy (unused) lhs variable. */
|
STRIP_USELESS_TYPE_CONVERSION (expr);
|
STRIP_USELESS_TYPE_CONVERSION (expr);
|
lhs = create_tmp_var (TREE_TYPE (expr), NULL);
|
lhs = create_tmp_var (TREE_TYPE (expr), NULL);
|
new_stmt = gimple_build_assign (lhs, expr);
|
new_stmt = gimple_build_assign (lhs, expr);
|
add_referenced_var (lhs);
|
add_referenced_var (lhs);
|
lhs = make_ssa_name (lhs, new_stmt);
|
lhs = make_ssa_name (lhs, new_stmt);
|
gimple_assign_set_lhs (new_stmt, lhs);
|
gimple_assign_set_lhs (new_stmt, lhs);
|
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
move_ssa_defining_stmt_for_defs (new_stmt, stmt);
|
move_ssa_defining_stmt_for_defs (new_stmt, stmt);
|
}
|
}
|
gimple_set_location (new_stmt, gimple_location (stmt));
|
gimple_set_location (new_stmt, gimple_location (stmt));
|
gsi_replace (si_p, new_stmt, false);
|
gsi_replace (si_p, new_stmt, false);
|
return true;
|
return true;
|
}
|
}
|
else
|
else
|
/* The call simplified to an expression that is
|
/* The call simplified to an expression that is
|
not a valid GIMPLE RHS. */
|
not a valid GIMPLE RHS. */
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Entry point to the propagation engine.
|
/* Entry point to the propagation engine.
|
|
|
VISIT_STMT is called for every statement visited.
|
VISIT_STMT is called for every statement visited.
|
VISIT_PHI is called for every PHI node visited. */
|
VISIT_PHI is called for every PHI node visited. */
|
|
|
void
|
void
|
ssa_propagate (ssa_prop_visit_stmt_fn visit_stmt,
|
ssa_propagate (ssa_prop_visit_stmt_fn visit_stmt,
|
ssa_prop_visit_phi_fn visit_phi)
|
ssa_prop_visit_phi_fn visit_phi)
|
{
|
{
|
ssa_prop_visit_stmt = visit_stmt;
|
ssa_prop_visit_stmt = visit_stmt;
|
ssa_prop_visit_phi = visit_phi;
|
ssa_prop_visit_phi = visit_phi;
|
|
|
ssa_prop_init ();
|
ssa_prop_init ();
|
|
|
/* Iterate until the worklists are empty. */
|
/* Iterate until the worklists are empty. */
|
while (!cfg_blocks_empty_p ()
|
while (!cfg_blocks_empty_p ()
|
|| VEC_length (gimple, interesting_ssa_edges) > 0
|
|| VEC_length (gimple, interesting_ssa_edges) > 0
|
|| VEC_length (gimple, varying_ssa_edges) > 0)
|
|| VEC_length (gimple, varying_ssa_edges) > 0)
|
{
|
{
|
if (!cfg_blocks_empty_p ())
|
if (!cfg_blocks_empty_p ())
|
{
|
{
|
/* Pull the next block to simulate off the worklist. */
|
/* Pull the next block to simulate off the worklist. */
|
basic_block dest_block = cfg_blocks_get ();
|
basic_block dest_block = cfg_blocks_get ();
|
simulate_block (dest_block);
|
simulate_block (dest_block);
|
}
|
}
|
|
|
/* In order to move things to varying as quickly as
|
/* In order to move things to varying as quickly as
|
possible,process the VARYING_SSA_EDGES worklist first. */
|
possible,process the VARYING_SSA_EDGES worklist first. */
|
process_ssa_edge_worklist (&varying_ssa_edges);
|
process_ssa_edge_worklist (&varying_ssa_edges);
|
|
|
/* Now process the INTERESTING_SSA_EDGES worklist. */
|
/* Now process the INTERESTING_SSA_EDGES worklist. */
|
process_ssa_edge_worklist (&interesting_ssa_edges);
|
process_ssa_edge_worklist (&interesting_ssa_edges);
|
}
|
}
|
|
|
ssa_prop_fini ();
|
ssa_prop_fini ();
|
}
|
}
|
|
|
|
|
/* Return true if STMT is of the form 'mem_ref = RHS', where 'mem_ref'
|
/* Return true if STMT is of the form 'mem_ref = RHS', where 'mem_ref'
|
is a non-volatile pointer dereference, a structure reference or a
|
is a non-volatile pointer dereference, a structure reference or a
|
reference to a single _DECL. Ignore volatile memory references
|
reference to a single _DECL. Ignore volatile memory references
|
because they are not interesting for the optimizers. */
|
because they are not interesting for the optimizers. */
|
|
|
bool
|
bool
|
stmt_makes_single_store (gimple stmt)
|
stmt_makes_single_store (gimple stmt)
|
{
|
{
|
tree lhs;
|
tree lhs;
|
|
|
if (gimple_code (stmt) != GIMPLE_ASSIGN
|
if (gimple_code (stmt) != GIMPLE_ASSIGN
|
&& gimple_code (stmt) != GIMPLE_CALL)
|
&& gimple_code (stmt) != GIMPLE_CALL)
|
return false;
|
return false;
|
|
|
if (!gimple_vdef (stmt))
|
if (!gimple_vdef (stmt))
|
return false;
|
return false;
|
|
|
lhs = gimple_get_lhs (stmt);
|
lhs = gimple_get_lhs (stmt);
|
|
|
/* A call statement may have a null LHS. */
|
/* A call statement may have a null LHS. */
|
if (!lhs)
|
if (!lhs)
|
return false;
|
return false;
|
|
|
return (!TREE_THIS_VOLATILE (lhs)
|
return (!TREE_THIS_VOLATILE (lhs)
|
&& (DECL_P (lhs)
|
&& (DECL_P (lhs)
|
|| REFERENCE_CLASS_P (lhs)));
|
|| REFERENCE_CLASS_P (lhs)));
|
}
|
}
|
|
|
|
|
/* Propagation statistics. */
|
/* Propagation statistics. */
|
struct prop_stats_d
|
struct prop_stats_d
|
{
|
{
|
long num_const_prop;
|
long num_const_prop;
|
long num_copy_prop;
|
long num_copy_prop;
|
long num_stmts_folded;
|
long num_stmts_folded;
|
long num_dce;
|
long num_dce;
|
};
|
};
|
|
|
static struct prop_stats_d prop_stats;
|
static struct prop_stats_d prop_stats;
|
|
|
/* Replace USE references in statement STMT with the values stored in
|
/* Replace USE references in statement STMT with the values stored in
|
PROP_VALUE. Return true if at least one reference was replaced. */
|
PROP_VALUE. Return true if at least one reference was replaced. */
|
|
|
static bool
|
static bool
|
replace_uses_in (gimple stmt, prop_value_t *prop_value)
|
replace_uses_in (gimple stmt, prop_value_t *prop_value)
|
{
|
{
|
bool replaced = false;
|
bool replaced = false;
|
use_operand_p use;
|
use_operand_p use;
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
|
|
FOR_EACH_SSA_USE_OPERAND (use, stmt, iter, SSA_OP_USE)
|
FOR_EACH_SSA_USE_OPERAND (use, stmt, iter, SSA_OP_USE)
|
{
|
{
|
tree tuse = USE_FROM_PTR (use);
|
tree tuse = USE_FROM_PTR (use);
|
tree val = prop_value[SSA_NAME_VERSION (tuse)].value;
|
tree val = prop_value[SSA_NAME_VERSION (tuse)].value;
|
|
|
if (val == tuse || val == NULL_TREE)
|
if (val == tuse || val == NULL_TREE)
|
continue;
|
continue;
|
|
|
if (gimple_code (stmt) == GIMPLE_ASM
|
if (gimple_code (stmt) == GIMPLE_ASM
|
&& !may_propagate_copy_into_asm (tuse))
|
&& !may_propagate_copy_into_asm (tuse))
|
continue;
|
continue;
|
|
|
if (!may_propagate_copy (tuse, val))
|
if (!may_propagate_copy (tuse, val))
|
continue;
|
continue;
|
|
|
if (TREE_CODE (val) != SSA_NAME)
|
if (TREE_CODE (val) != SSA_NAME)
|
prop_stats.num_const_prop++;
|
prop_stats.num_const_prop++;
|
else
|
else
|
prop_stats.num_copy_prop++;
|
prop_stats.num_copy_prop++;
|
|
|
propagate_value (use, val);
|
propagate_value (use, val);
|
|
|
replaced = true;
|
replaced = true;
|
}
|
}
|
|
|
return replaced;
|
return replaced;
|
}
|
}
|
|
|
|
|
/* Replace propagated values into all the arguments for PHI using the
|
/* Replace propagated values into all the arguments for PHI using the
|
values from PROP_VALUE. */
|
values from PROP_VALUE. */
|
|
|
static void
|
static void
|
replace_phi_args_in (gimple phi, prop_value_t *prop_value)
|
replace_phi_args_in (gimple phi, prop_value_t *prop_value)
|
{
|
{
|
size_t i;
|
size_t i;
|
bool replaced = false;
|
bool replaced = false;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Folding PHI node: ");
|
fprintf (dump_file, "Folding PHI node: ");
|
print_gimple_stmt (dump_file, phi, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, phi, 0, TDF_SLIM);
|
}
|
}
|
|
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
{
|
{
|
tree arg = gimple_phi_arg_def (phi, i);
|
tree arg = gimple_phi_arg_def (phi, i);
|
|
|
if (TREE_CODE (arg) == SSA_NAME)
|
if (TREE_CODE (arg) == SSA_NAME)
|
{
|
{
|
tree val = prop_value[SSA_NAME_VERSION (arg)].value;
|
tree val = prop_value[SSA_NAME_VERSION (arg)].value;
|
|
|
if (val && val != arg && may_propagate_copy (arg, val))
|
if (val && val != arg && may_propagate_copy (arg, val))
|
{
|
{
|
if (TREE_CODE (val) != SSA_NAME)
|
if (TREE_CODE (val) != SSA_NAME)
|
prop_stats.num_const_prop++;
|
prop_stats.num_const_prop++;
|
else
|
else
|
prop_stats.num_copy_prop++;
|
prop_stats.num_copy_prop++;
|
|
|
propagate_value (PHI_ARG_DEF_PTR (phi, i), val);
|
propagate_value (PHI_ARG_DEF_PTR (phi, i), val);
|
replaced = true;
|
replaced = true;
|
|
|
/* If we propagated a copy and this argument flows
|
/* If we propagated a copy and this argument flows
|
through an abnormal edge, update the replacement
|
through an abnormal edge, update the replacement
|
accordingly. */
|
accordingly. */
|
if (TREE_CODE (val) == SSA_NAME
|
if (TREE_CODE (val) == SSA_NAME
|
&& gimple_phi_arg_edge (phi, i)->flags & EDGE_ABNORMAL)
|
&& gimple_phi_arg_edge (phi, i)->flags & EDGE_ABNORMAL)
|
SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val) = 1;
|
SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val) = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
if (!replaced)
|
if (!replaced)
|
fprintf (dump_file, "No folding possible\n");
|
fprintf (dump_file, "No folding possible\n");
|
else
|
else
|
{
|
{
|
fprintf (dump_file, "Folded into: ");
|
fprintf (dump_file, "Folded into: ");
|
print_gimple_stmt (dump_file, phi, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, phi, 0, TDF_SLIM);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Perform final substitution and folding of propagated values.
|
/* Perform final substitution and folding of propagated values.
|
|
|
PROP_VALUE[I] contains the single value that should be substituted
|
PROP_VALUE[I] contains the single value that should be substituted
|
at every use of SSA name N_I. If PROP_VALUE is NULL, no values are
|
at every use of SSA name N_I. If PROP_VALUE is NULL, no values are
|
substituted.
|
substituted.
|
|
|
If FOLD_FN is non-NULL the function will be invoked on all statements
|
If FOLD_FN is non-NULL the function will be invoked on all statements
|
before propagating values for pass specific simplification.
|
before propagating values for pass specific simplification.
|
|
|
DO_DCE is true if trivially dead stmts can be removed.
|
DO_DCE is true if trivially dead stmts can be removed.
|
|
|
Return TRUE when something changed. */
|
Return TRUE when something changed. */
|
|
|
bool
|
bool
|
substitute_and_fold (prop_value_t *prop_value, ssa_prop_fold_stmt_fn fold_fn,
|
substitute_and_fold (prop_value_t *prop_value, ssa_prop_fold_stmt_fn fold_fn,
|
bool do_dce)
|
bool do_dce)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
bool something_changed = false;
|
bool something_changed = false;
|
|
|
if (prop_value == NULL && !fold_fn)
|
if (prop_value == NULL && !fold_fn)
|
return false;
|
return false;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "\nSubstituting values and folding statements\n\n");
|
fprintf (dump_file, "\nSubstituting values and folding statements\n\n");
|
|
|
memset (&prop_stats, 0, sizeof (prop_stats));
|
memset (&prop_stats, 0, sizeof (prop_stats));
|
|
|
/* Substitute values in every statement of every basic block. */
|
/* Substitute values in every statement of every basic block. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
gimple_stmt_iterator i;
|
gimple_stmt_iterator i;
|
|
|
/* Propagate known values into PHI nodes. */
|
/* Propagate known values into PHI nodes. */
|
if (prop_value)
|
if (prop_value)
|
for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
|
for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
|
replace_phi_args_in (gsi_stmt (i), prop_value);
|
replace_phi_args_in (gsi_stmt (i), prop_value);
|
|
|
/* Propagate known values into stmts. Do a backward walk to expose
|
/* Propagate known values into stmts. Do a backward walk to expose
|
more trivially deletable stmts. */
|
more trivially deletable stmts. */
|
for (i = gsi_last_bb (bb); !gsi_end_p (i);)
|
for (i = gsi_last_bb (bb); !gsi_end_p (i);)
|
{
|
{
|
bool did_replace;
|
bool did_replace;
|
gimple stmt = gsi_stmt (i);
|
gimple stmt = gsi_stmt (i);
|
gimple old_stmt;
|
gimple old_stmt;
|
enum gimple_code code = gimple_code (stmt);
|
enum gimple_code code = gimple_code (stmt);
|
gimple_stmt_iterator oldi;
|
gimple_stmt_iterator oldi;
|
|
|
oldi = i;
|
oldi = i;
|
gsi_prev (&i);
|
gsi_prev (&i);
|
|
|
/* Ignore ASSERT_EXPRs. They are used by VRP to generate
|
/* Ignore ASSERT_EXPRs. They are used by VRP to generate
|
range information for names and they are discarded
|
range information for names and they are discarded
|
afterwards. */
|
afterwards. */
|
|
|
if (code == GIMPLE_ASSIGN
|
if (code == GIMPLE_ASSIGN
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == ASSERT_EXPR)
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == ASSERT_EXPR)
|
continue;
|
continue;
|
|
|
/* No point propagating into a stmt whose result is not used,
|
/* No point propagating into a stmt whose result is not used,
|
but instead we might be able to remove a trivially dead stmt.
|
but instead we might be able to remove a trivially dead stmt.
|
Don't do this when called from VRP, since the SSA_NAME which
|
Don't do this when called from VRP, since the SSA_NAME which
|
is going to be released could be still referenced in VRP
|
is going to be released could be still referenced in VRP
|
ranges. */
|
ranges. */
|
if (do_dce
|
if (do_dce
|
&& gimple_get_lhs (stmt)
|
&& gimple_get_lhs (stmt)
|
&& TREE_CODE (gimple_get_lhs (stmt)) == SSA_NAME
|
&& TREE_CODE (gimple_get_lhs (stmt)) == SSA_NAME
|
&& has_zero_uses (gimple_get_lhs (stmt))
|
&& has_zero_uses (gimple_get_lhs (stmt))
|
&& !stmt_could_throw_p (stmt)
|
&& !stmt_could_throw_p (stmt)
|
&& !gimple_has_side_effects (stmt))
|
&& !gimple_has_side_effects (stmt))
|
{
|
{
|
gimple_stmt_iterator i2;
|
gimple_stmt_iterator i2;
|
|
|
if (dump_file && dump_flags & TDF_DETAILS)
|
if (dump_file && dump_flags & TDF_DETAILS)
|
{
|
{
|
fprintf (dump_file, "Removing dead stmt ");
|
fprintf (dump_file, "Removing dead stmt ");
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
prop_stats.num_dce++;
|
prop_stats.num_dce++;
|
i2 = gsi_for_stmt (stmt);
|
i2 = gsi_for_stmt (stmt);
|
gsi_remove (&i2, true);
|
gsi_remove (&i2, true);
|
release_defs (stmt);
|
release_defs (stmt);
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Replace the statement with its folded version and mark it
|
/* Replace the statement with its folded version and mark it
|
folded. */
|
folded. */
|
did_replace = false;
|
did_replace = false;
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Folding statement: ");
|
fprintf (dump_file, "Folding statement: ");
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
}
|
}
|
|
|
old_stmt = stmt;
|
old_stmt = stmt;
|
|
|
/* Some statements may be simplified using propagator
|
/* Some statements may be simplified using propagator
|
specific information. Do this before propagating
|
specific information. Do this before propagating
|
into the stmt to not disturb pass specific information. */
|
into the stmt to not disturb pass specific information. */
|
if (fold_fn
|
if (fold_fn
|
&& (*fold_fn)(&oldi))
|
&& (*fold_fn)(&oldi))
|
{
|
{
|
did_replace = true;
|
did_replace = true;
|
prop_stats.num_stmts_folded++;
|
prop_stats.num_stmts_folded++;
|
}
|
}
|
|
|
/* Only replace real uses if we couldn't fold the
|
/* Only replace real uses if we couldn't fold the
|
statement using value range information. */
|
statement using value range information. */
|
if (prop_value
|
if (prop_value
|
&& !did_replace)
|
&& !did_replace)
|
did_replace |= replace_uses_in (stmt, prop_value);
|
did_replace |= replace_uses_in (stmt, prop_value);
|
|
|
/* If we made a replacement, fold the statement. */
|
/* If we made a replacement, fold the statement. */
|
if (did_replace)
|
if (did_replace)
|
fold_stmt (&oldi);
|
fold_stmt (&oldi);
|
|
|
/* Now cleanup. */
|
/* Now cleanup. */
|
if (did_replace)
|
if (did_replace)
|
{
|
{
|
stmt = gsi_stmt (oldi);
|
stmt = gsi_stmt (oldi);
|
|
|
/* If we cleaned up EH information from the statement,
|
/* If we cleaned up EH information from the statement,
|
remove EH edges. */
|
remove EH edges. */
|
if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt))
|
if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt))
|
gimple_purge_dead_eh_edges (bb);
|
gimple_purge_dead_eh_edges (bb);
|
|
|
if (is_gimple_assign (stmt)
|
if (is_gimple_assign (stmt)
|
&& (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
|
&& (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
|
== GIMPLE_SINGLE_RHS))
|
== GIMPLE_SINGLE_RHS))
|
{
|
{
|
tree rhs = gimple_assign_rhs1 (stmt);
|
tree rhs = gimple_assign_rhs1 (stmt);
|
|
|
if (TREE_CODE (rhs) == ADDR_EXPR)
|
if (TREE_CODE (rhs) == ADDR_EXPR)
|
recompute_tree_invariant_for_addr_expr (rhs);
|
recompute_tree_invariant_for_addr_expr (rhs);
|
}
|
}
|
|
|
/* Determine what needs to be done to update the SSA form. */
|
/* Determine what needs to be done to update the SSA form. */
|
update_stmt (stmt);
|
update_stmt (stmt);
|
if (!is_gimple_debug (stmt))
|
if (!is_gimple_debug (stmt))
|
something_changed = true;
|
something_changed = true;
|
}
|
}
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
if (did_replace)
|
if (did_replace)
|
{
|
{
|
fprintf (dump_file, "Folded into: ");
|
fprintf (dump_file, "Folded into: ");
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
else
|
else
|
fprintf (dump_file, "Not folded\n");
|
fprintf (dump_file, "Not folded\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
statistics_counter_event (cfun, "Constants propagated",
|
statistics_counter_event (cfun, "Constants propagated",
|
prop_stats.num_const_prop);
|
prop_stats.num_const_prop);
|
statistics_counter_event (cfun, "Copies propagated",
|
statistics_counter_event (cfun, "Copies propagated",
|
prop_stats.num_copy_prop);
|
prop_stats.num_copy_prop);
|
statistics_counter_event (cfun, "Statements folded",
|
statistics_counter_event (cfun, "Statements folded",
|
prop_stats.num_stmts_folded);
|
prop_stats.num_stmts_folded);
|
statistics_counter_event (cfun, "Statements deleted",
|
statistics_counter_event (cfun, "Statements deleted",
|
prop_stats.num_dce);
|
prop_stats.num_dce);
|
return something_changed;
|
return something_changed;
|
}
|
}
|
|
|
#include "gt-tree-ssa-propagate.h"
|
#include "gt-tree-ssa-propagate.h"
|
|
|
