EXECUTE_IF_SET_IN_BITMAP (control_dependence_map[(N)], 0, \
(EDGE_NUMBER), (BI))
-/* 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
/* 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)
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. */
}
}
-/* 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->base.asm_written_flag
/* If STMT is not already marked necessary, mark it, and add it to the
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.
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)
-{
- 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);
- }
-}
-\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);
}
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))
{
statement (V_MAY_DEF operands allow us to follow def-def
links). */
- FOR_EACH_SSA_TREE_OPERAND (use, i, iter, SSA_OP_ALL_USES)
+ FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES)
mark_operand_necessary (use, false);
}
}
}
-\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
fprintf (dump_file, "\n");
}
- remove_phi_node (phi, prev);
+ remove_phi_node (phi, prev, true);
stats.removed_phis++;
phi = next;
}
}
}
}
-\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. */
bsi_remove (i, true);
release_defs (t);
}
-\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);
+ }
+ }
+ }
+}
+
+
/* Print out removed statement statistics. */
static void
OSDN Git Service
