re PR c/57821 ('array is too large' error is missing when sizetype overflows)

gcc/c:
        PR c/57821
        * c-typeck.c (set_init_index): When folding, check for index overflow.
gcc/c-family:
        PR c/57821
        * c-common.c (complete_array_type): Delay folding first index
        like other indices.  When folding, check for index overflow.
gcc/testsuite:
        PR c/57821
        * gcc.dg/large-size-array-6.c: New test.

From-SVN: r200683

gcc/c-family/ChangeLog

+2013-07-04  Joern Rennecke <joern.rennecke@embecosm.com>
+
+	PR c/57821
+	* c-common.c (complete_array_type): Delay folding first index
+	like other indices.  When folding, check for index overflow.
+
 2013-06-27  Marc Glisse  <marc.glisse@inria.fr>
 
 	PR c++/57509

gcc/c-family/c-common.c

@@ -9781,6 +9781,7 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
   tree maxindex, type, main_type, elt, unqual_elt;
   int failure = 0, quals;
   hashval_t hashcode = 0;
+  bool overflow_p = false;
 
   maxindex = size_zero_node;
   if (initial_value)
@@ -9809,8 +9810,8 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
 	      bool fold_p = false;
 
 	      if ((*v)[0].index)
-		maxindex = fold_convert_loc (input_location, sizetype,
-					     (*v)[0].index);
+		maxindex = (*v)[0].index, fold_p = true;
+
 	      curindex = maxindex;
 
 	      for (cnt = 1; vec_safe_iterate (v, cnt, &ce); cnt++)
@@ -9821,15 +9822,26 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
 		  else
 		    {
 		      if (fold_p)
-		        curindex = fold_convert (sizetype, curindex);
+			{
+			  /* Since we treat size types now as ordinary
+			     unsigned types, we need an explicit overflow
+			     check.  */
+			  tree orig = curindex;
+		          curindex = fold_convert (sizetype, curindex);
+			  overflow_p |= tree_int_cst_lt (curindex, orig);
+			}
 		      curindex = size_binop (PLUS_EXPR, curindex,
 					     size_one_node);
 		    }
 		  if (tree_int_cst_lt (maxindex, curindex))
 		    maxindex = curindex, fold_p = curfold_p;
 		}
-	       if (fold_p)
-	         maxindex = fold_convert (sizetype, maxindex);
+	      if (fold_p)
+		{
+		  tree orig = maxindex;
+	          maxindex = fold_convert (sizetype, maxindex);
+		  overflow_p |= tree_int_cst_lt (maxindex, orig);
+		}
 	    }
 	}
       else
@@ -9890,7 +9902,7 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
 
   if (COMPLETE_TYPE_P (type)
       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
-      && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
+      && (overflow_p || TREE_OVERFLOW (TYPE_SIZE_UNIT (type))))
     {
       error ("size of array is too large");
       /* If we proceed with the array type as it is, we'll eventually

gcc/c/ChangeLog

+2013-07-04  Joern Rennecke <joern.rennecke@embecosm.com>
+
+	PR c/57821
+	* c-typeck.c (set_init_index): When folding, check for index overflow.
+
 2013-06-28  Balaji V. Iyer  <balaji.v.iyer@intel.com>
 
 	* c-parser.c (c_parser_array_notation): Removed rejection of array

gcc/c/c-typeck.c

@@ -7217,6 +7217,11 @@ set_init_index (tree first, tree last,
       if (last)
 	constant_expression_warning (last);
       constructor_index = convert (bitsizetype, first);
+      if (tree_int_cst_lt (constructor_index, first))
+	{
+	  constructor_index = copy_node (constructor_index);
+	  TREE_OVERFLOW (constructor_index) = 1;
+	}
 
       if (last)
 	{

gcc/testsuite/ChangeLog

+2013-07-04  Joern Rennecke <joern.rennecke@embecosm.com>
+
+	PR c/57821
+	* gcc.dg/large-size-array-6.c: New test.
+
 2013-07-04  Paolo Carlini  <paolo.carlini@oracle.com>
 
 	PR c++/38634

gcc/testsuite/gcc.dg/large-size-array-6.c

+/* PR c/57821 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+static char * name[] = {
+    [0x8000000000000000]  = "bar"
+  }; /* { dg-error "too large" } */