CbC/CbC_gcc: gcc/tree-cfg.c comparison

comparison gcc/tree-cfg.c @ 63:b7f97abdc517 gcc-4.6-20100522

update gcc from gcc-4.5.0 to gcc-4.6

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 24 May 2010 12:47:05 +0900
parents	77e2b8dfacca
children	f6334be47118

comparison

equal deleted inserted replaced

-:3c8a44c06a95
+:b7f97abdc517
 /* Control flow functions for trees.
-Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-Free Software Foundation, Inc.
+2010  Free Software Foundation, Inc.
 Contributed by Diego Novillo <dnovillo@redhat.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
 #include "tree.h"
-#include "rtl.h"
 #include "tm_p.h"
-#include "hard-reg-set.h"
 #include "basic-block.h"
 #include "output.h"
 #include "flags.h"
 #include "function.h"
 #include "expr.h"
 #include "ggc.h"
 #include "langhooks.h"
 #include "diagnostic.h"
+#include "tree-pretty-print.h"
+#include "gimple-pretty-print.h"
 #include "tree-flow.h"
 #include "timevar.h"
 #include "tree-dump.h"
 #include "tree-pass.h"
 #include "toplev.h"
 more persistent.  The key is getting notification of changes to
 the CFG (particularly edge removal, creation and redirection).  */
 static struct pointer_map_t *edge_to_cases;
+/* If we record edge_to_cases, this bitmap will hold indexes
+of basic blocks that end in a GIMPLE_SWITCH which we touched
+due to edge manipulations.  */
+static bitmap touched_switch_bbs;
 /* CFG statistics.  */
 struct cfg_stats_d
 {
 long num_merged_labels;
 };
 static void remove_bb (basic_block);
 static edge find_taken_edge_computed_goto (basic_block, tree);
 static edge find_taken_edge_cond_expr (basic_block, tree);
 static edge find_taken_edge_switch_expr (basic_block, tree);
 static tree find_case_label_for_value (gimple, tree);
+static void group_case_labels_stmt (gimple);
 void
 init_empty_tree_cfg_for_function (struct function *fn)
 {
 /* Initialize the basic block array.  */
 void
 start_recording_case_labels (void)
 {
 gcc_assert (edge_to_cases == NULL);
 edge_to_cases = pointer_map_create ();
+touched_switch_bbs = BITMAP_ALLOC (NULL);
 }
 /* Return nonzero if we are recording information for case labels.  */
 static bool
 /* Stop recording information mapping edges to case labels and
 remove any information we have recorded.  */
 void
 end_recording_case_labels (void)
 {
+bitmap_iterator bi;
+unsigned i;
 pointer_map_traverse (edge_to_cases, edge_to_cases_cleanup, NULL);
 pointer_map_destroy (edge_to_cases);
 edge_to_cases = NULL;
+EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs, 0, i, bi)
+{
+basic_block bb = BASIC_BLOCK (i);
+if (bb)
+	{
+	  gimple stmt = last_stmt (bb);
+	  if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
+	    group_case_labels_stmt (stmt);
+	}
+}
+BITMAP_FREE (touched_switch_bbs);
 }
 /* If we are inside a {start,end}_recording_cases block, then return
 a chain of CASE_LABEL_EXPRs from T which reference E.
 }
 free (label_for_bb);
 }
-/* Look for blocks ending in a multiway branch (a SWITCH_EXPR in GIMPLE),
+/* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
+the ones jumping to the same label.
+Eg. three separate entries 1: 2: 3: become one entry 1..3:  */
+static void
+group_case_labels_stmt (gimple stmt)
+{
+int old_size = gimple_switch_num_labels (stmt);
+int i, j, new_size = old_size;
+tree default_case = NULL_TREE;
+tree default_label = NULL_TREE;
+bool has_default;
+/* The default label is always the first case in a switch
+statement after gimplification if it was not optimized
+away */
+if (!CASE_LOW (gimple_switch_default_label (stmt))
+&& !CASE_HIGH (gimple_switch_default_label (stmt)))
+{
+default_case = gimple_switch_default_label (stmt);
+default_label = CASE_LABEL (default_case);
+has_default = true;
+}
+else
+has_default = false;
+/* Look for possible opportunities to merge cases.  */
+if (has_default)
+i = 1;
+else
+i = 0;
+while (i < old_size)
+{
+tree base_case, base_label, base_high;
+base_case = gimple_switch_label (stmt, i);
+gcc_assert (base_case);
+base_label = CASE_LABEL (base_case);
+/* Discard cases that have the same destination as the
+	 default case.  */
+if (base_label == default_label)
+	{
+	  gimple_switch_set_label (stmt, i, NULL_TREE);
+	  i++;
+	  new_size--;
+	  continue;
+	}
+base_high = CASE_HIGH (base_case)
+	  ? CASE_HIGH (base_case)
+	  : CASE_LOW (base_case);
+i++;
+/* Try to merge case labels.  Break out when we reach the end
+	 of the label vector or when we cannot merge the next case
+	 label with the current one.  */
+while (i < old_size)
+	{
+	  tree merge_case = gimple_switch_label (stmt, i);
+	  tree merge_label = CASE_LABEL (merge_case);
+	  tree t = int_const_binop (PLUS_EXPR, base_high,
+				    integer_one_node, 1);
+	  /* Merge the cases if they jump to the same place,
+	     and their ranges are consecutive.  */
+	  if (merge_label == base_label
+	      && tree_int_cst_equal (CASE_LOW (merge_case), t))
+	    {
+	      base_high = CASE_HIGH (merge_case) ?
+		  CASE_HIGH (merge_case) : CASE_LOW (merge_case);
+	      CASE_HIGH (base_case) = base_high;
+	      gimple_switch_set_label (stmt, i, NULL_TREE);
+	      new_size--;
+	      i++;
+	    }
+	  else
+	    break;
+	}
+}
+/* Compress the case labels in the label vector, and adjust the
+length of the vector.  */
+for (i = 0, j = 0; i < new_size; i++)
+{
+while (! gimple_switch_label (stmt, j))
+	j++;
+gimple_switch_set_label (stmt, i,
+			       gimple_switch_label (stmt, j++));
+}
+gcc_assert (new_size <= old_size);
+gimple_switch_set_num_labels (stmt, new_size);
+}
+/* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
 and scan the sorted vector of cases.  Combine the ones jumping to the
-same label.
+same label.  */
-Eg. three separate entries 1: 2: 3: become one entry 1..3:  */
 void
 group_case_labels (void)
 {
 basic_block bb;
 FOR_EACH_BB (bb)
 {
 gimple stmt = last_stmt (bb);
 if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
-	{
+	group_case_labels_stmt (stmt);
-	  int old_size = gimple_switch_num_labels (stmt);
-	  int i, j, new_size = old_size;
-	  tree default_case = NULL_TREE;
-	  tree default_label = NULL_TREE;
-	  bool has_default;
-	  /* The default label is always the first case in a switch
-	     statement after gimplification if it was not optimized
-	     away */
-	  if (!CASE_LOW (gimple_switch_default_label (stmt))
-	      && !CASE_HIGH (gimple_switch_default_label (stmt)))
-	    {
-	      default_case = gimple_switch_default_label (stmt);
-	      default_label = CASE_LABEL (default_case);
-	      has_default = true;
-	    }
-	  else
-	    has_default = false;
-	  /* Look for possible opportunities to merge cases.  */
-	  if (has_default)
-	    i = 1;
-	  else
-	    i = 0;
-	  while (i < old_size)
-	    {
-	      tree base_case, base_label, base_high;
-	      base_case = gimple_switch_label (stmt, i);
-	      gcc_assert (base_case);
-	      base_label = CASE_LABEL (base_case);
-	      /* Discard cases that have the same destination as the
-		 default case.  */
-	      if (base_label == default_label)
-		{
-		  gimple_switch_set_label (stmt, i, NULL_TREE);
-		  i++;
-		  new_size--;
-		  continue;
-		}
-	      base_high = CASE_HIGH (base_case)
-			  ? CASE_HIGH (base_case)
-			  : CASE_LOW (base_case);
-	      i++;
-	      /* Try to merge case labels.  Break out when we reach the end
-		 of the label vector or when we cannot merge the next case
-		 label with the current one.  */
-	      while (i < old_size)
-		{
-		  tree merge_case = gimple_switch_label (stmt, i);
-	          tree merge_label = CASE_LABEL (merge_case);
-		  tree t = int_const_binop (PLUS_EXPR, base_high,
-					    integer_one_node, 1);
-		  /* Merge the cases if they jump to the same place,
-		     and their ranges are consecutive.  */
-		  if (merge_label == base_label
-		      && tree_int_cst_equal (CASE_LOW (merge_case), t))
-		    {
-		      base_high = CASE_HIGH (merge_case) ?
-			CASE_HIGH (merge_case) : CASE_LOW (merge_case);
-		      CASE_HIGH (base_case) = base_high;
-		      gimple_switch_set_label (stmt, i, NULL_TREE);
-		      new_size--;
-		      i++;
-		    }
-		  else
-		    break;
-		}
-	    }
-	  /* Compress the case labels in the label vector, and adjust the
-	     length of the vector.  */
-	  for (i = 0, j = 0; i < new_size; i++)
-	    {
-	      while (! gimple_switch_label (stmt, j))
-		j++;
-	      gimple_switch_set_label (stmt, i,
-				       gimple_switch_label (stmt, j++));
-	    }
-	  gcc_assert (new_size <= old_size);
-	  gimple_switch_set_num_labels (stmt, new_size);
-	}
 }
 }
 /* Checks whether we can merge block B into block A.  */
 /* Protect the loop latches.  */
 if (current_loops && b->loop_father->latch == b)
 return false;
 /* It must be possible to eliminate all phi nodes in B.  If ssa form
-is not up-to-date, we cannot eliminate any phis; however, if only
+is not up-to-date and a name-mapping is registered, we cannot eliminate
-some symbols as whole are marked for renaming, this is not a problem,
+any phis.  Symbols marked for renaming are never a problem though.  */
-as phi nodes for those symbols are irrelevant in updating anyway.  */
 phis = phi_nodes (b);
-if (!gimple_seq_empty_p (phis))
+if (!gimple_seq_empty_p (phis)
-{
+&& name_mappings_registered_p ())
-gimple_stmt_iterator i;
+return false;
-if (name_mappings_registered_p ())
-	return false;
-for (i = gsi_start (phis); !gsi_end_p (i); gsi_next (&i))
-	{
-	  gimple phi = gsi_stmt (i);
-	  if (!is_gimple_reg (gimple_phi_result (phi))
-	      && !may_propagate_copy (gimple_phi_result (phi),
-				      gimple_phi_arg_def (phi, 0)))
-	    return false;
-	}
-}
 return true;
 }
 /* Return true if the var whose chain of uses starts at PTR has no
 	      gimple stmt;
 	      FOR_EACH_IMM_USE_STMT (stmt, iter, def)
 		FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
 		  SET_USE (use_p, use);
+	      if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
+		SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use) = 1;
 	    }
 	  else
 replace_uses_by (def, use);
 remove_phi_node (&psi, true);
 static void
 remove_bb (basic_block bb)
 {
 gimple_stmt_iterator i;
-source_location loc = UNKNOWN_LOCATION;
 if (dump_file)
 {
 fprintf (dump_file, "Removing basic block %d\n", bb->index);
 if (dump_flags & TDF_DETAILS)
 	  if (gsi_end_p (i))
 	    i = gsi_last_bb (bb);
 	  else
 	    gsi_prev (&i);
+	}
-	  /* Don't warn for removed gotos.  Gotos are often removed due to
+}
-	     jump threading, thus resulting in bogus warnings.  Not great,
-	     since this way we lose warnings for gotos in the original
-	     program that are indeed unreachable.  */
-	  if (gimple_code (stmt) != GIMPLE_GOTO
-	      && gimple_has_location (stmt))
-	    loc = gimple_location (stmt);
-	}
-}
-/* If requested, give a warning that the first statement in the
-block is unreachable.  We walk statements backwards in the
-loop above, so the last statement we process is the first statement
-in the block.  */
-if (loc > BUILTINS_LOCATION && LOCATION_LINE (loc) > 0)
-warning_at (loc, OPT_Wunreachable_code, "will never be executed");
 remove_phi_nodes_and_edges_for_unreachable_block (bb);
 bb->il.gimple = NULL;
 }
 	   function has nonlocal labels.  */
 	if (!(flags & (ECF_CONST | ECF_PURE)) && cfun->has_nonlocal_label)
 	  return true;
 	/* A call also alters control flow if it does not return.  */
-	if (gimple_call_flags (t) & ECF_NORETURN)
+	if (flags & ECF_NORETURN)
 	  return true;
 }
 break;
 case GIMPLE_EH_DISPATCH:
 static bool
 verify_gimple_call (gimple stmt)
 {
 tree fn = gimple_call_fn (stmt);
 tree fntype;
+unsigned i;
+if (TREE_CODE (fn) != OBJ_TYPE_REF
+&& !is_gimple_val (fn))
+{
+error ("invalid function in gimple call");
+debug_generic_stmt (fn);
+return true;
+}
 if (!POINTER_TYPE_P (TREE_TYPE  (fn))
 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != FUNCTION_TYPE
 	  && TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != METHOD_TYPE))
 {
 if (gimple_call_lhs (stmt)
 && (!is_gimple_lvalue (gimple_call_lhs (stmt))
 	  || verify_types_in_gimple_reference (gimple_call_lhs (stmt), true)))
 {
 error ("invalid LHS in gimple call");
+return true;
+}
+if (gimple_call_lhs (stmt) && gimple_call_noreturn_p (stmt))
+{
+error ("LHS in noreturn call");
 return true;
 }
 fntype = TREE_TYPE (TREE_TYPE (fn));
 if (gimple_call_lhs (stmt)
 debug_generic_stmt (TREE_TYPE (gimple_call_lhs (stmt)));
 debug_generic_stmt (TREE_TYPE (fntype));
 return true;
 }
+if (gimple_call_chain (stmt)
+&& !is_gimple_val (gimple_call_chain (stmt)))
+{
+error ("invalid static chain in gimple call");
+debug_generic_stmt (gimple_call_chain (stmt));
+return true;
+}
 /* If there is a static chain argument, this should not be an indirect
 call, and the decl should have DECL_STATIC_CHAIN set.  */
 if (gimple_call_chain (stmt))
 {
 if (TREE_CODE (fn) != ADDR_EXPR
 	}
 }
 /* ???  The C frontend passes unpromoted arguments in case it
 didn't see a function declaration before the call.  So for now
-leave the call arguments unverified.  Once we gimplify
+leave the call arguments mostly unverified.  Once we gimplify
 unit-at-a-time we have a chance to fix this.  */
+for (i = 0; i < gimple_call_num_args (stmt); ++i)
+{
+tree arg = gimple_call_arg (stmt, i);
+if (!is_gimple_operand (arg))
+	{
+	  error ("invalid argument to gimple call");
+	  debug_generic_expr (arg);
+	}
+}
 return false;
 }
 /* Verifies the gimple comparison with the result type TYPE and
 	/* Shifts and rotates are ok on integral types, fixed point
 	   types and integer vector types.  */
 	if ((!INTEGRAL_TYPE_P (rhs1_type)
 	     && !FIXED_POINT_TYPE_P (rhs1_type)
 	     && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
-		  && TREE_CODE (TREE_TYPE (rhs1_type)) == INTEGER_TYPE))
+		  && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))))
 	    || (!INTEGRAL_TYPE_P (rhs2_type)
 		/* Vector shifts of vectors are also ok.  */
 		&& !(TREE_CODE (rhs1_type) == VECTOR_TYPE
-		     && TREE_CODE (TREE_TYPE (rhs1_type)) == INTEGER_TYPE
+		     && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
 		     && TREE_CODE (rhs2_type) == VECTOR_TYPE
-		     && TREE_CODE (TREE_TYPE (rhs2_type)) == INTEGER_TYPE))
+		     && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
 	    || !useless_type_conversion_p (lhs_type, rhs1_type))
 	  {
 	    error ("type mismatch in shift expression");
 	    debug_generic_expr (lhs_type);
 	    debug_generic_expr (rhs1_type);
 case LTGT_EXPR:
 /* Comparisons are also binary, but the result type is not
 	 connected to the operand types.  */
 return verify_gimple_comparison (lhs_type, rhs1, rhs2);
+case WIDEN_MULT_EXPR:
+if (TREE_CODE (lhs_type) != INTEGER_TYPE)
+	return true;
+return ((2 * TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (lhs_type))
+	      || (TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type)));
 case WIDEN_SUM_EXPR:
-case WIDEN_MULT_EXPR:
 case VEC_WIDEN_MULT_HI_EXPR:
 case VEC_WIDEN_MULT_LO_EXPR:
 case VEC_PACK_TRUNC_EXPR:
 case VEC_PACK_SAT_EXPR:
 case VEC_PACK_FIX_TRUNC_EXPR:
 case GIMPLE_CALL:
 return verify_gimple_call (stmt);
 case GIMPLE_COND:
+if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
+	{
+	  error ("invalid comparison code in gimple cond");
+	  return true;
+	}
+if (!(!gimple_cond_true_label (stmt)
+	    || TREE_CODE (gimple_cond_true_label (stmt)) == LABEL_DECL)
+	  || !(!gimple_cond_false_label (stmt)
+	       || TREE_CODE (gimple_cond_false_label (stmt)) == LABEL_DECL))
+	{
+	  error ("invalid labels in gimple cond");
+	  return true;
+	}
 return verify_gimple_comparison (boolean_type_node,
 				       gimple_cond_lhs (stmt),
 				       gimple_cond_rhs (stmt));
 case GIMPLE_GOTO:
 	  label = gimple_label_label (stmt);
 	  if (prev_stmt && DECL_NONLOCAL (label))
 	    {
 	      error ("nonlocal label ");
+	      print_generic_expr (stderr, label, 0);
+	      fprintf (stderr, " is not first in a sequence of labels in bb %d",
+		       bb->index);
+	      err = 1;
+	    }
+	  if (prev_stmt && EH_LANDING_PAD_NR (label) != 0)
+	    {
+	      error ("EH landing pad label ");
 	      print_generic_expr (stderr, label, 0);
 	      fprintf (stderr, " is not first in a sequence of labels in bb %d",
 		       bb->index);
 	      err = 1;
 	    }
 		tree cases2 = get_cases_for_edge (e2, stmt);
 		TREE_CHAIN (last) = TREE_CHAIN (cases2);
 		TREE_CHAIN (cases2) = first;
 	      }
+	    bitmap_set_bit (touched_switch_bbs, gimple_bb (stmt)->index);
 	  }
 	else
 	  {
 	    size_t i, n = gimple_switch_num_labels (stmt);
 FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
 	create_new_def_for (DEF_FROM_PTR (def_p), copy, def_p);
 }
 return new_bb;
-}
-/* Add phi arguments to the phi nodes in E_COPY->dest according to
-the phi arguments coming from the equivalent edge at
-the phi nodes of DEST.  */
-static void
-add_phi_args_after_redirect (edge e_copy, edge orig_e)
-{
-gimple_stmt_iterator psi, psi_copy;
-gimple phi, phi_copy;
-tree def;
-for (psi = gsi_start_phis (orig_e->dest),
-psi_copy = gsi_start_phis (e_copy->dest);
-!gsi_end_p (psi);
-gsi_next (&psi), gsi_next (&psi_copy))
-{
-phi = gsi_stmt (psi);
-phi_copy = gsi_stmt (psi_copy);
-def = PHI_ARG_DEF_FROM_EDGE (phi, orig_e);
-add_phi_arg (phi_copy, def, e_copy,
-gimple_phi_arg_location_from_edge (phi, orig_e));
-}
 }
 /* Adds phi node arguments for edge E_COPY after basic block duplication.  */
 static void
 int total_freq = 0, exit_freq = 0;
 gcov_type total_count = 0, exit_count = 0;
 edge exits[2], nexits[2], e;
 gimple_stmt_iterator gsi,gsi1;
 gimple cond_stmt;
-edge sorig, snew, orig_e;
+edge sorig, snew;
 basic_block exit_bb;
-edge_iterator ei;
+basic_block iters_bb;
-VEC (edge, heap) *redirect_edges;
-basic_block iters_bb, orig_src;
 tree new_rhs;
+gimple_stmt_iterator psi;
+gimple phi;
+tree def;
 gcc_assert (EDGE_COUNT (exit->src->succs) == 2);
 exits[0] = exit;
 exits[1] = EDGE_SUCC (exit->src, EDGE_SUCC (exit->src, 0) == exit);
 if (!can_copy_bbs_p (region, n_region))
 return false;
-/* Some sanity checking.  Note that we do not check for all possible
-missuses of the functions.  I.e. if you ask to copy something weird
-(e.g., in the example, if there is a jump from inside to the middle
-of some_code, or come_code defines some of the values used in cond)
-it will work, but the resulting code will not be correct.  */
-for (i = 0; i < n_region; i++)
-{
-if (region[i] == orig_loop->latch)
-	return false;
-}
 initialize_original_copy_tables ();
 set_loop_copy (orig_loop, loop);
 duplicate_subloops (orig_loop, loop);
 exit_bb = exit->dest;
 e = redirect_edge_and_branch (exits[0], exits[1]->dest);
 PENDING_STMT (e) = NULL;
-/* If the block consisting of the exit condition has the latch as
+/* The latch of ORIG_LOOP was copied, and so was the backedge
-successor, then the body of the loop is executed before
+to the original header.  We redirect this backedge to EXIT_BB.  */
-the exit condition is tested.
+for (i = 0; i < n_region; i++)
+if (get_bb_original (region_copy[i]) == orig_loop->latch)
-{ body  }
+{
-{ cond  } (exit[0])  -> { latch }
+	gcc_assert (single_succ_edge (region_copy[i]));
-|
+	e = redirect_edge_and_branch (single_succ_edge (region_copy[i]), exit_bb);
-	V (exit[1])
+	PENDING_STMT (e) = NULL;
+	for (psi = gsi_start_phis (exit_bb);
-{ exit_bb }
+	     !gsi_end_p (psi);
+	     gsi_next (&psi))
+	  {
-In such case, the equivalent copied edge nexits[1]
+	    phi = gsi_stmt (psi);
-(for the peeled iteration) needs to be redirected to exit_bb.
+	    def = PHI_ARG_DEF (phi, nexits[0]->dest_idx);
+	    add_phi_arg (phi, def, e, gimple_phi_arg_location_from_edge (phi, e));
-Otherwise,
+	  }
+}
-{ cond  } (exit[0])  -> { body }
+e = redirect_edge_and_branch (nexits[0], nexits[1]->dest);
-|
-	V (exit[1])
-{ exit_bb }
-exit[0] is pointing to the body of the loop,
-and the equivalent nexits[0] needs to be redirected to
-the copied body (of the peeled iteration).  */
-if (exits[1]->dest == orig_loop->latch)
-e = redirect_edge_and_branch (nexits[1], nexits[0]->dest);
-else
-e = redirect_edge_and_branch (nexits[0], nexits[1]->dest);
 PENDING_STMT (e) = NULL;
-redirect_edges = VEC_alloc (edge, heap, 10);
-for (i = 0; i < n_region; i++)
-region_copy[i]->flags |= BB_DUPLICATED;
-/* Iterate all incoming edges to latch.  All those coming from
-copied bbs will be redirected to exit_bb.  */
-FOR_EACH_EDGE (e, ei, orig_loop->latch->preds)
-{
-if (e->src->flags & BB_DUPLICATED)
-VEC_safe_push (edge, heap, redirect_edges, e);
-}
-for (i = 0; i < n_region; i++)
-region_copy[i]->flags &= ~BB_DUPLICATED;
-for (i = 0; VEC_iterate (edge, redirect_edges, i, e); ++i)
-{
-e = redirect_edge_and_branch (e, exit_bb);
-PENDING_STMT (e) = NULL;
-orig_src = get_bb_original (e->src);
-orig_e = find_edge (orig_src, orig_loop->latch);
-add_phi_args_after_redirect (e, orig_e);
-}
-VEC_free (edge, heap, redirect_edges);
 /* Anything that is outside of the region, but was dominated by something
 inside needs to update dominance info.  */
 iterate_fix_dominators (CDI_DOMINATORS, doms, false);
 VEC_free (basic_block, heap, doms);
 /* Update the SSA web.  */
 update_ssa (TODO_update_ssa);
 if (free_region_copy)
 free (region_copy);
 static void
 gimple_execute_on_growing_pred (edge e)
 {
 basic_block bb = e->dest;
-if (phi_nodes (bb))
+if (!gimple_seq_empty_p (phi_nodes (bb)))
 reserve_phi_args_for_new_edge (bb);
 }
 /* This function is called immediately before edge E is removed from
 the edge vector E->dest->preds.  */
 static void
 gimple_execute_on_shrinking_pred (edge e)
 {
-if (phi_nodes (e->dest))
+if (!gimple_seq_empty_p (phi_nodes (e->dest)))
 remove_phi_args (e);
 }
 /*---------------------------------------------------------------------------
 Helper functions for Loop versioning

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-cfg.c @ 63:b7f97abdc517 gcc-4.6-20100522