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

comparison gcc/tree-eh.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
 /* Exception handling semantics and decomposition for trees.
-Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
+Copyright (C) 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 "flags.h"
 #include "function.h"
 #include "except.h"
+#include "pointer-set.h"
 #include "tree-flow.h"
 #include "tree-dump.h"
 #include "tree-inline.h"
 #include "tree-iterator.h"
 #include "tree-pass.h"
 replace_goto_queue (struct leh_tf_state *tf)
 {
 if (tf->goto_queue_active == 0)
 return;
 replace_goto_queue_stmt_list (tf->top_p_seq, tf);
+replace_goto_queue_stmt_list (eh_seq, tf);
 }
 /* Add a new record to the goto queue contained in TF. NEW_STMT is the
 data to be added, IS_LABEL indicates whether NEW_STMT is a label or
 a gimple return. */
 /* In the case of a GOTO we want to record the destination label,
 since with a GIMPLE_COND we have an easy access to the then/else
 labels. */
 new_stmt = stmt;
 record_in_goto_queue (tf, new_stmt, index, true);
 }
 /* For any GIMPLE_GOTO or GIMPLE_RETURN, decide whether it leaves a try_finally
 node, and if so record that fact in the goto queue associated with that
 try_finally node.  */
 return f_estimate < 100 || f_estimate < sw_estimate * 2;
 else
 return f_estimate < 40 || f_estimate * 2 < sw_estimate * 3;
 }
+/* REG is the enclosing region for a possible cleanup region, or the region
+itself.  Returns TRUE if such a region would be unreachable.
+Cleanup regions within a must-not-throw region aren't actually reachable
+even if there are throwing stmts within them, because the personality
+routine will call terminate before unwinding.  */
+static bool
+cleanup_is_dead_in (eh_region reg)
+{
+while (reg && reg->type == ERT_CLEANUP)
+reg = reg->outer;
+return (reg && reg->type == ERT_MUST_NOT_THROW);
+}
 /* A subroutine of lower_eh_constructs_1.  Lower a GIMPLE_TRY_FINALLY nodes
 to a sequence of labels and blocks, plus the exception region trees
 that record all the magic.  This is complicated by the need to
 arrange for the FINALLY block to be executed on all exits.  */
 lower_try_finally (struct leh_state *state, gimple tp)
 {
 struct leh_tf_state this_tf;
 struct leh_state this_state;
 int ndests;
+gimple_seq old_eh_seq;
 /* Process the try block.  */
 memset (&this_tf, 0, sizeof (this_tf));
 this_tf.try_finally_expr = tp;
 this_tf.top_p = tp;
 this_tf.outer = state;
-if (using_eh_for_cleanups_p)
+if (using_eh_for_cleanups_p && !cleanup_is_dead_in (state->cur_region))
-this_tf.region = gen_eh_region_cleanup (state->cur_region);
+{
+this_tf.region = gen_eh_region_cleanup (state->cur_region);
+this_state.cur_region = this_tf.region;
+}
 else
-this_tf.region = NULL;
+{
+this_tf.region = NULL;
-this_state.cur_region = this_tf.region;
+this_state.cur_region = state->cur_region;
+}
 this_state.ehp_region = state->ehp_region;
 this_state.tf = &this_tf;
+old_eh_seq = eh_seq;
+eh_seq = NULL;
 lower_eh_constructs_1 (&this_state, gimple_try_eval(tp));
 /* Determine if the try block is escaped through the bottom.  */
 this_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp));
 /* Determine if any exceptions are possible within the try block.  */
-if (using_eh_for_cleanups_p)
+if (this_tf.region)
 this_tf.may_throw = eh_region_may_contain_throw (this_tf.region);
 if (this_tf.may_throw)
 honor_protect_cleanup_actions (state, &this_state, &this_tf);
 /* Determine how many edges (still) reach the finally block.  Or rather,
 if (this_tf.goto_queue)
 free (this_tf.goto_queue);
 if (this_tf.goto_queue_map)
 pointer_map_destroy (this_tf.goto_queue_map);
+/* If there was an old (aka outer) eh_seq, append the current eh_seq.
+If there was no old eh_seq, then the append is trivially already done.  */
+if (old_eh_seq)
+{
+if (eh_seq == NULL)
+	eh_seq = old_eh_seq;
+else
+	{
+	  gimple_seq new_eh_seq = eh_seq;
+	  eh_seq = old_eh_seq;
+	  gimple_seq_add_seq(&eh_seq, new_eh_seq);
+	}
+}
 return this_tf.top_p_seq;
 }
 /* A subroutine of lower_eh_constructs_1.  Lower a GIMPLE_TRY_CATCH with a
 list of GIMPLE_CATCH to a sequence of labels and blocks, plus the
 {
 struct leh_state this_state = *state;
 eh_region this_region = NULL;
 struct leh_tf_state fake_tf;
 gimple_seq result;
+bool cleanup_dead = cleanup_is_dead_in (state->cur_region);
-if (flag_exceptions)
+if (flag_exceptions && !cleanup_dead)
 {
 this_region = gen_eh_region_cleanup (state->cur_region);
 this_state.cur_region = this_region;
 }
 lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
-if (!eh_region_may_contain_throw (this_region))
+if (cleanup_dead || !eh_region_may_contain_throw (this_region))
 return gimple_try_eval (tp);
 /* Build enough of a try-finally state so that we can reuse
 honor_protect_cleanup_actions.  */
 memset (&fake_tf, 0, sizeof (fake_tf));
 TODO_dump_func | TODO_verify_flow	/* todo_flags_finish */
 }
 };
-/* At the end of inlining, we can lower EH_DISPATCH.  */
+/* At the end of inlining, we can lower EH_DISPATCH.  Return true when
+we have found some duplicate labels and removed some edges.  */
-static void
+static bool
 lower_eh_dispatch (basic_block src, gimple stmt)
 {
 gimple_stmt_iterator gsi;
 int region_nr;
 eh_region r;
 tree filter, fn;
 gimple x;
+bool redirected = false;
 region_nr = gimple_eh_dispatch_region (stmt);
 r = get_eh_region_from_number (region_nr);
 gsi = gsi_last_bb (src);
 	VEC (tree, heap) *labels = NULL;
 	tree default_label = NULL;
 	eh_catch c;
 	edge_iterator ei;
 	edge e;
+	struct pointer_set_t *seen_values = pointer_set_create ();
 	/* Collect the labels for a switch.  Zero the post_landing_pad
 	   field becase we'll no longer have anything keeping these labels
 	   in existance and the optimizer will be free to merge these
 	   blocks at will.  */
 	for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
 	  {
 	    tree tp_node, flt_node, lab = c->label;
+	    bool have_label = false;
 	    c->label = NULL;
 	    tp_node = c->type_list;
 	    flt_node = c->filter_list;
 	        default_label = lab;
 		break;
 	      }
 	    do
 	      {
-		tree t = build3 (CASE_LABEL_EXPR, void_type_node,
+		/* Filter out duplicate labels that arise when this handler
-				 TREE_VALUE (flt_node), NULL, lab);
+		   is shadowed by an earlier one.  When no labels are
-		VEC_safe_push (tree, heap, labels, t);
+		   attached to the handler anymore, we remove
+		   the corresponding edge and then we delete unreachable
+		   blocks at the end of this pass.  */
+		if (! pointer_set_contains (seen_values, TREE_VALUE (flt_node)))
+		  {
+		    tree t = build3 (CASE_LABEL_EXPR, void_type_node,
+				     TREE_VALUE (flt_node), NULL, lab);
+		    VEC_safe_push (tree, heap, labels, t);
+		    pointer_set_insert (seen_values, TREE_VALUE (flt_node));
+		    have_label = true;
+		  }
 		tp_node = TREE_CHAIN (tp_node);
 		flt_node = TREE_CHAIN (flt_node);
 	      }
 	    while (tp_node);
+	    if (! have_label)
+	      {
+	        remove_edge (find_edge (src, label_to_block (lab)));
+	        redirected = true;
+	      }
 	  }
 	/* Clean up the edge flags.  */
 	FOR_EACH_EDGE (e, ei, src->succs)
 	  {
 	    x = gimple_build_switch_vec (filter, default_label, labels);
 	    gsi_insert_before (&gsi, x, GSI_SAME_STMT);
 	    VEC_free (tree, heap, labels);
 	  }
+	pointer_set_destroy (seen_values);
 }
 break;
 case ERT_ALLOWED_EXCEPTIONS:
 {
 gcc_unreachable ();
 }
 /* Replace the EH_DISPATCH with the SWITCH or COND generated above.  */
 gsi_remove (&gsi, true);
+return redirected;
 }
 static unsigned
 execute_lower_eh_dispatch (void)
 {
 basic_block bb;
 bool any_rewritten = false;
+bool redirected = false;
 assign_filter_values ();
 FOR_EACH_BB (bb)
 {
 gimple last = last_stmt (bb);
 if (last && gimple_code (last) == GIMPLE_EH_DISPATCH)
 	{
-	  lower_eh_dispatch (bb, last);
+	  redirected |= lower_eh_dispatch (bb, last);
 	  any_rewritten = true;
 	}
 }
+if (redirected)
+delete_unreachable_blocks ();
 return any_rewritten ? TODO_update_ssa_only_virtuals : 0;
 }
 static bool
 gate_lower_eh_dispatch (void)
 /* Input edge must be EH and output edge must be normal.  */
 if ((e_in->flags & EDGE_EH) == 0 || (e_out->flags & EDGE_EH) != 0)
 return false;
-/* The block must be empty except for the labels.  */
+/* The block must be empty except for the labels and debug insns.  */
-if (!gsi_end_p (gsi_after_labels (bb)))
+gsi = gsi_after_labels (bb);
+if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
+gsi_next_nondebug (&gsi);
+if (!gsi_end_p (gsi))
 return false;
 /* The destination block must not already have a landing pad
 for a different region.  */
 for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))

Mercurial > hg > CbC > CbC_gcc

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