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

comparison gcc/tree-cfgcleanup.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
 /* CFG cleanup for trees.
-Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 Free Software Foundation, Inc.
 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 "toplev.h"
 #include "flags.h"
 #include "function.h"
 if (!single_succ_p (bb))
 {
 edge e;
 edge_iterator ei;
 bool warned;
+location_t loc;
 fold_defer_overflow_warnings ();
-val = gimple_fold (stmt);
+loc = gimple_location (stmt);
+switch (gimple_code (stmt))
+	{
+	case GIMPLE_COND:
+	  {
+	    tree lhs = gimple_cond_lhs (stmt);
+	    tree rhs = gimple_cond_rhs (stmt);
+	    /* For conditions try harder and lookup single-argument
+	       PHI nodes.  Only do so from the same basic-block though
+	       as other basic-blocks may be dead already.  */
+	    if (TREE_CODE (lhs) == SSA_NAME
+		&& !name_registered_for_update_p (lhs))
+	      {
+		gimple def_stmt = SSA_NAME_DEF_STMT (lhs);
+		if (gimple_code (def_stmt) == GIMPLE_PHI
+		    && gimple_phi_num_args (def_stmt) == 1
+		    && gimple_bb (def_stmt) == gimple_bb (stmt)
+		    && (TREE_CODE (PHI_ARG_DEF (def_stmt, 0)) != SSA_NAME
+			|| !name_registered_for_update_p (PHI_ARG_DEF (def_stmt,
+								       0))))
+		  lhs = PHI_ARG_DEF (def_stmt, 0);
+	      }
+	    if (TREE_CODE (rhs) == SSA_NAME
+		&& !name_registered_for_update_p (rhs))
+	      {
+		gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
+		if (gimple_code (def_stmt) == GIMPLE_PHI
+		    && gimple_phi_num_args (def_stmt) == 1
+		    && gimple_bb (def_stmt) == gimple_bb (stmt)
+		    && (TREE_CODE (PHI_ARG_DEF (def_stmt, 0)) != SSA_NAME
+			|| !name_registered_for_update_p (PHI_ARG_DEF (def_stmt,
+								       0))))
+		  rhs = PHI_ARG_DEF (def_stmt, 0);
+	      }
+	    val = fold_binary_loc (loc, gimple_cond_code (stmt),
+				   boolean_type_node, lhs, rhs);
+	    break;
+	  }
+	case GIMPLE_SWITCH:
+	  val = gimple_switch_index (stmt);
+	  break;
+	default:
+	  val = NULL_TREE;
+	}
 taken_edge = find_taken_edge (bb, val);
 if (!taken_edge)
 	{
 	  fold_undefer_and_ignore_overflow_warnings ();
 	  return false;
 static bool
 tree_forwarder_block_p (basic_block bb, bool phi_wanted)
 {
 gimple_stmt_iterator gsi;
+location_t locus;
 /* BB must have a single outgoing edge.  */
 if (single_succ_p (bb) != 1
 /* If PHI_WANTED is false, BB must not have any PHI nodes.
 	 Otherwise, BB must have PHI nodes.  */
 #if ENABLE_CHECKING
 gcc_assert (bb != ENTRY_BLOCK_PTR);
 #endif
+locus = single_succ_edge (bb)->goto_locus;
 /* There should not be an edge coming from entry, or an EH edge.  */
 {
 edge_iterator ei;
 edge e;
 FOR_EACH_EDGE (e, ei, bb->preds)
 if (e->src == ENTRY_BLOCK_PTR || (e->flags & EDGE_EH))
 	return false;
+/* If goto_locus of any of the edges differs, prevent removing
+	 the forwarder block for -O0.  */
+else if (optimize == 0 && e->goto_locus != locus)
+	return false;
 }
 /* Now walk through the statements backward.  We can ignore labels,
 anything else means this is not a forwarder block.  */
 for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
 switch (gimple_code (stmt))
 	{
 	case GIMPLE_LABEL:
 	  if (DECL_NONLOCAL (gimple_label_label (stmt)))
+	    return false;
+	  if (optimize == 0 && gimple_location (stmt) != locus)
 	    return false;
 	  break;
 	  /* ??? For now, hope there's a corresponding debug
 	     assignment at the destination.  */
 edge succ = single_succ_edge (bb), e, s;
 basic_block dest = succ->dest;
 gimple label;
 edge_iterator ei;
 gimple_stmt_iterator gsi, gsi_to;
-bool seen_abnormal_edge = false;
+bool can_move_debug_stmts;
 /* We check for infinite loops already in tree_forwarder_block_p.
 However it may happen that the infinite loop is created
 afterwards due to removal of forwarders.  */
 if (dest == bb)
 return false;
-/* If the destination block consists of a nonlocal label, do not merge
+/* If the destination block consists of a nonlocal label or is a
-it.  */
+EH landing pad, do not merge it.  */
 label = first_stmt (dest);
 if (label
 && gimple_code (label) == GIMPLE_LABEL
-&& DECL_NONLOCAL (gimple_label_label (label)))
+&& (DECL_NONLOCAL (gimple_label_label (label))
+	  || EH_LANDING_PAD_NR (gimple_label_label (label)) != 0))
 return false;
 /* If there is an abnormal edge to basic block BB, but not into
 dest, problems might occur during removal of the phi node at out
 of ssa due to overlapping live ranges of registers.
 two different eh regions, and rest of exception handling code
 does not like it.
 So if there is an abnormal edge to BB, proceed only if there is
 no abnormal edge to DEST and there are no phi nodes in DEST.  */
-if (has_abnormal_incoming_edge_p (bb))
+if (has_abnormal_incoming_edge_p (bb)
-{
+&& (has_abnormal_incoming_edge_p (dest)
-seen_abnormal_edge = true;
+	  || !gimple_seq_empty_p (phi_nodes (dest))))
+return false;
-if (has_abnormal_incoming_edge_p (dest)
-	  || !gimple_seq_empty_p (phi_nodes (dest)))
-	return false;
-}
 /* If there are phi nodes in DEST, and some of the blocks that are
 predecessors of BB are also predecessors of DEST, check that the
 phi node arguments match.  */
 if (!gimple_seq_empty_p (phi_nodes (dest)))
 	  if (!phi_alternatives_equal (dest, succ, s))
 	    return false;
 	}
 }
+can_move_debug_stmts = single_pred_p (dest);
 /* Redirect the edges.  */
 for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
 {
 bitmap_set_bit (cfgcleanup_altered_bbs, e->src->index);
 	      add_phi_arg (phi, gimple_phi_arg_def (phi, succ->dest_idx), s, l);
 	    }
 	}
 }
-if (seen_abnormal_edge)
+/* Move nonlocal labels and computed goto targets as well as user
-{
+defined labels and labels with an EH landing pad number to the
-/* Move the labels to the new block, so that the redirection of
+new block, so that the redirection of the abnormal edges works,
-	 the abnormal edges works.  */
+jump targets end up in a sane place and debug information for
-gsi_to = gsi_start_bb (dest);
+labels is retained.  */
-for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
+gsi_to = gsi_start_bb (dest);
-	{
+for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
-	  label = gsi_stmt (gsi);
+{
-	  gcc_assert (gimple_code (label) == GIMPLE_LABEL
+tree decl;
-		      || is_gimple_debug (label));
+label = gsi_stmt (gsi);
+if (is_gimple_debug (label))
+	break;
+decl = gimple_label_label (label);
+if (EH_LANDING_PAD_NR (decl) != 0
+	  || DECL_NONLOCAL (decl)
+	  || FORCED_LABEL (decl)
+	  || !DECL_ARTIFICIAL (decl))
+	{
 	  gsi_remove (&gsi, false);
 	  gsi_insert_before (&gsi_to, label, GSI_SAME_STMT);
+	}
+else
+	gsi_next (&gsi);
+}
+/* Move debug statements if the destination has just a single
+predecessor.  */
+if (can_move_debug_stmts)
+{
+gsi_to = gsi_after_labels (dest);
+for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); )
+	{
+	  gimple debug = gsi_stmt (gsi);
+	  if (!is_gimple_debug (debug))
+	    break;
+	  gsi_remove (&gsi, false);
+	  gsi_insert_before (&gsi_to, debug, GSI_SAME_STMT);
 	}
 }
 bitmap_set_bit (cfgcleanup_altered_bbs, dest->index);
 if (cleanup_omp_return (bb))
 return true;
 retval = cleanup_control_flow_bb (bb);
-/* Forwarder blocks can carry line number information which is
+if (tree_forwarder_block_p (bb, false)
-useful when debugging, so we only clean them up when
-optimizing.  */
-if (optimize > 0
-&& tree_forwarder_block_p (bb, false)
 && remove_forwarder_block (bb))
 return true;
 /* Merging the blocks may create new opportunities for folding
 conditional branches (due to the elimination of single-valued PHI
 dest = single_succ (bb);
 /* We have to feed into another basic block with PHI
 	 nodes.  */
-if (!phi_nodes (dest)
+if (gimple_seq_empty_p (phi_nodes (dest))
 	  /* We don't want to deal with a basic block with
 	     abnormal edges.  */
 	  || has_abnormal_incoming_edge_p (bb))
 	continue;

Mercurial > hg > CbC > CbC_gcc

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