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

6 files changed, 59 insertions, 40 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 3742fb1..3030d3c 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,17 @@
+2007-05-30  Zdenek Dvorak  <dvorakz@suse.cz>
+
+	* 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 <ubizjak@gmail.com>
 
 	* config/i386/i386.h (TARGET_ABM): New define.
diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c
index 579c3d3..62fd245 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 83ab930..7bd4496 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 54e8847..2dace9c 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 fd55938..0598361 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 c81f83c..6dff7ff 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 <a_13, a_26>
@@ -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;
+
+  *tobb = sinkbb;
+  *tobsi = bsi_after_labels (sinkbb);
 
-  return first_stmt (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);