/* Dead code elimination pass for the GNU compiler.
- Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
Contributed by Ben Elliston <bje@redhat.com>
and Andrew MacLeod <amacleod@redhat.com>
Adapted to use control dependence by Steven Bosscher, SUSE Labs.
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
+Free Software Foundation; either version 3, or (at your option) any
later version.
GCC is distributed in the hope that it will be useful, but WITHOUT
for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
/* Dead code elimination.
#include "tree-pass.h"
#include "timevar.h"
#include "flags.h"
+#include "cfgloop.h"
+#include "tree-scalar-evolution.h"
\f
static struct stmt_stats
{
to be recomputed. */
static bool cfg_altered;
-/* Execute CODE for each edge (given number EDGE_NUMBER within the CODE)
- for which the block with index N is control dependent. */
-#define EXECUTE_IF_CONTROL_DEPENDENT(N, EDGE_NUMBER, CODE) \
- { \
- bitmap_iterator bi; \
- \
- EXECUTE_IF_SET_IN_BITMAP (control_dependence_map[N], 0, EDGE_NUMBER, bi) \
- { \
- CODE; \
- } \
- }
-
-/* Local function prototypes. */
-static inline void set_control_dependence_map_bit (basic_block, int);
-static inline void clear_control_dependence_bitmap (basic_block);
-static void find_all_control_dependences (struct edge_list *);
-static void find_control_dependence (struct edge_list *, int);
-static inline basic_block find_pdom (basic_block);
-
-static inline void mark_stmt_necessary (tree, bool);
-static inline void mark_operand_necessary (tree, bool);
-
-static void mark_stmt_if_obviously_necessary (tree, bool);
-static void find_obviously_necessary_stmts (struct edge_list *);
-
-static void mark_control_dependent_edges_necessary (basic_block, struct edge_list *);
-static void propagate_necessity (struct edge_list *);
-
-static void eliminate_unnecessary_stmts (void);
-static void remove_dead_phis (basic_block);
-static void remove_dead_stmt (block_stmt_iterator *, basic_block);
-
-static void print_stats (void);
-static void tree_dce_init (bool);
-static void tree_dce_done (bool);
-\f
+/* Execute code that follows the macro for each edge (given number
+ EDGE_NUMBER within the CODE) for which the block with index N is
+ control dependent. */
+#define EXECUTE_IF_CONTROL_DEPENDENT(BI, N, EDGE_NUMBER) \
+ EXECUTE_IF_SET_IN_BITMAP (control_dependence_map[(N)], 0, \
+ (EDGE_NUMBER), (BI))
+
+
/* Indicate block BB is control dependent on an edge with index EDGE_INDEX. */
static inline void
set_control_dependence_map_bit (basic_block bb, int edge_index)
}
/* Clear all control dependences for block BB. */
-static inline
-void clear_control_dependence_bitmap (basic_block bb)
+static inline void
+clear_control_dependence_bitmap (basic_block bb)
{
bitmap_clear (control_dependence_map[bb->index]);
}
-/* Record all blocks' control dependences on all edges in the edge
- list EL, ala Morgan, Section 3.6. */
-static void
-find_all_control_dependences (struct edge_list *el)
+/* Find the immediate postdominator PDOM of the specified basic block BLOCK.
+ This function is necessary because some blocks have negative numbers. */
+
+static inline basic_block
+find_pdom (basic_block block)
{
- int i;
+ gcc_assert (block != ENTRY_BLOCK_PTR);
- for (i = 0; i < NUM_EDGES (el); ++i)
- find_control_dependence (el, i);
+ if (block == EXIT_BLOCK_PTR)
+ return EXIT_BLOCK_PTR;
+ else
+ {
+ basic_block bb = get_immediate_dominator (CDI_POST_DOMINATORS, block);
+ if (! bb)
+ return EXIT_BLOCK_PTR;
+ return bb;
+ }
}
+
/* Determine all blocks' control dependences on the given edge with edge_list
EL index EDGE_INDEX, ala Morgan, Section 3.6. */
gcc_assert (INDEX_EDGE_PRED_BB (el, edge_index) != EXIT_BLOCK_PTR);
if (INDEX_EDGE_PRED_BB (el, edge_index) == ENTRY_BLOCK_PTR)
- ending_block = ENTRY_BLOCK_PTR->next_bb;
+ ending_block = single_succ (ENTRY_BLOCK_PTR);
else
ending_block = find_pdom (INDEX_EDGE_PRED_BB (el, edge_index));
}
}
-/* Find the immediate postdominator PDOM of the specified basic block BLOCK.
- This function is necessary because some blocks have negative numbers. */
-static inline basic_block
-find_pdom (basic_block block)
+/* Record all blocks' control dependences on all edges in the edge
+ list EL, ala Morgan, Section 3.6. */
+
+static void
+find_all_control_dependences (struct edge_list *el)
{
- gcc_assert (block != ENTRY_BLOCK_PTR);
+ int i;
- if (block == EXIT_BLOCK_PTR)
- return EXIT_BLOCK_PTR;
- else
- {
- basic_block bb = get_immediate_dominator (CDI_POST_DOMINATORS, block);
- if (! bb)
- return EXIT_BLOCK_PTR;
- return bb;
- }
+ for (i = 0; i < NUM_EDGES (el); ++i)
+ find_control_dependence (el, i);
}
-\f
-#define NECESSARY(stmt) stmt->common.asm_written_flag
+
+
+#define NECESSARY(stmt) stmt->base.asm_written_flag
/* If STMT is not already marked necessary, mark it, and add it to the
worklist if ADD_TO_WORKLIST is true. */
VEC_safe_push (tree, heap, worklist, stmt);
}
-/* Mark the statement defining operand OP as necessary. PHIONLY is true
- if we should only mark it necessary if it is a phi node. */
+
+/* Mark the statement defining operand OP as necessary. */
static inline void
-mark_operand_necessary (tree op, bool phionly)
+mark_operand_necessary (tree op)
{
tree stmt;
int ver;
stmt = SSA_NAME_DEF_STMT (op);
gcc_assert (stmt);
- if (NECESSARY (stmt)
- || IS_EMPTY_STMT (stmt)
- || (phionly && TREE_CODE (stmt) != PHI_NODE))
+ if (NECESSARY (stmt) || IS_EMPTY_STMT (stmt))
return;
NECESSARY (stmt) = 1;
VEC_safe_push (tree, heap, worklist, stmt);
}
-\f
+
/* Mark STMT as necessary if it obviously is. Add it to the worklist if
it can make other statements necessary.
mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
{
stmt_ann_t ann;
- tree op, def;
- ssa_op_iter iter;
+ tree op;
/* With non-call exceptions, we have to assume that all statements could
throw. If a statement may throw, it is inherently necessary. */
case ASM_EXPR:
case RESX_EXPR:
case RETURN_EXPR:
+ case CHANGE_DYNAMIC_TYPE_EXPR:
mark_stmt_necessary (stmt, true);
return;
mark_stmt_necessary (stmt, true);
return;
- case MODIFY_EXPR:
+ case GIMPLE_MODIFY_STMT:
op = get_call_expr_in (stmt);
if (op && TREE_SIDE_EFFECTS (op))
{
/* These values are mildly magic bits of the EH runtime. We can't
see the entire lifetime of these values until landing pads are
generated. */
- if (TREE_CODE (TREE_OPERAND (stmt, 0)) == EXC_PTR_EXPR
- || TREE_CODE (TREE_OPERAND (stmt, 0)) == FILTER_EXPR)
+ if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == EXC_PTR_EXPR
+ || TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == FILTER_EXPR)
{
mark_stmt_necessary (stmt, true);
return;
return;
}
- FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
- {
- if (is_global_var (SSA_NAME_VAR (def)))
- {
- mark_stmt_necessary (stmt, true);
- return;
- }
- }
if (is_hidden_global_store (stmt))
{
mark_stmt_necessary (stmt, true);
return;
}
-\f
+
+
+/* Make corresponding control dependent edges necessary. We only
+ have to do this once for each basic block, so we clear the bitmap
+ after we're done. */
+static void
+mark_control_dependent_edges_necessary (basic_block bb, struct edge_list *el)
+{
+ bitmap_iterator bi;
+ unsigned edge_number;
+
+ gcc_assert (bb != EXIT_BLOCK_PTR);
+
+ if (bb == ENTRY_BLOCK_PTR)
+ return;
+
+ EXECUTE_IF_CONTROL_DEPENDENT (bi, bb->index, edge_number)
+ {
+ tree t;
+ basic_block cd_bb = INDEX_EDGE_PRED_BB (el, edge_number);
+
+ if (TEST_BIT (last_stmt_necessary, cd_bb->index))
+ continue;
+ SET_BIT (last_stmt_necessary, cd_bb->index);
+
+ t = last_stmt (cd_bb);
+ if (t && is_ctrl_stmt (t))
+ mark_stmt_necessary (t, true);
+ }
+}
+
+
/* Find obviously necessary statements. These are things like most function
calls, and stores to file level variables.
{
tree phi;
- /* Check any PHI nodes in the block. */
+ /* PHI nodes are never inherently necessary. */
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
- {
- NECESSARY (phi) = 0;
-
- /* PHIs for virtual variables do not directly affect code
- generation and need not be considered inherently necessary
- regardless of the bits set in their decl.
-
- Thus, we only need to mark PHIs for real variables which
- need their result preserved as being inherently necessary. */
- if (is_gimple_reg (PHI_RESULT (phi))
- && is_global_var (SSA_NAME_VAR (PHI_RESULT (phi))))
- mark_stmt_necessary (phi, true);
- }
+ NECESSARY (phi) = 0;
/* Check all statements in the block. */
for (i = bsi_start (bb); ! bsi_end_p (i); bsi_next (&i))
}
}
}
-\f
-/* Make corresponding control dependent edges necessary. We only
- have to do this once for each basic block, so we clear the bitmap
- after we're done. */
-static void
-mark_control_dependent_edges_necessary (basic_block bb, struct edge_list *el)
-{
- unsigned edge_number;
- gcc_assert (bb != EXIT_BLOCK_PTR);
- if (bb == ENTRY_BLOCK_PTR)
- return;
-
- EXECUTE_IF_CONTROL_DEPENDENT (bb->index, edge_number,
- {
- tree t;
- basic_block cd_bb = INDEX_EDGE_PRED_BB (el, edge_number);
-
- if (TEST_BIT (last_stmt_necessary, cd_bb->index))
- continue;
- SET_BIT (last_stmt_necessary, cd_bb->index);
-
- t = last_stmt (cd_bb);
- if (t && is_ctrl_stmt (t))
- mark_stmt_necessary (t, true);
- });
-}
-\f
-/* Propagate necessity using the operands of necessary statements. Process
- the uses on each statement in the worklist, and add all feeding statements
- which contribute to the calculation of this value to the worklist.
+/* Propagate necessity using the operands of necessary statements.
+ Process the uses on each statement in the worklist, and add all
+ feeding statements which contribute to the calculation of this
+ value to the worklist.
In conservative mode, EL is NULL. */
static void
propagate_necessity (struct edge_list *el)
{
- tree i;
+ tree stmt;
bool aggressive = (el ? true : false);
if (dump_file && (dump_flags & TDF_DETAILS))
while (VEC_length (tree, worklist) > 0)
{
- /* Take `i' from worklist. */
- i = VEC_pop (tree, worklist);
+ /* Take STMT from worklist. */
+ stmt = VEC_pop (tree, worklist);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "processing: ");
- print_generic_stmt (dump_file, i, TDF_SLIM);
+ print_generic_stmt (dump_file, stmt, TDF_SLIM);
fprintf (dump_file, "\n");
}
if (aggressive)
{
/* Mark the last statements of the basic blocks that the block
- containing `i' is control dependent on, but only if we haven't
+ containing STMT is control dependent on, but only if we haven't
already done so. */
- basic_block bb = bb_for_stmt (i);
+ basic_block bb = bb_for_stmt (stmt);
if (bb != ENTRY_BLOCK_PTR
&& ! TEST_BIT (visited_control_parents, bb->index))
{
}
}
- if (TREE_CODE (i) == PHI_NODE)
+ if (TREE_CODE (stmt) == PHI_NODE)
{
/* PHI nodes are somewhat special in that each PHI alternative has
data and control dependencies. All the statements feeding the
predecessor block associated with each PHI alternative as
necessary. */
int k;
- for (k = 0; k < PHI_NUM_ARGS (i); k++)
+
+ for (k = 0; k < PHI_NUM_ARGS (stmt); k++)
{
- tree arg = PHI_ARG_DEF (i, k);
+ tree arg = PHI_ARG_DEF (stmt, k);
if (TREE_CODE (arg) == SSA_NAME)
- mark_operand_necessary (arg, false);
+ mark_operand_necessary (arg);
}
if (aggressive)
{
- for (k = 0; k < PHI_NUM_ARGS (i); k++)
+ for (k = 0; k < PHI_NUM_ARGS (stmt); k++)
{
- basic_block arg_bb = PHI_ARG_EDGE (i, k)->src;
+ basic_block arg_bb = PHI_ARG_EDGE (stmt, k)->src;
if (arg_bb != ENTRY_BLOCK_PTR
&& ! TEST_BIT (visited_control_parents, arg_bb->index))
{
else
{
/* Propagate through the operands. Examine all the USE, VUSE and
- V_MAY_DEF operands in this statement. Mark all the statements
- which feed this statement's uses as necessary. */
- ssa_op_iter iter;
- tree use;
-
- /* The operands of V_MAY_DEF expressions are also needed as they
+ VDEF operands in this statement. Mark all the statements
+ which feed this statement's uses as necessary. The
+ operands of VDEF expressions are also needed as they
represent potential definitions that may reach this
- statement (V_MAY_DEF operands allow us to follow def-def
+ statement (VDEF operands allow us to follow def-def
links). */
+ ssa_op_iter iter;
+ tree use;
- FOR_EACH_SSA_TREE_OPERAND (use, i, iter, SSA_OP_ALL_USES)
- mark_operand_necessary (use, false);
- }
- }
-}
-
-
-/* Propagate necessity around virtual phi nodes used in kill operands.
- The reason this isn't done during propagate_necessity is because we don't
- want to keep phis around that are just there for must-defs, unless we
- absolutely have to. After we've rewritten the reaching definitions to be
- correct in the previous part of the fixup routine, we can simply propagate
- around the information about which of these virtual phi nodes are really
- used, and set the NECESSARY flag accordingly.
- Note that we do the minimum here to ensure that we keep alive the phis that
- are actually used in the corrected SSA form. In particular, some of these
- phis may now have all of the same operand, and will be deleted by some
- other pass. */
-
-static void
-mark_really_necessary_kill_operand_phis (void)
-{
- basic_block bb;
- int i;
-
- /* Seed the worklist with the new virtual phi arguments and virtual
- uses */
- FOR_EACH_BB (bb)
- {
- block_stmt_iterator bsi;
- tree phi;
-
- for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
- {
- if (!is_gimple_reg (PHI_RESULT (phi)) && NECESSARY (phi))
- {
- for (i = 0; i < PHI_NUM_ARGS (phi); i++)
- mark_operand_necessary (PHI_ARG_DEF (phi, i), true);
- }
+ FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES)
+ mark_operand_necessary (use);
}
-
- for (bsi = bsi_last (bb); !bsi_end_p (bsi); bsi_prev (&bsi))
- {
- tree stmt = bsi_stmt (bsi);
-
- if (NECESSARY (stmt))
- {
- use_operand_p use_p;
- ssa_op_iter iter;
- FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
- SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS)
- {
- tree use = USE_FROM_PTR (use_p);
- mark_operand_necessary (use, true);
- }
- }
- }
- }
-
- /* Mark all virtual phis still in use as necessary, and all of their
- arguments that are phis as necessary. */
- while (VEC_length (tree, worklist) > 0)
- {
- tree use = VEC_pop (tree, worklist);
-
- for (i = 0; i < PHI_NUM_ARGS (use); i++)
- mark_operand_necessary (PHI_ARG_DEF (use, i), true);
}
}
-\f
-
-/* Eliminate unnecessary statements. Any instruction not marked as necessary
- contributes nothing to the program, and can be deleted. */
-
-static void
-eliminate_unnecessary_stmts (void)
-{
- basic_block bb;
- block_stmt_iterator i;
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "\nEliminating unnecessary statements:\n");
-
- clear_special_calls ();
- FOR_EACH_BB (bb)
- {
- /* Remove dead PHI nodes. */
- remove_dead_phis (bb);
- }
-
- FOR_EACH_BB (bb)
- {
- /* Remove dead statements. */
- for (i = bsi_start (bb); ! bsi_end_p (i) ; )
- {
- tree t = bsi_stmt (i);
-
- stats.total++;
-
- /* If `i' is not necessary then remove it. */
- if (! NECESSARY (t))
- remove_dead_stmt (&i, bb);
- else
- {
- tree call = get_call_expr_in (t);
- if (call)
- notice_special_calls (call);
- bsi_next (&i);
- }
- }
- }
- }
-\f
/* Remove dead PHI nodes from block BB. */
-static void
+static bool
remove_dead_phis (basic_block bb)
{
tree prev, phi;
+ bool something_changed = false;
prev = NULL_TREE;
phi = phi_nodes (bb);
{
tree next = PHI_CHAIN (phi);
+ something_changed = true;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Deleting : ");
fprintf (dump_file, "\n");
}
- remove_phi_node (phi, prev);
+ remove_phi_node (phi, prev, true);
stats.removed_phis++;
phi = next;
}
phi = PHI_CHAIN (phi);
}
}
+ return something_changed;
}
-\f
+
+
/* Remove dead statement pointed to by iterator I. Receives the basic block BB
containing I so that we don't have to look it up. */
remove_dead_stmt (block_stmt_iterator *i, basic_block bb)
{
tree t = bsi_stmt (*i);
- def_operand_p def_p;
-
- ssa_op_iter iter;
if (dump_file && (dump_flags & TDF_DETAILS))
{
nothing to the program, then we not only remove it, but we also change
the flow graph so that the current block will simply fall-thru to its
immediate post-dominator. The blocks we are circumventing will be
- removed by cleaup_tree_cfg if this change in the flow graph makes them
+ removed by cleanup_tree_cfg if this change in the flow graph makes them
unreachable. */
if (is_ctrl_stmt (t))
{
basic_block post_dom_bb;
/* The post dominance info has to be up-to-date. */
- gcc_assert (dom_computed[CDI_POST_DOMINATORS] == DOM_OK);
+ gcc_assert (dom_info_state (CDI_POST_DOMINATORS) == DOM_OK);
/* Get the immediate post dominator of bb. */
post_dom_bb = get_immediate_dominator (CDI_POST_DOMINATORS, bb);
- /* Some blocks don't have an immediate post dominator. This can happen
- for example with infinite loops. Removing an infinite loop is an
- inappropriate transformation anyway... */
- if (! post_dom_bb)
- {
- bsi_next (i);
- return;
- }
- /* If the post dominator block has PHI nodes, we might be unable
- to compute the right PHI args for them. Since the control
- statement is unnecessary, all edges can be regarded as
- equivalent, but we have to get rid of the condition, since it
- might reference a variable that was determined to be
- unnecessary and thus removed. */
- if (phi_nodes (post_dom_bb))
- post_dom_bb = EDGE_SUCC (bb, 0)->dest;
+ /* There are three particularly problematical cases.
+
+ 1. Blocks that do not have an immediate post dominator. This
+ can happen with infinite loops.
+
+ 2. Blocks that are only post dominated by the exit block. These
+ can also happen for infinite loops as we create fake edges
+ in the dominator tree.
+
+ 3. If the post dominator has PHI nodes we may be able to compute
+ the right PHI args for them.
+
+ In each of these cases we must remove the control statement
+ as it may reference SSA_NAMEs which are going to be removed and
+ we remove all but one outgoing edge from the block. */
+ if (! post_dom_bb
+ || post_dom_bb == EXIT_BLOCK_PTR
+ || phi_nodes (post_dom_bb))
+ ;
else
{
/* Redirect the first edge out of BB to reach POST_DOM_BB. */
redirect_edge_and_branch (EDGE_SUCC (bb, 0), post_dom_bb);
PENDING_STMT (EDGE_SUCC (bb, 0)) = NULL;
+
+ /* It is not sufficient to set cfg_altered below during edge
+ removal, in case BB has two successors and one of them
+ is POST_DOM_BB. */
+ cfg_altered = true;
}
EDGE_SUCC (bb, 0)->probability = REG_BR_PROB_BASE;
EDGE_SUCC (bb, 0)->count = bb->count;
not have TRUE/FALSE flags. */
EDGE_SUCC (bb, 0)->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);
- /* If the edge reaches any block other than the exit, then it is a
- fallthru edge; if it reaches the exit, then it is not a fallthru
- edge. */
- if (post_dom_bb != EXIT_BLOCK_PTR)
- EDGE_SUCC (bb, 0)->flags |= EDGE_FALLTHRU;
- else
- EDGE_SUCC (bb, 0)->flags &= ~EDGE_FALLTHRU;
+ /* The lone outgoing edge from BB will be a fallthru edge. */
+ EDGE_SUCC (bb, 0)->flags |= EDGE_FALLTHRU;
/* Remove the remaining the outgoing edges. */
while (!single_succ_p (bb))
}
}
- FOR_EACH_SSA_DEF_OPERAND (def_p, t, iter, SSA_OP_VIRTUAL_DEFS)
+ bsi_remove (i, true);
+ release_defs (t);
+}
+
+
+/* Eliminate unnecessary statements. Any instruction not marked as necessary
+ contributes nothing to the program, and can be deleted. */
+
+static bool
+eliminate_unnecessary_stmts (void)
+{
+ bool something_changed = false;
+ basic_block bb;
+ block_stmt_iterator i;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "\nEliminating unnecessary statements:\n");
+
+ clear_special_calls ();
+ FOR_EACH_BB (bb)
{
- tree def = DEF_FROM_PTR (def_p);
- mark_sym_for_renaming (SSA_NAME_VAR (def));
+ /* Remove dead PHI nodes. */
+ something_changed |= remove_dead_phis (bb);
}
- bsi_remove (i);
- release_defs (t);
+
+ FOR_EACH_BB (bb)
+ {
+ /* Remove dead statements. */
+ for (i = bsi_start (bb); ! bsi_end_p (i) ; )
+ {
+ tree t = bsi_stmt (i);
+
+ stats.total++;
+
+ /* If `i' is not necessary then remove it. */
+ if (! NECESSARY (t))
+ {
+ remove_dead_stmt (&i, bb);
+ something_changed = true;
+ }
+ else
+ {
+ tree call = get_call_expr_in (t);
+ if (call)
+ {
+ tree name;
+
+ /* When LHS of var = call (); is dead, simplify it into
+ call (); saving one operand. */
+ if (TREE_CODE (t) == GIMPLE_MODIFY_STMT
+ && (TREE_CODE ((name = GIMPLE_STMT_OPERAND (t, 0)))
+ == SSA_NAME)
+ && !TEST_BIT (processed, SSA_NAME_VERSION (name)))
+ {
+ tree oldlhs = GIMPLE_STMT_OPERAND (t, 0);
+ something_changed = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "Deleting LHS of call: ");
+ print_generic_stmt (dump_file, t, TDF_SLIM);
+ fprintf (dump_file, "\n");
+ }
+ push_stmt_changes (bsi_stmt_ptr (i));
+ TREE_BLOCK (call) = TREE_BLOCK (t);
+ bsi_replace (&i, call, false);
+ maybe_clean_or_replace_eh_stmt (t, call);
+ mark_symbols_for_renaming (call);
+ pop_stmt_changes (bsi_stmt_ptr (i));
+ release_ssa_name (oldlhs);
+ }
+ notice_special_calls (call);
+ }
+ bsi_next (&i);
+ }
+ }
+ }
+
+ return something_changed;
}
-\f
+
+
/* Print out removed statement statistics. */
static void
{
int i;
- control_dependence_map
- = xmalloc (last_basic_block * sizeof (bitmap));
+ control_dependence_map = XNEWVEC (bitmap, last_basic_block);
for (i = 0; i < last_basic_block; ++i)
control_dependence_map[i] = BITMAP_ALLOC (NULL);
as the last tree SSA pass, but keep this in mind when you
start experimenting with pass ordering. */
-static void
+static unsigned int
perform_tree_ssa_dce (bool aggressive)
{
struct edge_list *el = NULL;
+ bool something_changed = 0;
tree_dce_init (aggressive);
propagate_necessity (el);
- mark_really_necessary_kill_operand_phis ();
- eliminate_unnecessary_stmts ();
+ something_changed |= eliminate_unnecessary_stmts ();
+ something_changed |= cfg_altered;
- if (aggressive)
- free_dominance_info (CDI_POST_DOMINATORS);
+ /* We do not update postdominators, so free them unconditionally. */
+ free_dominance_info (CDI_POST_DOMINATORS);
/* If we removed paths in the CFG, then we need to update
dominators as well. I haven't investigated the possibility
tree_dce_done (aggressive);
free_edge_list (el);
+
+ if (something_changed)
+ return (TODO_update_ssa | TODO_cleanup_cfg | TODO_ggc_collect
+ | TODO_remove_unused_locals);
+ else
+ return 0;
}
/* Pass entry points. */
-void
+static unsigned int
tree_ssa_dce (void)
{
- perform_tree_ssa_dce (/*aggressive=*/false);
+ return perform_tree_ssa_dce (/*aggressive=*/false);
}
-static void
+static unsigned int
+tree_ssa_dce_loop (void)
+{
+ unsigned int todo;
+ todo = perform_tree_ssa_dce (/*aggressive=*/false);
+ if (todo)
+ {
+ free_numbers_of_iterations_estimates ();
+ scev_reset ();
+ }
+ return todo;
+}
+
+static unsigned int
tree_ssa_cd_dce (void)
{
- perform_tree_ssa_dce (/*aggressive=*/optimize >= 2);
+ return perform_tree_ssa_dce (/*aggressive=*/optimize >= 2);
}
static bool
NULL, /* next */
0, /* static_pass_number */
TV_TREE_DCE, /* tv_id */
- PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
+ PROP_cfg | PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_dump_func | TODO_verify_ssa, /* todo_flags_finish */
+ 0 /* letter */
+};
+
+struct tree_opt_pass pass_dce_loop =
+{
+ "dceloop", /* name */
+ gate_dce, /* gate */
+ tree_ssa_dce_loop, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_TREE_DCE, /* tv_id */
+ PROP_cfg | PROP_ssa, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_dump_func
- | TODO_update_ssa_no_phi
- | TODO_cleanup_cfg
- | TODO_ggc_collect
- | TODO_verify_ssa, /* todo_flags_finish */
+ TODO_dump_func | TODO_verify_ssa, /* todo_flags_finish */
0 /* letter */
};
NULL, /* next */
0, /* static_pass_number */
TV_TREE_CD_DCE, /* tv_id */
- PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
+ PROP_cfg | PROP_ssa, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_dump_func
- | TODO_update_ssa_no_phi
- | TODO_cleanup_cfg
- | TODO_ggc_collect
- | TODO_verify_ssa
- | TODO_verify_flow, /* todo_flags_finish */
+ TODO_dump_func | TODO_verify_ssa
+ | TODO_verify_flow, /* todo_flags_finish */
0 /* letter */
};
-
OSDN Git Service
