tree-ssa-dce.c File Reference

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "ggc.h"
#include "rtl.h"
#include "tm_p.h"
#include "hard-reg-set.h"
#include "obstack.h"
#include "basic-block.h"
#include "tree.h"
#include "diagnostic.h"
#include "tree-flow.h"
#include "tree-gimple.h"
#include "tree-dump.h"
#include "tree-pass.h"
#include "timevar.h"
#include "flags.h"
#include "cfgloop.h"
#include "tree-scalar-evolution.h"

Include dependency graph for tree-ssa-dce.c:

Go to the source code of this file.

Data Structures
struct	stmt_stats
Defines
#define	EXECUTE_IF_CONTROL_DEPENDENT(BI, N, EDGE_NUMBER)
#define	NECESSARY(stmt)   stmt->common.asm_written_flag
Functions
static	VEC (static inline void mark_stmt_necessary(tree, heap)
static void	clear_control_dependence_bitmap ()
static void	find_all_control_dependences ()
static void	find_control_dependence ()
static basic_block	find_pdom ()
static void	mark_stmt_necessary ()
static void	mark_operand_necessary ()
static void	mark_stmt_if_obviously_necessary ()
static void	find_obviously_necessary_stmts ()
static void	mark_control_dependent_edges_necessary ()
static void	propagate_necessity ()
static void	mark_really_necessary_kill_operand_phis ()
static void	eliminate_unnecessary_stmts ()
static void	remove_dead_phis ()
static void	remove_dead_stmt ()
static void	print_stats ()
static void	tree_dce_init ()
static void	tree_dce_done ()
static void	perform_tree_ssa_dce ()
static unsigned int	tree_ssa_dce ()
static unsigned int	tree_ssa_dce_loop ()
static unsigned int	tree_ssa_cd_dce ()
static bool	gate_dce ()
Variables
static struct stmt_stats	stats
tree_opt_pass	pass_dce
tree_opt_pass	pass_dce_loop
tree_opt_pass	pass_cd_dce

---

Define Documentation

#define EXECUTE_IF_CONTROL_DEPENDENT (  BI, N, EDGE_NUMBER   )

Value: EXECUTE_IF_SET_IN_BITMAP (control_dependence_map[(N)], 0, \ (EDGE_NUMBER), (BI)) Referenced by mark_control_dependent_edges_necessary().

#define NECESSARY (  stmt   )     stmt->common.asm_written_flag

Definition at line 219 of file tree-ssa-dce.c. Referenced by eliminate(), eliminate_unnecessary_stmts(), find_obviously_necessary_stmts(), insert_extra_phis(), insert_fake_stores(), mark_operand_necessary(), mark_really_necessary_kill_operand_phis(), mark_stmt_necessary(), realify_fake_stores(), remove_dead_inserted_code(), and remove_dead_phis().

---

Function Documentation

static void clear_control_dependence_bitmap (   )  [inline, static]

Clear all control dependences for block BB. Definition at line 151 of file tree-ssa-dce.c. { bitmap_clear (control_dependence_map[bb->index]); }

static void eliminate_unnecessary_stmts (   )  [static]

Eliminate unnecessary statements. Any instruction not marked as necessary contributes nothing to the program, and can be deleted. Definition at line 625 of file tree-ssa-dce.c. References bsi_end_p(), bsi_next(), bsi_start, bsi_stmt(), clear_special_calls(), dump_file, dump_flags, get_call_expr_in(), NECESSARY, notice_special_calls(), remove_dead_phis(), remove_dead_stmt(), stats, TDF_DETAILS, and stmt_stats::total. Referenced by perform_tree_ssa_dce(). { 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); } } } }

static void find_all_control_dependences (   )  [static]

Record all blocks' control dependences on all edges in the edge list EL, ala Morgan, Section 3.6. Definition at line 160 of file tree-ssa-dce.c. References find_control_dependence(). Referenced by perform_tree_ssa_dce(). { int i; for (i = 0; i < NUM_EDGES (el); ++i) find_control_dependence (el, i); }

static void find_control_dependence (   )  [static]

Determine all blocks' control dependences on the given edge with edge_list EL index EDGE_INDEX, ala Morgan, Section 3.6. Definition at line 172 of file tree-ssa-dce.c. References find_pdom(). Referenced by find_all_control_dependences(). { basic_block current_block; basic_block ending_block; 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 = single_succ (ENTRY_BLOCK_PTR); else ending_block = find_pdom (INDEX_EDGE_PRED_BB (el, edge_index)); for (current_block = INDEX_EDGE_SUCC_BB (el, edge_index); current_block != ending_block && current_block != EXIT_BLOCK_PTR; current_block = find_pdom (current_block)) { edge e = INDEX_EDGE (el, edge_index); /* For abnormal edges, we don't make current_block control dependent because instructions that throw are always necessary anyway. */ if (e->flags & EDGE_ABNORMAL) continue; set_control_dependence_map_bit (current_block, edge_index); } }

static void find_obviously_necessary_stmts (   )  [static]

Find obviously necessary statements. These are things like most function calls, and stores to file level variables. If EL is NULL, control statements are conservatively marked as necessary. Otherwise it contains the list of edges used by control dependence analysis. Definition at line 386 of file tree-ssa-dce.c. References bsi_end_p(), bsi_next(), bsi_start, bsi_stmt(), is_gimple_reg(), is_global_var(), mark_stmt_if_obviously_necessary(), mark_stmt_necessary(), NECESSARY, PHI_CHAIN, phi_nodes(), PHI_RESULT, and SSA_NAME_VAR. Referenced by perform_tree_ssa_dce(). { basic_block bb; block_stmt_iterator i; edge e; FOR_EACH_BB (bb) { tree phi; /* Check any PHI nodes in the block. */ 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); } /* Check all statements in the block. */ for (i = bsi_start (bb); ! bsi_end_p (i); bsi_next (&i)) { tree stmt = bsi_stmt (i); NECESSARY (stmt) = 0; mark_stmt_if_obviously_necessary (stmt, el != NULL); } } if (el) { /* Prevent the loops from being removed. We must keep the infinite loops, and we currently do not have a means to recognize the finite ones. */ FOR_EACH_BB (bb) { edge_iterator ei; FOR_EACH_EDGE (e, ei, bb->succs) if (e->flags & EDGE_DFS_BACK) mark_control_dependent_edges_necessary (e->dest, el); } } }

static basic_block find_pdom (   )  [inline, static]

Find the immediate postdominator PDOM of the specified basic block BLOCK. This function is necessary because some blocks have negative numbers. Definition at line 204 of file tree-ssa-dce.c. Referenced by find_control_dependence(). { gcc_assert (block != ENTRY_BLOCK_PTR); 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; } }

static bool gate_dce (   )  [static]

Definition at line 949 of file tree-ssa-dce.c. { return flag_tree_dce != 0; }

static void mark_control_dependent_edges_necessary (   )  [static]

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. Definition at line 439 of file tree-ssa-dce.c. References EXECUTE_IF_CONTROL_DEPENDENT, is_ctrl_stmt(), last_stmt(), and mark_stmt_necessary(). Referenced by propagate_necessity(). { 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); } }

static void mark_operand_necessary (   )  [inline, static]

Mark the statement defining operand OP as necessary. PHIONLY is true if we should only mark it necessary if it is a phi node. Definition at line 248 of file tree-ssa-dce.c. References IS_EMPTY_STMT, NECESSARY, SSA_NAME_DEF_STMT, SSA_NAME_VERSION, and TREE_CODE. Referenced by mark_really_necessary_kill_operand_phis(), and propagate_necessity(). { tree stmt; int ver; gcc_assert (op); ver = SSA_NAME_VERSION (op); if (TEST_BIT (processed, ver)) return; SET_BIT (processed, ver); stmt = SSA_NAME_DEF_STMT (op); gcc_assert (stmt); if (NECESSARY (stmt) || IS_EMPTY_STMT (stmt) || (phionly && TREE_CODE (stmt) != PHI_NODE)) return; NECESSARY (stmt) = 1; VEC_safe_push (tree, heap, worklist, stmt); }

static void mark_really_necessary_kill_operand_phis (   )  [static]

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. Definition at line 568 of file tree-ssa-dce.c. References bsi_end_p(), bsi_last, bsi_prev(), bsi_stmt(), FOR_EACH_SSA_USE_OPERAND, is_gimple_reg(), mark_operand_necessary(), NECESSARY, PHI_ARG_DEF, PHI_CHAIN, phi_nodes(), PHI_NUM_ARGS, PHI_RESULT, SSA_OP_VIRTUAL_KILLS, SSA_OP_VIRTUAL_USES, and USE_FROM_PTR. Referenced by perform_tree_ssa_dce(). { 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 (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); } }

static void mark_stmt_if_obviously_necessary (   )  [static]

Mark STMT as necessary if it obviously is. Add it to the worklist if it can make other statements necessary. If AGGRESSIVE is false, control statements are conservatively marked as necessary. Definition at line 280 of file tree-ssa-dce.c. References bb_for_stmt(), get_call_expr_in(), stmt_ann_d::has_volatile_ops, is_ctrl_altering_stmt(), is_hidden_global_store(), mark_stmt_necessary(), simple_goto_p(), stmt_ann, TREE_CODE, tree_could_throw_p(), TREE_OPERAND, and TREE_SIDE_EFFECTS. Referenced by find_obviously_necessary_stmts(). { stmt_ann_t ann; tree op; /* With non-call exceptions, we have to assume that all statements could throw. If a statement may throw, it is inherently necessary. */ if (flag_non_call_exceptions && tree_could_throw_p (stmt)) { mark_stmt_necessary (stmt, true); return; } /* Statements that are implicitly live. Most function calls, asm and return statements are required. Labels and BIND_EXPR nodes are kept because they are control flow, and we have no way of knowing whether they can be removed. DCE can eliminate all the other statements in a block, and CFG can then remove the block and labels. */ switch (TREE_CODE (stmt)) { case BIND_EXPR: case LABEL_EXPR: case CASE_LABEL_EXPR: mark_stmt_necessary (stmt, false); return; case ASM_EXPR: case RESX_EXPR: case RETURN_EXPR: mark_stmt_necessary (stmt, true); return; case CALL_EXPR: /* Most, but not all function calls are required. Function calls that produce no result and have no side effects (i.e. const pure functions) are unnecessary. */ if (TREE_SIDE_EFFECTS (stmt)) mark_stmt_necessary (stmt, true); return; case MODIFY_EXPR: op = get_call_expr_in (stmt); if (op && TREE_SIDE_EFFECTS (op)) { mark_stmt_necessary (stmt, true); return; } /* 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) { mark_stmt_necessary (stmt, true); return; } break; case GOTO_EXPR: gcc_assert (!simple_goto_p (stmt)); mark_stmt_necessary (stmt, true); return; case COND_EXPR: gcc_assert (EDGE_COUNT (bb_for_stmt (stmt)->succs) == 2); /* Fall through. */ case SWITCH_EXPR: if (! aggressive) mark_stmt_necessary (stmt, true); break; default: break; } ann = stmt_ann (stmt); /* If the statement has volatile operands, it needs to be preserved. Same for statements that can alter control flow in unpredictable ways. */ if (ann->has_volatile_ops || is_ctrl_altering_stmt (stmt)) { mark_stmt_necessary (stmt, true); return; } if (is_hidden_global_store (stmt)) { mark_stmt_necessary (stmt, true); return; } return; }

static void mark_stmt_necessary (   )  [inline, static]

If STMT is not already marked necessary, mark it, and add it to the worklist if ADD_TO_WORKLIST is true. Definition at line 224 of file tree-ssa-dce.c. References DECL_P, dump_file, dump_flags, NECESSARY, print_generic_stmt(), TDF_DETAILS, and TDF_SLIM. Referenced by find_obviously_necessary_stmts(), mark_control_dependent_edges_necessary(), and mark_stmt_if_obviously_necessary(). { gcc_assert (stmt); gcc_assert (!DECL_P (stmt)); if (NECESSARY (stmt)) return; if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Marking useful stmt: "); print_generic_stmt (dump_file, stmt, TDF_SLIM); fprintf (dump_file, "\n"); } NECESSARY (stmt) = 1; if (add_to_worklist) VEC_safe_push (tree, heap, worklist, stmt); }

static void perform_tree_ssa_dce (   )  [static]

Main routine to eliminate dead code. AGGRESSIVE controls the aggressiveness of the algorithm. In conservative mode, we ignore control dependence and simply declare all but the most trivially dead branches necessary. This mode is fast. In aggressive mode, control dependences are taken into account, which results in more dead code elimination, but at the cost of some time. FIXME: Aggressive mode before PRE doesn't work currently because the dominance info is not invalidated after DCE1. This is not an issue right now because we only run aggressive DCE as the last tree SSA pass, but keep this in mind when you start experimenting with pass ordering. Definition at line 878 of file tree-ssa-dce.c. References dump_file, eliminate_unnecessary_stmts(), find_all_control_dependences(), find_obviously_necessary_stmts(), mark_really_necessary_kill_operand_phis(), print_stats(), propagate_necessity(), tree_dce_done(), and tree_dce_init(). Referenced by tree_ssa_cd_dce(), tree_ssa_dce(), and tree_ssa_dce_loop(). { struct edge_list *el = NULL; tree_dce_init (aggressive); if (aggressive) { /* Compute control dependence. */ timevar_push (TV_CONTROL_DEPENDENCES); calculate_dominance_info (CDI_POST_DOMINATORS); el = create_edge_list (); find_all_control_dependences (el); timevar_pop (TV_CONTROL_DEPENDENCES); visited_control_parents = sbitmap_alloc (last_basic_block); sbitmap_zero (visited_control_parents); mark_dfs_back_edges (); } find_obviously_necessary_stmts (el); propagate_necessity (el); mark_really_necessary_kill_operand_phis (); eliminate_unnecessary_stmts (); if (aggressive) 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 of incrementally updating dominators. */ if (cfg_altered) free_dominance_info (CDI_DOMINATORS); /* Debugging dumps. */ if (dump_file) print_stats (); tree_dce_done (aggressive); free_edge_list (el); }

static void print_stats (   )  [static]

Print out removed statement statistics. Definition at line 795 of file tree-ssa-dce.c. References dump_file, dump_flags, stmt_stats::removed, stmt_stats::removed_phis, stats, TDF_DETAILS, TDF_STATS, stmt_stats::total, and stmt_stats::total_phis. Referenced by perform_tree_ssa_dce(). { if (dump_file && (dump_flags & (TDF_STATS|TDF_DETAILS))) { float percg; percg = ((float) stats.removed / (float) stats.total) * 100; fprintf (dump_file, "Removed %d of %d statements (%d%%)\n", stats.removed, stats.total, (int) percg); if (stats.total_phis == 0) percg = 0; else percg = ((float) stats.removed_phis / (float) stats.total_phis) * 100; fprintf (dump_file, "Removed %d of %d PHI nodes (%d%%)\n", stats.removed_phis, stats.total_phis, (int) percg); } }

static void propagate_necessity (   )  [static]

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. Definition at line 471 of file tree-ssa-dce.c. References bb_for_stmt(), dump_file, dump_flags, mark_control_dependent_edges_necessary(), mark_operand_necessary(), PHI_ARG_DEF, PHI_ARG_EDGE, PHI_NUM_ARGS, print_generic_stmt(), TDF_DETAILS, TDF_SLIM, and TREE_CODE. Referenced by perform_tree_ssa_dce(). { tree i; bool aggressive = (el ? true : false); if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "\nProcessing worklist:\n"); while (VEC_length (tree, worklist) > 0) { /* Take `i' from worklist. */ i = VEC_pop (tree, worklist); if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "processing: "); print_generic_stmt (dump_file, i, 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 already done so. */ basic_block bb = bb_for_stmt (i); if (bb != ENTRY_BLOCK_PTR && ! TEST_BIT (visited_control_parents, bb->index)) { SET_BIT (visited_control_parents, bb->index); mark_control_dependent_edges_necessary (bb, el); } } if (TREE_CODE (i) == PHI_NODE) { /* PHI nodes are somewhat special in that each PHI alternative has data and control dependencies. All the statements feeding the PHI node's arguments are always necessary. In aggressive mode, we also consider the control dependent edges leading to the predecessor block associated with each PHI alternative as necessary. */ int k; for (k = 0; k < PHI_NUM_ARGS (i); k++) { tree arg = PHI_ARG_DEF (i, k); if (TREE_CODE (arg) == SSA_NAME) mark_operand_necessary (arg, false); } if (aggressive) { for (k = 0; k < PHI_NUM_ARGS (i); k++) { basic_block arg_bb = PHI_ARG_EDGE (i, k)->src; if (arg_bb != ENTRY_BLOCK_PTR && ! TEST_BIT (visited_control_parents, arg_bb->index)) { SET_BIT (visited_control_parents, arg_bb->index); mark_control_dependent_edges_necessary (arg_bb, el); } } } } 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 represent potential definitions that may reach this statement (V_MAY_DEF operands allow us to follow def-def links). */ FOR_EACH_SSA_TREE_OPERAND (use, i, iter, SSA_OP_ALL_USES) mark_operand_necessary (use, false); } } }

static void remove_dead_phis (   )  [static]

Remove dead PHI nodes from block BB. Definition at line 666 of file tree-ssa-dce.c. References dump_file, dump_flags, NECESSARY, NULL_TREE, PHI_CHAIN, phi_nodes(), print_generic_stmt(), remove_phi_node(), stmt_stats::removed_phis, stats, TDF_DETAILS, TDF_SLIM, and stmt_stats::total_phis. Referenced by eliminate_unnecessary_stmts(). { tree prev, phi; prev = NULL_TREE; phi = phi_nodes (bb); while (phi) { stats.total_phis++; if (! NECESSARY (phi)) { tree next = PHI_CHAIN (phi); if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Deleting : "); print_generic_stmt (dump_file, phi, TDF_SLIM); fprintf (dump_file, "\n"); } remove_phi_node (phi, prev); stats.removed_phis++; phi = next; } else { prev = phi; phi = PHI_CHAIN (phi); } } }

static void remove_dead_stmt (   )  [static]

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. Definition at line 703 of file tree-ssa-dce.c. References bsi_remove(), bsi_stmt(), DEF_FROM_PTR, dump_file, dump_flags, FOR_EACH_SSA_DEF_OPERAND, is_ctrl_stmt(), mark_sym_for_renaming(), PENDING_STMT, phi_nodes(), print_generic_stmt(), release_defs(), stmt_stats::removed, SSA_NAME_VAR, SSA_OP_VIRTUAL_DEFS, stats, TDF_DETAILS, and TDF_SLIM. Referenced by eliminate_unnecessary_stmts(). { tree t = bsi_stmt (*i); def_operand_p def_p; ssa_op_iter iter; if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Deleting : "); print_generic_stmt (dump_file, t, TDF_SLIM); fprintf (dump_file, "\n"); } stats.removed++; /* If we have determined that a conditional branch statement contributes 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 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); /* Get the immediate post dominator of bb. */ post_dom_bb = get_immediate_dominator (CDI_POST_DOMINATORS, bb); /* 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; } EDGE_SUCC (bb, 0)->probability = REG_BR_PROB_BASE; EDGE_SUCC (bb, 0)->count = bb->count; /* The edge is no longer associated with a conditional, so it does not have TRUE/FALSE flags. */ EDGE_SUCC (bb, 0)->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE); /* 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)) { /* FIXME. When we remove the edge, we modify the CFG, which in turn modifies the dominator and post-dominator tree. Is it safe to postpone recomputing the dominator and post-dominator tree until the end of this pass given that the post-dominators are used above? */ cfg_altered = true; remove_edge (EDGE_SUCC (bb, 1)); } } FOR_EACH_SSA_DEF_OPERAND (def_p, t, iter, SSA_OP_VIRTUAL_DEFS) { tree def = DEF_FROM_PTR (def_p); mark_sym_for_renaming (SSA_NAME_VAR (def)); } bsi_remove (i, true); release_defs (t); }

static void tree_dce_done (   )  [static]

Cleanup after this pass. Definition at line 844 of file tree-ssa-dce.c. Referenced by perform_tree_ssa_dce(). { if (aggressive) { int i; for (i = 0; i < last_basic_block; ++i) BITMAP_FREE (control_dependence_map[i]); free (control_dependence_map); sbitmap_free (visited_control_parents); sbitmap_free (last_stmt_necessary); } sbitmap_free (processed); VEC_free (tree, heap, worklist); }

static void tree_dce_init (   )  [static]

Initialization for this pass. Set up the used data structures. Definition at line 818 of file tree-ssa-dce.c. References num_ssa_names, and stats. Referenced by perform_tree_ssa_dce(). { memset ((void *) &stats, 0, sizeof (stats)); if (aggressive) { int i; control_dependence_map = XNEWVEC (bitmap, last_basic_block); for (i = 0; i < last_basic_block; ++i) control_dependence_map[i] = BITMAP_ALLOC (NULL); last_stmt_necessary = sbitmap_alloc (last_basic_block); sbitmap_zero (last_stmt_necessary); } processed = sbitmap_alloc (num_ssa_names + 1); sbitmap_zero (processed); worklist = VEC_alloc (tree, heap, 64); cfg_altered = false; }

static unsigned int tree_ssa_cd_dce (   )  [static]

Definition at line 942 of file tree-ssa-dce.c. References perform_tree_ssa_dce(). { perform_tree_ssa_dce (/*aggressive=*/optimize >= 2); return 0; }

static unsigned int tree_ssa_dce (   )  [static]

Pass entry points. Definition at line 926 of file tree-ssa-dce.c. References perform_tree_ssa_dce(). { perform_tree_ssa_dce (/*aggressive=*/false); return 0; }

static unsigned int tree_ssa_dce_loop (   )  [static]

Definition at line 933 of file tree-ssa-dce.c. References current_loops, free_numbers_of_iterations_estimates(), perform_tree_ssa_dce(), and scev_reset(). { perform_tree_ssa_dce (/*aggressive=*/false); free_numbers_of_iterations_estimates (current_loops); scev_reset (); return 0; }

static VEC (  static inline void mark_stmt_necessary (  tree, heap  )  [static]

Indicate block BB is control dependent on an edge with index EDGE_INDEX. Definition at line 78 of file tree-ssa-dce.c. { if (bb == ENTRY_BLOCK_PTR) return; gcc_assert (bb != EXIT_BLOCK_PTR); bitmap_set_bit (control_dependence_map[bb->index], edge_index); }

---

Variable Documentation

struct tree_opt_pass pass_cd_dce

Initial value: { "cddce", gate_dce, tree_ssa_cd_dce, NULL, NULL, 0, TV_TREE_CD_DCE, PROP_cfg | PROP_ssa | PROP_alias, 0, 0, 0, TODO_dump_func | TODO_update_ssa | TODO_cleanup_cfg | TODO_ggc_collect | TODO_verify_ssa | TODO_verify_flow, 0 } Definition at line 996 of file tree-ssa-dce.c.

struct tree_opt_pass pass_dce

Initial value: { "dce", gate_dce, tree_ssa_dce, NULL, NULL, 0, TV_TREE_DCE, PROP_cfg | PROP_ssa | PROP_alias, 0, 0, 0, TODO_dump_func | TODO_update_ssa | TODO_cleanup_cfg | TODO_ggc_collect | TODO_verify_ssa | TODO_remove_unused_locals, 0 } Definition at line 954 of file tree-ssa-dce.c.

struct tree_opt_pass pass_dce_loop

Initial value: { "dceloop", gate_dce, tree_ssa_dce_loop, NULL, NULL, 0, TV_TREE_DCE, PROP_cfg | PROP_ssa | PROP_alias, 0, 0, 0, TODO_dump_func | TODO_update_ssa | TODO_cleanup_cfg | TODO_verify_ssa, 0 } Definition at line 976 of file tree-ssa-dce.c.

struct stmt_stats stats [static]

These RTL headers are needed for basic-block.h. Referenced by add_graph_edge(), analyze_scalar_evolution_for_all_loop_phi_nodes(), create_function_info_for(), create_variable_info_for(), dump_chrecs_stats(), dump_sa_points_to_info(), eliminate_unnecessary_stmts(), gather_chrec_stats(), gather_stats_on_scev_database(), init_alias_vars(), int_add_graph_edge(), perform_var_substitution(), print_stats(), process_unification_queue(), remove_dead_phis(), remove_dead_stmt(), reset_chrecs_counters(), solve_graph(), and tree_dce_init().

---