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

comparison gcc/tree-eh.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 /* Exception handling semantics and decomposition for trees.
-Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 #include "tree-iterator.h"
 #include "tree-pass.h"
 #include "timevar.h"
 #include "langhooks.h"
 #include "ggc.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "gimple.h"
 #include "target.h"
 /* In some instances a tree and a gimple need to be stored in a same table,
 i.e. in hash tables. This is a structure to do this. */
 struct throw_stmt_node *n;
 void **slot;
 gcc_assert (num != 0);
-n = GGC_NEW (struct throw_stmt_node);
+n = ggc_alloc_throw_stmt_node ();
 n->stmt = t;
 n->lp_nr = num;
 if (!get_eh_throw_stmt_table (ifun))
 set_eh_throw_stmt_table (ifun, htab_create_ggc (31, struct_ptr_hash,
 call to a function which itself may contain a throw.  */
 static void
 note_eh_region_may_contain_throw (eh_region region)
 {
-while (!bitmap_bit_p (eh_region_may_contain_throw_map, region->index))
+while (bitmap_set_bit (eh_region_may_contain_throw_map, region->index))
 {
-bitmap_set_bit (eh_region_may_contain_throw_map, region->index);
 region = region->outer;
 if (region == NULL)
 	break;
 }
 }
 }
 }
 return label;
 }
-/* A subroutine of lower_try_finally.  If lang_protect_cleanup_actions
+/* A subroutine of lower_try_finally.  If the eh_protect_cleanup_actions
-returns non-null, then the language requires that the exception path out
+langhook returns non-null, then the language requires that the exception
-of a try_finally be treated specially.  To wit: the code within the
+path out of a try_finally be treated specially.  To wit: the code within
-finally block may not itself throw an exception.  We have two choices here.
+the finally block may not itself throw an exception.  We have two choices
-First we can duplicate the finally block and wrap it in a must_not_throw
+here. First we can duplicate the finally block and wrap it in a
-region.  Second, we can generate code like
+must_not_throw region.  Second, we can generate code like
 	try {
 	  finally_block;
 	} catch {
 	  if (fintmp == eh_edge)
 bool finally_may_fallthru;
 gimple_seq finally;
 gimple x;
 /* First check for nothing to do.  */
-if (lang_protect_cleanup_actions == NULL)
+if (lang_hooks.eh_protect_cleanup_actions == NULL)
 return;
-protect_cleanup_actions = lang_protect_cleanup_actions ();
+protect_cleanup_actions = lang_hooks.eh_protect_cleanup_actions ();
 if (protect_cleanup_actions == NULL)
 return;
 finally = gimple_try_cleanup (tf->top_p);
 finally_may_fallthru = gimple_seq_may_fallthru (finally);
 		  gimple_call_set_arg (stmt, 0, nr);
 		}
 	      else
 		{
 		  /* The user has dome something silly.  Remove it.  */
-		  rhs = build_int_cst (ptr_type_node, 0);
+		  rhs = null_pointer_node;
 		  goto do_replace;
 		}
 	      break;
 	    case BUILT_IN_EH_FILTER:
 	return true;
 if (honor_trapv)
 	return true;
 return false;
+case COMPLEX_EXPR:
+case CONSTRUCTOR:
+/* Constructing an object cannot trap.  */
+return false;
 default:
 /* Any floating arithmetic may trap.  */
 if (fp_operation && flag_trapping_math)
 	return true;
 restart:
 switch (code)
 {
 case TARGET_MEM_REF:
-/* For TARGET_MEM_REFs use the information based on the original
+if (TREE_CODE (TMR_BASE (expr)) == ADDR_EXPR
-	 reference.  */
+	  && !TMR_INDEX (expr) && !TMR_INDEX2 (expr))
-expr = TMR_ORIGINAL (expr);
+	return false;
-code = TREE_CODE (expr);
+return !TREE_THIS_NOTRAP (expr);
-goto restart;
 case COMPONENT_REF:
 case REALPART_EXPR:
 case IMAGPART_EXPR:
 case BIT_FIELD_REF:
 	return true;
 if (TREE_THIS_NOTRAP (expr))
 	return false;
 return !in_array_bounds_p (expr);
+case MEM_REF:
+if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR)
+	return false;
+/* Fallthru.  */
 case INDIRECT_REF:
-case ALIGN_INDIRECT_REF:
-case MISALIGNED_INDIRECT_REF:
 return !TREE_THIS_NOTRAP (expr);
 case ASM_EXPR:
 return TREE_THIS_VOLATILE (expr);
 case GIMPLE_CALL:
 return !gimple_call_nothrow_p (stmt);
 case GIMPLE_ASSIGN:
 case GIMPLE_COND:
-if (!flag_non_call_exceptions)
+if (!cfun->can_throw_non_call_exceptions)
 return false;
 return stmt_could_throw_1_p (stmt);
 case GIMPLE_ASM:
-if (!flag_non_call_exceptions)
+if (!cfun->can_throw_non_call_exceptions)
 return false;
 return gimple_asm_volatile_p (stmt);
 default:
 return false;
 {
 if (!flag_exceptions)
 return false;
 if (TREE_CODE (t) == MODIFY_EXPR)
 {
-if (flag_non_call_exceptions
+if (cfun->can_throw_non_call_exceptions
 && tree_could_trap_p (TREE_OPERAND (t, 0)))
 return true;
 t = TREE_OPERAND (t, 1);
 }
 if (TREE_CODE (t) == WITH_SIZE_EXPR)
 t = TREE_OPERAND (t, 0);
 if (TREE_CODE (t) == CALL_EXPR)
 return (call_expr_flags (t) & ECF_NOTHROW) == 0;
-if (flag_non_call_exceptions)
+if (cfun->can_throw_non_call_exceptions)
 return tree_could_trap_p (t);
 return false;
 }
 /* Return true if STMT can throw an exception that is not caught within
 	}
 /* If we did find the corresponding PHI, copy those inputs.  */
 if (ophi)
 	{
+	  /* If NOP is used somewhere else beyond phis in new_bb, give up.  */
+	  if (!has_single_use (nop))
+	    {
+	      imm_use_iterator imm_iter;
+	      use_operand_p use_p;
+	      FOR_EACH_IMM_USE_FAST (use_p, imm_iter, nop)
+		{
+		  if (!gimple_debug_bind_p (USE_STMT (use_p))
+		      && (gimple_code (USE_STMT (use_p)) != GIMPLE_PHI
+			  || gimple_bb (USE_STMT (use_p)) != new_bb))
+		    goto fail;
+		}
+	    }
 	  bitmap_set_bit (ophi_handled, SSA_NAME_VERSION (nop));
 	  FOR_EACH_EDGE (e, ei, old_bb->preds)
 	    {
 	      location_t oloc;
 	      tree oop;
 static bool
 cleanup_empty_eh_unsplit (basic_block bb, edge e_out, eh_landing_pad lp)
 {
 gimple_stmt_iterator gsi;
 tree lab;
+edge_iterator ei;
+edge e;
 /* We really ought not have totally lost everything following
 a landing pad label.  Given that BB is empty, there had better
 be a successor.  */
 gcc_assert (e_out != NULL);
 lp_nr = EH_LANDING_PAD_NR (lab);
 if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region)
 	return false;
 }
+/* The destination block must not be a regular successor for any
+of the preds of the landing pad.  Thus, avoid turning
+<..>
+	 |  \ EH
+	 |  <..>
+	 |  /
+	<..>
+into
+<..>
+	|  | EH
+	<..>
+which CFG verification would choke on.  See PR45172.  */
+FOR_EACH_EDGE (e, ei, bb->preds)
+if (find_edge (e->src, e_out->dest))
+return false;
 /* Attempt to move the PHIs into the successor block.  */
 if (cleanup_empty_eh_merge_phis (e_out->dest, bb, e_out, false))
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file,
 		 lp->index, e_out->dest->index);
 return true;
 }
 return false;
+}
+/* Return true if edge E_FIRST is part of an empty infinite loop
+or leads to such a loop through a series of single successor
+empty bbs.  */
+static bool
+infinite_empty_loop_p (edge e_first)
+{
+bool inf_loop = false;
+edge e;
+if (e_first->dest == e_first->src)
+return true;
+e_first->src->aux = (void *) 1;
+for (e = e_first; single_succ_p (e->dest); e = single_succ_edge (e->dest))
+{
+gimple_stmt_iterator gsi;
+if (e->dest->aux)
+	{
+	  inf_loop = true;
+	  break;
+	}
+e->dest->aux = (void *) 1;
+gsi = gsi_after_labels (e->dest);
+if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
+	gsi_next_nondebug (&gsi);
+if (!gsi_end_p (gsi))
+	break;
+}
+e_first->src->aux = NULL;
+for (e = e_first; e->dest->aux; e = single_succ_edge (e->dest))
+e->dest->aux = NULL;
+return inf_loop;
 }
 /* Examine the block associated with LP to determine if it's an empty
 handler for its EH region.  If so, attempt to redirect EH edges to
 an outer region.  Return true the CFG was updated in any way.  This
 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
 gsi_next_nondebug (&gsi);
 /* If the block is totally empty, look for more unsplitting cases.  */
 if (gsi_end_p (gsi))
-return cleanup_empty_eh_unsplit (bb, e_out, lp);
+{
+/* For the degenerate case of an infinite loop bail out.  */
+if (infinite_empty_loop_p (e_out))
+	return false;
+return cleanup_empty_eh_unsplit (bb, e_out, lp);
+}
 /* The block should consist only of a single RESX statement.  */
 resx = gsi_stmt (gsi);
 if (!is_gimple_resx (resx))
 return false;
 TODO: Push MUST_NOT_THROW regions to the root of the EH tree.
 	 Unify those that have the same failure decl and locus.
 */
 static unsigned int
-execute_cleanup_eh (void)
+execute_cleanup_eh_1 (void)
 {
 /* Do this first: unsplit_all_eh and cleanup_all_empty_eh can die
 looking up unreachable landing pads.  */
 remove_unreachable_handlers ();
 	  return TODO_cleanup_cfg | TODO_update_ssa_only_virtuals;
 	}
 }
 return 0;
+}
+static unsigned int
+execute_cleanup_eh (void)
+{
+int ret = execute_cleanup_eh_1 ();
+/* If the function no longer needs an EH personality routine
+clear it.  This exposes cross-language inlining opportunities
+and avoids references to a never defined personality routine.  */
+if (DECL_FUNCTION_PERSONALITY (current_function_decl)
+&& function_needs_eh_personality (cfun) != eh_personality_lang)
+DECL_FUNCTION_PERSONALITY (current_function_decl) = NULL_TREE;
+return ret;
 }
 static bool
 gate_cleanup_eh (void)
 {
 };
 /* Verify that BB containing STMT as the last statement, has precisely the
 edge that make_eh_edges would create.  */
-bool
+DEBUG_FUNCTION bool
 verify_eh_edges (gimple stmt)
 {
 basic_block bb = gimple_bb (stmt);
 eh_landing_pad lp = NULL;
 int lp_nr;
 return false;
 }
 /* Similarly, but handle GIMPLE_EH_DISPATCH specifically.  */
-bool
+DEBUG_FUNCTION bool
 verify_eh_dispatch_edge (gimple stmt)
 {
 eh_region r;
 eh_catch c;
 basic_block src, dst;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-eh.c @ 67:f6334be47118