From 1896570321ab490f506b885e18c76c41d0f5e4bf Mon Sep 17 00:00:00 2001 From: Zdenek Dvorak Date: Wed, 30 May 2007 15:29:51 +0200 Subject: [PATCH] tree-scalar-evolution.c (scev_const_prop): Do not create labels. * tree-scalar-evolution.c (scev_const_prop): Do not create labels. * tree-ssa-sink.c (statement_sink_location): Return basic block and bsi of the location where statements should be inserted. (sink_code_in_bb): Take bsi from statement_sink_location. * lambda-code.c (lambda_loopnest_to_gcc_loopnest): Use bsi_after_labels instead of bsi_start. * tree-profile.c (tree_gen_ic_func_profiler): Pass BSI_NEW_STMT to bsi_insert_after. * tree-cfg.c (bsi_move_after): Pass BSI_NEW_STMT to bsi_insert_after. (bsi_move_before): Document inconsistency with bsi_move_after. (tree_redirect_edge_and_branch): Do not create labels if not necessary. From-SVN: r125181 --- gcc/ChangeLog | 14 ++++++++ gcc/lambda-code.c | 4 +-- gcc/tree-cfg.c | 12 ++++--- gcc/tree-profile.c | 2 +- gcc/tree-scalar-evolution.c | 1 - gcc/tree-ssa-sink.c | 66 +++++++++++++++++++------------------ 6 files changed, 59 insertions(+), 40 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 3742fb17a0f..3030d3ccd00 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,17 @@ +2007-05-30 Zdenek Dvorak + + * tree-scalar-evolution.c (scev_const_prop): Do not create labels. + * tree-ssa-sink.c (statement_sink_location): Return basic block and + bsi of the location where statements should be inserted. + (sink_code_in_bb): Take bsi from statement_sink_location. + * lambda-code.c (lambda_loopnest_to_gcc_loopnest): Use bsi_after_labels + instead of bsi_start. + * tree-profile.c (tree_gen_ic_func_profiler): Pass BSI_NEW_STMT to + bsi_insert_after. + * tree-cfg.c (bsi_move_after): Pass BSI_NEW_STMT to bsi_insert_after. + (bsi_move_before): Document inconsistency with bsi_move_after. + (tree_redirect_edge_and_branch): Do not create labels if not necessary. + 2007-05-30 Uros Bizjak * config/i386/i386.h (TARGET_ABM): New define. diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c index 579c3d3fb7f..62fd245b235 100644 --- a/gcc/lambda-code.c +++ b/gcc/lambda-code.c @@ -1881,8 +1881,8 @@ lambda_loopnest_to_gcc_loopnest (struct loop *old_loopnest, exit = single_exit (temp); exitcond = get_loop_exit_condition (temp); bb = bb_for_stmt (exitcond); - bsi = bsi_start (bb); - bsi_insert_after (&bsi, stmts, BSI_NEW_STMT); + bsi = bsi_after_labels (bb); + bsi_insert_before (&bsi, stmts, BSI_NEW_STMT); /* Create the new iv. */ diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 83ab930d935..7bd4496cf83 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -2776,7 +2776,9 @@ bsi_move_after (block_stmt_iterator *from, block_stmt_iterator *to) { tree stmt = bsi_stmt (*from); bsi_remove (from, false); - bsi_insert_after (to, stmt, BSI_SAME_STMT); + /* We must have BSI_NEW_STMT here, as bsi_move_after is sometimes used to + move statements to an empty block. */ + bsi_insert_after (to, stmt, BSI_NEW_STMT); } @@ -2787,6 +2789,9 @@ bsi_move_before (block_stmt_iterator *from, block_stmt_iterator *to) { tree stmt = bsi_stmt (*from); bsi_remove (from, false); + /* For consistency with bsi_move_after, it might be better to have + BSI_NEW_STMT here; however, that breaks several places that expect + that TO does not change. */ bsi_insert_before (to, stmt, BSI_SAME_STMT); } @@ -3993,7 +3998,7 @@ tree_redirect_edge_and_branch (edge e, basic_block dest) basic_block bb = e->src; block_stmt_iterator bsi; edge ret; - tree label, stmt; + tree stmt; if (e->flags & EDGE_ABNORMAL) return NULL; @@ -4005,8 +4010,6 @@ tree_redirect_edge_and_branch (edge e, basic_block dest) if (e->dest == dest) return NULL; - label = tree_block_label (dest); - bsi = bsi_last (bb); stmt = bsi_end_p (bsi) ? NULL : bsi_stmt (bsi); @@ -4024,6 +4027,7 @@ tree_redirect_edge_and_branch (edge e, basic_block dest) case SWITCH_EXPR: { tree cases = get_cases_for_edge (e, stmt); + tree label = tree_block_label (dest); /* If we have a list of cases associated with E, then use it as it's a lot faster than walking the entire case vector. */ diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c index 54e88479cdf..2dace9c6a8f 100644 --- a/gcc/tree-profile.c +++ b/gcc/tree-profile.c @@ -332,7 +332,7 @@ tree_gen_ic_func_profiler (void) tree_uid, cur_func, ic_void_ptr_var); - bsi_insert_after (&bsi, stmt1, BSI_SAME_STMT); + bsi_insert_after (&bsi, stmt1, BSI_NEW_STMT); } } diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c index fd559388d65..059836154a6 100644 --- a/gcc/tree-scalar-evolution.c +++ b/gcc/tree-scalar-evolution.c @@ -2968,7 +2968,6 @@ scev_const_prop (void) /* Ensure that it is possible to insert new statements somewhere. */ if (!single_pred_p (exit->dest)) split_loop_exit_edge (exit); - tree_block_label (exit->dest); bsi = bsi_after_labels (exit->dest); ex_loop = superloop_at_depth (loop, diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c index c81f83c098f..6dff7ff943f 100644 --- a/gcc/tree-ssa-sink.c +++ b/gcc/tree-ssa-sink.c @@ -263,11 +263,13 @@ nearest_common_dominator_of_uses (tree stmt) /* Given a statement (STMT) and the basic block it is currently in (FROMBB), determine the location to sink the statement to, if any. - Return the basic block to sink it to, or NULL if we should not sink - it. */ + Returns true if there is such location; in that case, TOBB is set to the + basic block of the location, and TOBSI points to the statement before + that STMT should be moved. */ -static tree -statement_sink_location (tree stmt, basic_block frombb) +static bool +statement_sink_location (tree stmt, basic_block frombb, basic_block *tobb, + block_stmt_iterator *tobsi) { tree use, def; use_operand_p one_use = NULL_USE_OPERAND_P; @@ -291,10 +293,10 @@ statement_sink_location (tree stmt, basic_block frombb) /* Return if there are no immediate uses of this stmt. */ if (one_use == NULL_USE_OPERAND_P) - return NULL; + return false; if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) - return NULL; + return false; rhs = GIMPLE_STMT_OPERAND (stmt, 1); /* There are a few classes of things we can't or don't move, some because we @@ -325,21 +327,21 @@ statement_sink_location (tree stmt, basic_block frombb) || is_hidden_global_store (stmt) || ann->has_volatile_ops || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VUSE)) - return NULL; + return false; FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_ALL_DEFS) { tree def = DEF_FROM_PTR (def_p); if (is_global_var (SSA_NAME_VAR (def)) || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def)) - return NULL; + return false; } FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES) { tree use = USE_FROM_PTR (use_p); if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use)) - return NULL; + return false; } /* If all the immediate uses are not in the same place, find the nearest @@ -351,13 +353,13 @@ statement_sink_location (tree stmt, basic_block frombb) basic_block commondom = nearest_common_dominator_of_uses (stmt); if (commondom == frombb) - return NULL; + return false; /* Our common dominator has to be dominated by frombb in order to be a trivially safe place to put this statement, since it has multiple uses. */ if (!dominated_by_p (CDI_DOMINATORS, commondom, frombb)) - return NULL; + return false; /* It doesn't make sense to move to a dominator that post-dominates frombb, because it means we've just moved it into a path that always @@ -367,17 +369,19 @@ statement_sink_location (tree stmt, basic_block frombb) { if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Not moving store, common dominator post-dominates from block.\n"); - return NULL; + return false; } if (commondom == frombb || commondom->loop_depth > frombb->loop_depth) - return NULL; + return false; if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Common dominator of all uses is %d\n", commondom->index); } - return first_stmt (commondom); + *tobb = commondom; + *tobsi = bsi_after_labels (commondom); + return true; } use = USE_STMT (one_use); @@ -386,8 +390,10 @@ statement_sink_location (tree stmt, basic_block frombb) sinkbb = bb_for_stmt (use); if (sinkbb == frombb || sinkbb->loop_depth > frombb->loop_depth || sinkbb->loop_father != frombb->loop_father) - return NULL; - return use; + return false; + *tobb = sinkbb; + *tobsi = bsi_for_stmt (use); + return true; } /* Note that at this point, all uses must be in the same statement, so it @@ -395,10 +401,9 @@ statement_sink_location (tree stmt, basic_block frombb) FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS) break; - sinkbb = find_bb_for_arg (use, def); if (!sinkbb) - return NULL; + return false; /* This will happen when you have a_3 = PHI @@ -409,12 +414,15 @@ statement_sink_location (tree stmt, basic_block frombb) we can't sink it. */ if (bb_for_stmt (use) == frombb) - return NULL; + return false; if (sinkbb == frombb || sinkbb->loop_depth > frombb->loop_depth || sinkbb->loop_father != frombb->loop_father) - return NULL; + return false; - return first_stmt (sinkbb); + *tobb = sinkbb; + *tobsi = bsi_after_labels (sinkbb); + + return true; } /* Perform code sinking on BB */ @@ -441,10 +449,9 @@ sink_code_in_bb (basic_block bb) { tree stmt = bsi_stmt (bsi); block_stmt_iterator tobsi; - tree sinkstmt; - - sinkstmt = statement_sink_location (stmt, bb); - if (!sinkstmt) + basic_block tobb; + + if (!statement_sink_location (stmt, bb, &tobb, &tobsi)) { if (!bsi_end_p (bsi)) bsi_prev (&bsi); @@ -455,18 +462,13 @@ sink_code_in_bb (basic_block bb) fprintf (dump_file, "Sinking "); print_generic_expr (dump_file, stmt, TDF_VOPS); fprintf (dump_file, " from bb %d to bb %d\n", - bb->index, bb_for_stmt (sinkstmt)->index); + bb->index, tobb->index); } - tobsi = bsi_for_stmt (sinkstmt); - /* Find the first non-label. */ - while (!bsi_end_p (tobsi) - && TREE_CODE (bsi_stmt (tobsi)) == LABEL_EXPR) - bsi_next (&tobsi); /* If this is the end of the basic block, we need to insert at the end of the basic block. */ if (bsi_end_p (tobsi)) - bsi_move_to_bb_end (&bsi, bb_for_stmt (sinkstmt)); + bsi_move_to_bb_end (&bsi, tobb); else bsi_move_before (&bsi, &tobsi);