From 9b3b55a10516cf15d37f39ac473ad86b6ae3c3ce Mon Sep 17 00:00:00 2001 From: Diego Novillo Date: Mon, 11 Dec 2006 17:50:53 +0000 Subject: [PATCH] * tree-scalar-evolution.c (scev_const_prop): * tree-phinodes.c (remove_phi_node): Add argument RELEASE_LHS_P. If given, release the SSA name on the LHS of the PHI node. Update all users. * tree-ssa-dce.c: Remove forward declarations for static functions. Re-arrange functions bodies as needed. (find_obviously_necessary_stmts): Never mark PHI nodes as obviously necessary. From-SVN: r119740 --- gcc/ChangeLog | 12 ++ gcc/lambda-code.c | 8 +- gcc/tree-cfg.c | 5 +- gcc/tree-flow.h | 2 +- gcc/tree-outof-ssa.c | 6 +- gcc/tree-phinodes.c | 17 +- gcc/tree-scalar-evolution.c | 12 +- gcc/tree-ssa-dce.c | 305 +++++++++++++++++------------------- gcc/tree-ssa-dom.c | 2 +- gcc/tree-ssa-loop-ivopts.c | 7 +- gcc/tree-ssa-pre.c | 2 +- 11 files changed, 181 insertions(+), 197 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index bc160d8b87a..9b4ad415287 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,15 @@ +2006-12-11 Diego Novillo + + * tree-scalar-evolution.c (scev_const_prop): + * tree-phinodes.c (remove_phi_node): Add argument + RELEASE_LHS_P. If given, release the SSA name on the LHS of + the PHI node. + Update all users. + * tree-ssa-dce.c: Remove forward declarations for static + functions. Re-arrange functions bodies as needed. + (find_obviously_necessary_stmts): Never mark PHI nodes as + obviously necessary. + 2006-12-11 Carlos O'Donell * config/arm/elf.h (MAX_OFILE_ALIGNMENT): Remove definition. diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c index 0eb3286503b..8972e50b362 100644 --- a/gcc/lambda-code.c +++ b/gcc/lambda-code.c @@ -2474,13 +2474,9 @@ perfect_nestify (struct loop *loop, } e = redirect_edge_and_branch (single_succ_edge (preheaderbb), headerbb); - /* Remove the exit phis from the old basic block. Make sure to set - PHI_RESULT to null so it doesn't get released. */ + /* Remove the exit phis from the old basic block. */ while (phi_nodes (olddest) != NULL) - { - SET_PHI_RESULT (phi_nodes (olddest), NULL); - remove_phi_node (phi_nodes (olddest), NULL); - } + remove_phi_node (phi_nodes (olddest), NULL, false); /* and add them back to the new basic block. */ while (VEC_length (tree, phis) != 0) diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 59a32ea6fff..f738d409d53 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -1333,13 +1333,12 @@ tree_merge_blocks (basic_block a, basic_block b) appear as arguments of the phi nodes. */ copy = build2_gimple (GIMPLE_MODIFY_STMT, def, use); bsi_insert_after (&bsi, copy, BSI_NEW_STMT); - SET_PHI_RESULT (phi, NULL_TREE); SSA_NAME_DEF_STMT (def) = copy; } else replace_uses_by (def, use); - remove_phi_node (phi, NULL); + remove_phi_node (phi, NULL, false); } /* Ensure that B follows A. */ @@ -1970,7 +1969,7 @@ remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb) while (phi) { tree next = PHI_CHAIN (phi); - remove_phi_node (phi, NULL_TREE); + remove_phi_node (phi, NULL_TREE, true); phi = next; } diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index bb6b4ae2113..aa36ad4940d 100644 --- a/gcc/tree-flow.h +++ b/gcc/tree-flow.h @@ -687,7 +687,7 @@ extern void reserve_phi_args_for_new_edge (basic_block); extern tree create_phi_node (tree, basic_block); extern void add_phi_arg (tree, tree, edge); extern void remove_phi_args (edge); -extern void remove_phi_node (tree, tree); +extern void remove_phi_node (tree, tree, bool); extern tree phi_reverse (tree); /* In gimple-low.c */ diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c index f591eb5ed97..8197f1ac9b8 100644 --- a/gcc/tree-outof-ssa.c +++ b/gcc/tree-outof-ssa.c @@ -639,7 +639,7 @@ eliminate_virtual_phis (void) } } #endif - remove_phi_node (phi, NULL_TREE); + remove_phi_node (phi, NULL_TREE, true); } } } @@ -1170,13 +1170,13 @@ remove_ssa_form (bool perform_ter) if (values) free (values); - /* Remove phi nodes which have been translated back to real variables. */ + /* Remove PHI nodes which have been translated back to real variables. */ FOR_EACH_BB (bb) { for (phi = phi_nodes (bb); phi; phi = next) { next = PHI_CHAIN (phi); - remove_phi_node (phi, NULL_TREE); + remove_phi_node (phi, NULL_TREE, true); } } diff --git a/gcc/tree-phinodes.c b/gcc/tree-phinodes.c index 98b011f89e6..344770e700a 100644 --- a/gcc/tree-phinodes.c +++ b/gcc/tree-phinodes.c @@ -233,6 +233,7 @@ make_phi_node (tree var, int len) imm->next = NULL; imm->stmt = phi; } + return phi; } @@ -301,7 +302,6 @@ resize_phi_node (tree *phi, int len) imm->stmt = new_phi; } - *phi = new_phi; } @@ -343,6 +343,7 @@ reserve_phi_args_for_new_edge (basic_block bb) } } + /* Create a new PHI node for variable VAR at basic block BB. */ tree @@ -362,6 +363,7 @@ create_phi_node (tree var, basic_block bb) return phi; } + /* Add a new argument to PHI node PHI. DEF is the incoming reaching definition and E is the edge through which DEF reaches PHI. The new argument is added at the end of the argument list. @@ -394,6 +396,7 @@ add_phi_arg (tree phi, tree def, edge e) SET_PHI_ARG_DEF (phi, e->dest_idx, def); } + /* Remove the Ith argument from PHI's argument list. This routine implements removal by swapping the last alternative with the alternative we want to delete and then shrinking the vector, which @@ -406,7 +409,6 @@ remove_phi_arg_num (tree phi, int i) gcc_assert (i < num_elem); - /* Delink the item which is being removed. */ delink_imm_use (&(PHI_ARG_IMM_USE_NODE (phi, i))); @@ -428,6 +430,7 @@ remove_phi_arg_num (tree phi, int i) PHI_NUM_ARGS (phi)--; } + /* Remove all PHI arguments associated with edge E. */ void @@ -439,11 +442,14 @@ remove_phi_args (edge e) remove_phi_arg_num (phi, e->dest_idx); } + /* Remove PHI node PHI from basic block BB. If PREV is non-NULL, it is - used as the node immediately before PHI in the linked list. */ + used as the node immediately before PHI in the linked list. If + RELEASE_LHS_P is true, the LHS of this PHI node is released into + the free pool of SSA names. */ void -remove_phi_node (tree phi, tree prev) +remove_phi_node (tree phi, tree prev, bool release_lhs_p) { tree *loc; @@ -465,7 +471,8 @@ remove_phi_node (tree phi, tree prev) /* If we are deleting the PHI node, then we should release the SSA_NAME node so that it can be reused. */ release_phi_node (phi); - release_ssa_name (PHI_RESULT (phi)); + if (release_lhs_p) + release_ssa_name (PHI_RESULT (phi)); } diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c index 10d5da5d271..bd47befd679 100644 --- a/gcc/tree-scalar-evolution.c +++ b/gcc/tree-scalar-evolution.c @@ -2929,8 +2929,9 @@ scev_const_prop (void) } } - /* Remove the ssa names that were replaced by constants. We do not remove them - directly in the previous cycle, since this invalidates scev cache. */ + /* Remove the ssa names that were replaced by constants. We do not + remove them directly in the previous cycle, since this + invalidates scev cache. */ if (ssa_names_to_remove) { bitmap_iterator bi; @@ -2941,7 +2942,7 @@ scev_const_prop (void) phi = SSA_NAME_DEF_STMT (name); gcc_assert (TREE_CODE (phi) == PHI_NODE); - remove_phi_node (phi, NULL); + remove_phi_node (phi, NULL, true); } BITMAP_FREE (ssa_names_to_remove); @@ -2998,11 +2999,10 @@ scev_const_prop (void) || contains_abnormal_ssa_name_p (def)) continue; - /* Eliminate the phi node and replace it by a computation outside + /* Eliminate the PHI node and replace it by a computation outside the loop. */ def = unshare_expr (def); - SET_PHI_RESULT (phi, NULL_TREE); - remove_phi_node (phi, NULL_TREE); + remove_phi_node (phi, NULL_TREE, false); ass = build2 (GIMPLE_MODIFY_STMT, void_type_node, rslt, NULL_TREE); SSA_NAME_DEF_STMT (rslt) = ass; diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c index 3b205629e33..16ff4a30d1f 100644 --- a/gcc/tree-ssa-dce.c +++ b/gcc/tree-ssa-dce.c @@ -112,30 +112,7 @@ static bool cfg_altered; 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); - /* 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) @@ -153,18 +130,27 @@ 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. */ @@ -197,25 +183,20 @@ find_control_dependence (struct edge_list *el, int 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); } - + + #define NECESSARY(stmt) stmt->base.asm_written_flag /* If STMT is not already marked necessary, mark it, and add it to the @@ -268,7 +249,7 @@ mark_operand_necessary (tree op, bool phionly) NECESSARY (stmt) = 1; VEC_safe_push (tree, heap, worklist, stmt); } - + /* Mark STMT as necessary if it obviously is. Add it to the worklist if it can make other statements necessary. @@ -374,64 +355,8 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive) return; } - -/* 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. */ -static void -find_obviously_necessary_stmts (struct edge_list *el) -{ - 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); - } - } -} - /* 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. */ @@ -460,17 +385,65 @@ mark_control_dependent_edges_necessary (basic_block bb, struct edge_list *el) mark_stmt_necessary (t, true); } } - -/* 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. + + +/* 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. */ + +static void +find_obviously_necessary_stmts (struct edge_list *el) +{ + basic_block bb; + block_stmt_iterator i; + edge e; + + FOR_EACH_BB (bb) + { + tree phi; + + /* PHI nodes are never inherently necessary. */ + for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) + NECESSARY (phi) = 0; + + /* 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); + } + } +} + + +/* 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)) @@ -478,22 +451,22 @@ propagate_necessity (struct edge_list *el) 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)) { @@ -502,7 +475,7 @@ propagate_necessity (struct edge_list *el) } } - 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 @@ -511,18 +484,19 @@ propagate_necessity (struct edge_list *el) 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)) { @@ -545,7 +519,7 @@ propagate_necessity (struct edge_list *el) 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); } } @@ -616,50 +590,6 @@ mark_really_necessary_kill_operand_phis (void) } - - -/* 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); - } - } - } - } - /* Remove dead PHI nodes from block BB. */ static void @@ -684,7 +614,7 @@ remove_dead_phis (basic_block bb) fprintf (dump_file, "\n"); } - remove_phi_node (phi, prev); + remove_phi_node (phi, prev, true); stats.removed_phis++; phi = next; } @@ -695,7 +625,8 @@ remove_dead_phis (basic_block bb) } } } - + + /* 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. */ @@ -788,7 +719,51 @@ remove_dead_stmt (block_stmt_iterator *i, basic_block bb) 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 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 diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c index 7656f365d8f..dcd4b86b42a 100644 --- a/gcc/tree-ssa-dom.c +++ b/gcc/tree-ssa-dom.c @@ -2089,7 +2089,7 @@ static void remove_stmt_or_phi (tree t) { if (TREE_CODE (t) == PHI_NODE) - remove_phi_node (t, NULL); + remove_phi_node (t, NULL, true); else { block_stmt_iterator bsi = bsi_for_stmt (t); diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 1aea162fe2c..ca95823f6a2 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -5351,12 +5351,7 @@ remove_statement (tree stmt, bool including_defined_name) { if (TREE_CODE (stmt) == PHI_NODE) { - if (!including_defined_name) - { - /* Prevent the ssa name defined by the statement from being removed. */ - SET_PHI_RESULT (stmt, NULL); - } - remove_phi_node (stmt, NULL_TREE); + remove_phi_node (stmt, NULL_TREE, including_defined_name); } else { diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index 492b42d1551..c0c5d5eabfd 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -4035,7 +4035,7 @@ remove_dead_inserted_code (void) if (TREE_CODE (t) == PHI_NODE) { - remove_phi_node (t, NULL); + remove_phi_node (t, NULL, true); } else {