re PR middle-end/92063 (ICE in operation_could_trap_p, at tree-eh.c:2528 when…

re PR middle-end/92063 (ICE in operation_could_trap_p, at tree-eh.c:2528 when compiling Python's Python/_warnings.c)

	PR middle-end/92063
	* tree-eh.c (operation_could_trap_helper_p) <case COND_EXPR>
	<case VEC_COND_EXPR>: Return false with *handled = false.
	(tree_could_trap_p): For {,VEC_}COND_EXPR return false instead of
	recursing on the first operand.
	* fold-const.c (simple_operand_p_2): Use generic_expr_could_trap_p
	instead of tree_could_trap_p.
	* tree-ssa-sccvn.c (vn_nary_may_trap): Formatting fixes.

	* gcc.c-torture/compile/pr92063.c: New test.

From-SVN: r276915

gcc/ChangeLog

+2019-10-12  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/92063
+	* tree-eh.c (operation_could_trap_helper_p) <case COND_EXPR>
+	<case VEC_COND_EXPR>: Return false with *handled = false.
+	(tree_could_trap_p): For {,VEC_}COND_EXPR return false instead of
+	recursing on the first operand.
+	* fold-const.c (simple_operand_p_2): Use generic_expr_could_trap_p
+	instead of tree_could_trap_p.
+	* tree-ssa-sccvn.c (vn_nary_may_trap): Formatting fixes.
+
 2019-10-11  Jim Wilson  <jimw@sifive.com>
 
 	PR rtl-optimization/91860

gcc/fold-const.c

@@ -4447,8 +4447,7 @@ simple_operand_p_2 (tree exp)
 {
   enum tree_code code;
 
-  if (TREE_SIDE_EFFECTS (exp)
-      || tree_could_trap_p (exp))
+  if (TREE_SIDE_EFFECTS (exp) || generic_expr_could_trap_p (exp))
     return false;
 
   while (CONVERT_EXPR_P (exp))

gcc/testsuite/ChangeLog

 2019-10-12  Jakub Jelinek  <jakub@redhat.com>
 
+	PR middle-end/92063
+	* gcc.c-torture/compile/pr92063.c: New test.
+
 	* c-c++-common/gomp/declare-variant-2.c: Adjust for error recovery
 	improvements.  Add new tests.
 	* c-c++-common/gomp/declare-variant-4.c: New test.

gcc/testsuite/gcc.c-torture/compile/pr92063.c

+/* PR middle-end/92063 */
+
+int
+foo (int a, int b, int *c, short *d)
+{
+  return (c[0] ? b : 0) == 'y' && ((a ? d[0] : c[0]) ? b : 0) == 'c';
+}

gcc/tree-eh.c

@@ -2499,6 +2499,14 @@ operation_could_trap_helper_p (enum tree_code op,
       /* Constructing an object cannot trap.  */
       return false;
 
+    case COND_EXPR:
+    case VEC_COND_EXPR:
+      /* Whether *COND_EXPR can trap depends on whether the
+	 first argument can trap, so signal it as not handled.
+	 Whether lhs is floating or not doesn't matter.  */
+      *handled = false;
+      return false;
+
     default:
       /* Any floating arithmetic may trap.  */
       if (fp_operation && flag_trapping_math)
@@ -2614,9 +2622,12 @@ tree_could_trap_p (tree expr)
   if (!expr)
     return false;
 
-  /* For COND_EXPR and VEC_COND_EXPR only the condition may trap.  */
+  /* In COND_EXPR and VEC_COND_EXPR only the condition may trap, but
+     they won't appear as operands in GIMPLE form, so this is just for the
+     GENERIC uses where it needs to recurse on the operands and so
+     *COND_EXPR itself doesn't trap.  */
   if (TREE_CODE (expr) == COND_EXPR || TREE_CODE (expr) == VEC_COND_EXPR)
-    expr = TREE_OPERAND (expr, 0);
+    return false;
 
   code = TREE_CODE (expr);
   t = TREE_TYPE (expr);

gcc/tree-ssa-sccvn.c

@@ -5105,18 +5105,15 @@ vn_nary_may_trap (vn_nary_op_t nary)
 	  honor_nans = flag_trapping_math && !flag_finite_math_only;
 	  honor_snans = flag_signaling_nans != 0;
 	}
-      else if (INTEGRAL_TYPE_P (type)
-	       && TYPE_OVERFLOW_TRAPS (type))
+      else if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type))
 	honor_trapv = true;
     }
   if (nary->length >= 2)
     rhs2 = nary->op[1];
   ret = operation_could_trap_helper_p (nary->opcode, fp_operation,
-				       honor_trapv,
-				       honor_nans, honor_snans, rhs2,
-				       &handled);
-  if (handled
-      && ret)
+				       honor_trapv, honor_nans, honor_snans,
+				       rhs2, &handled);
+  if (handled && ret)
     return true;
 
   for (i = 0; i < nary->length; ++i)