2016-09-27 Richard Biener <rguenther@suse.de>

	Backport from mainline
	2016-09-01  Richard Biener  <rguenther@suse.de>

	PR middle-end/77436
	* tree-chrec.c (tree_fold_binomial): Use widest_int, properly
	check whether the result fits the desired result type.

	* gcc.dg/torture/pr77436.c: New testcase.

	2016-09-06  Richard Biener  <rguenther@suse.de>

	PR c/77450
	c-family/
	* c-common.c (c_common_mark_addressable_vec): Handle
	COMPOUND_LITERAL_EXPR.

	* gcc.dg/pr77450.c: New testcase.

	2016-09-19  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/77514
	* tree-ssa-pre.c (create_expression_by_pieces): Optimize
	search for folded stmt.

	2016-09-15  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/77514
	* tree-ssa-pre.c (create_expression_by_pieces): Handle garbage
	only forced_stmts sequence.

	* gcc.dg/torture/pr77514.c: New testcase.

	2016-09-15  Richard Biener  <rguenther@suse.de>

	PR middle-end/77544
	* fold-const.c (split_tree): Do not split constant ~X.

	* c-c++-common/torture/pr77544.c: New testcase.

	2016-09-19  Richard Biener  <rguenther@suse.de>

	PR middle-end/77605
	* tree-data-ref.c (analyze_subscript_affine_affine): Use the
	proper niter to bound the loops.

	* gcc.dg/torture/pr77605.c: New testcase.

	2016-09-22  Richard Biener  <rguenther@suse.de>
 
	PR middle-end/77679
	* gimple-fold.c (fold_array_ctor_reference): Turn asserts into
	fold fails.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/gcc-6-branch@240527 138bc75d-0d04-0410-961f-82ee72b054a4

14 files changed, 181 insertions, 19 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 9cfbc33ef20..e30042c38a5 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,41 @@
+2016-09-27  Richard Biener  <rguenther@suse.de>
+
+	Backport from mainline
+	2016-09-01  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/77436
+	* tree-chrec.c (tree_fold_binomial): Use widest_int, properly
+	check whether the result fits the desired result type.
+
+	2016-09-19  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/77514
+	* tree-ssa-pre.c (create_expression_by_pieces): Optimize
+	search for folded stmt.
+
+	2016-09-15  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/77514
+	* tree-ssa-pre.c (create_expression_by_pieces): Handle garbage
+	only forced_stmts sequence.
+
+	2016-09-15  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/77544
+	* fold-const.c (split_tree): Do not split constant ~X.
+
+	2016-09-19  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/77605
+	* tree-data-ref.c (analyze_subscript_affine_affine): Use the
+	proper niter to bound the loops.
+
+	2016-09-22  Richard Biener  <rguenther@suse.de>
+ 
+	PR middle-end/77679
+	* gimple-fold.c (fold_array_ctor_reference): Turn asserts into
+	fold fails.
+
 2016-09-25  Uros Bizjak  <ubizjak@gmail.com>
 
 	Backport from mainline
diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index 6c01fa84e11..f21e176ac87 100644
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,12 @@
+2016-09-27  Richard Biener  <rguenther@suse.de>
+
+	Backport from mainline
+	2016-09-06  Richard Biener  <rguenther@suse.de>
+
+	PR c/77450
+	* c-common.c (c_common_mark_addressable_vec): Handle
+	COMPOUND_LITERAL_EXPR.
+
 2016-09-13  Tom de Vries  <tom@codesourcery.com>
 
 	backport from trunk:
diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 1e5362608d6..d2e3ad46a01 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -10679,7 +10679,9 @@ c_common_mark_addressable_vec (tree t)
 {   
   while (handled_component_p (t))
     t = TREE_OPERAND (t, 0);
-  if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
+  if (!VAR_P (t)
+      && TREE_CODE (t) != PARM_DECL
+      && TREE_CODE (t) != COMPOUND_LITERAL_EXPR)
     return;
   TREE_ADDRESSABLE (t) = 1;
 }
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 6700b765868..95b008030ef 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -837,15 +837,16 @@ split_tree (location_t loc, tree in, tree type, enum tree_code code,
 	  var = negate_expr (var);
 	}
     }
+  else if (TREE_CONSTANT (in))
+    *conp = in;
   else if (TREE_CODE (in) == BIT_NOT_EXPR
 	   && code == PLUS_EXPR)
     {
-      /* -X - 1 is folded to ~X, undo that here.  */
+      /* -X - 1 is folded to ~X, undo that here.  Do _not_ do this
+         when IN is constant.  */
       *minus_litp = build_one_cst (TREE_TYPE (in));
       var = negate_expr (TREE_OPERAND (in, 0));
     }
-  else if (TREE_CONSTANT (in))
-    *conp = in;
   else
     var = in;
 
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 7a6395c00eb..ef2ea8f7654 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -5381,14 +5381,15 @@ fold_array_ctor_reference (tree type, tree ctor,
   if (domain_type && TYPE_MIN_VALUE (domain_type))
     {
       /* Static constructors for variably sized objects makes no sense.  */
-      gcc_assert (TREE_CODE (TYPE_MIN_VALUE (domain_type)) == INTEGER_CST);
+      if (TREE_CODE (TYPE_MIN_VALUE (domain_type)) != INTEGER_CST)
+	return NULL_TREE;
       low_bound = wi::to_offset (TYPE_MIN_VALUE (domain_type));
     }
   else
     low_bound = 0;
   /* Static constructors for variably sized objects makes no sense.  */
-  gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor))))
-	      == INTEGER_CST);
+  if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))) != INTEGER_CST)
+    return NULL_TREE;
   elt_size = wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor))));
 
   /* We can handle only constantly sized accesses that are known to not
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 3afe2fe08b0..e8bda55546e 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,31 @@
+2016-09-27  Richard Biener  <rguenther@suse.de>
+
+	Backport from mainline
+	2016-09-01  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/77436
+	* gcc.dg/torture/pr77436.c: New testcase.
+
+	2016-09-06  Richard Biener  <rguenther@suse.de>
+
+	PR c/77450
+	* gcc.dg/pr77450.c: New testcase.
+
+	2016-09-15  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/77514
+	* gcc.dg/torture/pr77514.c: New testcase.
+
+	2016-09-15  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/77544
+	* c-c++-common/torture/pr77544.c: New testcase.
+
+	2016-09-19  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/77605
+	* gcc.dg/torture/pr77605.c: New testcase.
+
 2016-09-25  Uros Bizjak  <ubizjak@gmail.com>
 
 	Backport from mainline
diff --git a/gcc/testsuite/c-c++-common/torture/pr77544.c b/gcc/testsuite/c-c++-common/torture/pr77544.c
new file mode 100644
index 00000000000..1d1ce3ff74f
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/torture/pr77544.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+
+struct {
+  long a : 17;
+} b;
+int c, d;
+void e() { b.a = d + c + ~(long)(302806U >> 0); }
diff --git a/gcc/testsuite/gcc.dg/pr77450.c b/gcc/testsuite/gcc.dg/pr77450.c
new file mode 100644
index 00000000000..7c19e86ca02
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr77450.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu90" } */
+
+typedef int V __attribute__((vector_size(4)));
+
+void
+foo(void)
+{
+  (V){ 0 }[0] = 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr77436.c b/gcc/testsuite/gcc.dg/torture/pr77436.c
new file mode 100644
index 00000000000..513867db7ce
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr77436.c
@@ -0,0 +1,11 @@
+/* { dg-do run } */
+
+int main()
+{
+  unsigned short sum = 0;
+  for (short x = -(__SHRT_MAX__ -1); x <= (__SHRT_MAX__ -1); x++)
+    sum += x;
+  if (sum != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr77514.c b/gcc/testsuite/gcc.dg/torture/pr77514.c
new file mode 100644
index 00000000000..464841ce364
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr77514.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+
+void
+m1 (char l0, char e8, int hw)
+{
+  char *rs = &l0;
+
+yu:
+  l0 = 1;
+  while (l0 != 0)
+    {
+      l0 = -l0;
+      l0 += (*rs ^ (l0 &= 1));
+    }
+  for (;;)
+    {
+      if (hw != 0)
+	goto yu;
+      rs = &e8;
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr77605.c b/gcc/testsuite/gcc.dg/torture/pr77605.c
new file mode 100644
index 00000000000..3f1a26bc8d5
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr77605.c
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+
+int a, b, c[2][8];
+
+int main ()
+{
+  for (a = 0; a < 8; a++)
+    for (b = 0; b < 2; b++)
+      c[b][a] = c[b][b + 6] ^ 1;
+
+  if (c[0][7] != 0) 
+    __builtin_abort ();
+
+  return 0; 
+}
diff --git a/gcc/tree-chrec.c b/gcc/tree-chrec.c
index ee789a2436f..007243d77d9 100644
--- a/gcc/tree-chrec.c
+++ b/gcc/tree-chrec.c
@@ -484,7 +484,6 @@ tree_fold_binomial (tree type, tree n, unsigned int k)
 {
   bool overflow;
   unsigned int i;
-  tree res;
 
   /* Handle the most frequent cases.  */
   if (k == 0)
@@ -492,18 +491,20 @@ tree_fold_binomial (tree type, tree n, unsigned int k)
   if (k == 1)
     return fold_convert (type, n);
 
+  widest_int num = wi::to_widest (n);
+
   /* Check that k <= n.  */
-  if (wi::ltu_p (n, k))
+  if (wi::ltu_p (num, k))
     return NULL_TREE;
 
   /* Denominator = 2.  */
-  wide_int denom = wi::two (TYPE_PRECISION (TREE_TYPE (n)));
+  widest_int denom = 2;
 
   /* Index = Numerator-1.  */
-  wide_int idx = wi::sub (n, 1);
+  widest_int idx = num - 1;
 
   /* Numerator = Numerator*Index = n*(n-1).  */
-  wide_int num = wi::smul (n, idx, &overflow);
+  num = wi::smul (num, idx, &overflow);
   if (overflow)
     return NULL_TREE;
 
@@ -522,9 +523,10 @@ tree_fold_binomial (tree type, tree n, unsigned int k)
     }
 
   /* Result = Numerator / Denominator.  */
-  wide_int di_res = wi::udiv_trunc (num, denom);
-  res = wide_int_to_tree (type, di_res);
-  return int_fits_type_p (res, type) ? res : NULL_TREE;
+  num = wi::udiv_trunc (num, denom);
+  if (! wi::fits_to_tree_p (num, type))
+    return NULL_TREE;
+  return wide_int_to_tree (type, num);
 }
 
 /* Helper function.  Use the Newton's interpolating formula for
diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index d6d9ffcaa34..f321fdda53e 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -2680,13 +2680,13 @@ analyze_subscript_affine_affine (tree chrec_a,
 
 	      if (niter > 0)
 		{
-		  HOST_WIDE_INT tau2 = MIN (FLOOR_DIV (niter - i0, i1),
-					    FLOOR_DIV (niter - j0, j1));
+		  HOST_WIDE_INT tau2 = MIN (FLOOR_DIV (niter_a - i0, i1),
+					    FLOOR_DIV (niter_b - j0, j1));
 		  HOST_WIDE_INT last_conflict = tau2 - (x1 - i0)/i1;
 
 		  /* If the overlap occurs outside of the bounds of the
 		     loop, there is no dependence.  */
-		  if (x1 >= niter || y1 >= niter)
+		  if (x1 >= niter_a || y1 >= niter_b)
 		    {
 		      *overlaps_a = conflict_fn_no_dependence ();
 		      *overlaps_b = conflict_fn_no_dependence ();
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index e4e6d998461..c35806a9332 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -2896,7 +2896,24 @@ create_expression_by_pieces (basic_block block, pre_expr expr,
       gimple_seq_discard (forced_stmts);
       return folded;
     }
-
+  /* Likewise if we simplified to sth not queued for insertion.  */
+  bool found = false;
+  gsi = gsi_last (forced_stmts);
+  for (; !gsi_end_p (gsi); gsi_prev (&gsi))
+    {
+      gimple *stmt = gsi_stmt (gsi);
+      tree forcedname = gimple_get_lhs (stmt);
+      if (forcedname == folded)
+	{
+	  found = true;
+	  break;
+	}
+    }
+  if (! found)
+    {
+      gimple_seq_discard (forced_stmts);
+      return folded;
+    }
   gcc_assert (TREE_CODE (folded) == SSA_NAME);
 
   /* If we have any intermediate expressions to the value sets, add them