tree-ssa-pre.c (valid_in_sets): Remove checking of trapping operations.

2012-05-03  Richard Guenther  <rguenther@suse.de>

	* tree-ssa-pre.c (valid_in_sets): Remove checking of trapping
	operations.
	(prune_clobbered_mems): Do it here.  Do not uselessly sort
	expressions.
	(compute_avail): Do not add possibly trapping operations to
	EXP_GEN if they might not be executed in the block.

	* gcc.dg/tree-ssa/ssa-pre-27.c: Remove XFAIL.

From-SVN: r187096

4 files changed, 51 insertions, 30 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1bff6de..7b523a6 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2012-05-03  Richard Guenther  <rguenther@suse.de>
+
+	* tree-ssa-pre.c (valid_in_sets): Remove checking of trapping
+	operations.
+	(prune_clobbered_mems): Do it here.  Do not uselessly sort
+	expressions.
+	(compute_avail): Do not add possibly trapping operations to
+	EXP_GEN if they might not be executed in the block.
+
 2012-05-03  Uros Bizjak  <ubizjak@gmail.com>
 
 	* config/alpha/elf.h (MAX_OFILE_ALIGNMENT): Remove.
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index a642d17..c35bd85 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2012-05-03  Richard Guenther  <rguenther@suse.de>
+
+	* gcc.dg/tree-ssa/ssa-pre-27.c: Remove XFAIL.
+
 2012-05-03  Uros Bizjak  <ubizjak@gmail.com>
 
 	* gcc.target/i386/hle-cmpxchg-acq-1.c (dg-options): Add -march=x86-64.
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-27.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-27.c
index 1d60a30..4149bbe 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-27.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-27.c
@@ -17,13 +17,12 @@ int foo2 (int i, int j, int b)
   int res = 0;
   if (b)
     res = i/j;
-  /* But we fail so here because of the possibly not returning
-     call in the same basic-block.  */
+  /* And here, the possibly not returning call in the same basic-block
+     comes after the trapping i/j.  */
   res += i/j;
   bar ();
   return res;
 }
 
-/* { dg-final { scan-tree-dump-times "# prephitmp" 1 "pre" } } */
-/* { dg-final { scan-tree-dump-times "# prephitmp" 2 "pre" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "# prephitmp" 2 "pre" } } */
 /* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index e27e914..776a37c 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -2069,13 +2069,6 @@ valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, pre_expr expr,
 	for (i = 0; i < nary->length; i++)
 	  if (!op_valid_in_sets (set1, set2, nary->op[i]))
 	    return false;
-	/* If the NARY may trap make sure the block does not contain
-	   a possible exit point.
-	   ???  This is overly conservative if we translate AVAIL_OUT
-	   as the available expression might be after the exit point.  */
-	if (BB_MAY_NOTRETURN (block)
-	    && vn_nary_may_trap (nary))
-	  return false;
 	return true;
       }
       break;
@@ -2140,35 +2133,44 @@ clean (bitmap_set_t set, basic_block block)
 }
 
 /* Clean the set of expressions that are no longer valid in SET because
-   they are clobbered in BLOCK.  */
+   they are clobbered in BLOCK or because they trap and may not be executed.  */
 
 static void
 prune_clobbered_mems (bitmap_set_t set, basic_block block)
 {
-  VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set);
-  pre_expr expr;
-  int i;
+  bitmap_iterator bi;
+  unsigned i;
 
-  FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+  FOR_EACH_EXPR_ID_IN_SET (set, i, bi)
     {
-      vn_reference_t ref;
-      if (expr->kind != REFERENCE)
-	continue;
-
-      ref = PRE_EXPR_REFERENCE (expr);
-      if (ref->vuse)
+      pre_expr expr = expression_for_id (i);
+      if (expr->kind == REFERENCE)
+	{
+	  vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
+	  if (ref->vuse)
+	    {
+	      gimple def_stmt = SSA_NAME_DEF_STMT (ref->vuse);
+	      if (!gimple_nop_p (def_stmt)
+		  && ((gimple_bb (def_stmt) != block
+		       && !dominated_by_p (CDI_DOMINATORS,
+					   block, gimple_bb (def_stmt)))
+		      || (gimple_bb (def_stmt) == block
+			  && value_dies_in_block_x (expr, block))))
+		bitmap_remove_from_set (set, expr);
+	    }
+	}
+      else if (expr->kind == NARY)
 	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (ref->vuse);
-	  if (!gimple_nop_p (def_stmt)
-	      && ((gimple_bb (def_stmt) != block
-		   && !dominated_by_p (CDI_DOMINATORS,
-				       block, gimple_bb (def_stmt)))
-		  || (gimple_bb (def_stmt) == block
-		      && value_dies_in_block_x (expr, block))))
+	  vn_nary_op_t nary = PRE_EXPR_NARY (expr);
+	  /* If the NARY may trap make sure the block does not contain
+	     a possible exit point.
+	     ???  This is overly conservative if we translate AVAIL_OUT
+	     as the available expression might be after the exit point.  */
+	  if (BB_MAY_NOTRETURN (block)
+	      && vn_nary_may_trap (nary))
 	    bitmap_remove_from_set (set, expr);
 	}
     }
-  VEC_free (pre_expr, heap, exprs);
 }
 
 static sbitmap has_abnormal_preds;
@@ -4119,6 +4121,13 @@ compute_avail (void)
 			if (TREE_CODE (nary->op[i]) == SSA_NAME)
 			  add_to_exp_gen (block, nary->op[i]);
 
+		      /* If the NARY traps and there was a preceeding
+		         point in the block that might not return avoid
+			 adding the nary to EXP_GEN.  */
+		      if (BB_MAY_NOTRETURN (block)
+			  && vn_nary_may_trap (nary))
+			continue;
+
 		      result = (pre_expr) pool_alloc (pre_expr_pool);
 		      result->kind = NARY;
 		      result->id = 0;