Re: [PATCH] Use size_type_node instead of sizetype for stride overflow checking (PR fortran/46945)

[Jakub Jelinek <jakub@redhat.com>]

On Wed, Dec 15, 2010 at 08:22:20PM +0200, Janne Blomqvist wrote:
> You've converted size_zero_node into build_int_cst (size_type_node,
> 0), but you missed one case, so I presume you'd want

Thanks for catching it up.
This is what I've actually committed (note, I've also added cond temporary
so that the 80 chars length limit wouldn't be so big issue:

--- fortran/ChangeLog	(revision 167870)
+++ fortran/ChangeLog	(working copy)
@@ -1,3 +1,11 @@
+2010-12-15  Jakub Jelinek  <jakub@redhat.com>
+
+	PR fortran/46945
+	* trans-array.c (gfc_array_init_size): Perform stride overflow
+	checking and multiplication by element_size in size_type_node instead
+	of sizetype, return value with size_type_node type instead of
+	sometimes with sizetype and sometimes with gfc_array_index_type.
+
 2010-12-15  Janne Blomqvist  <jb@gcc.gnu.org>
 
 	* trans.c (gfc_allocate_with_status): Better error message for
--- testsuite/ChangeLog	(revision 167870)
+++ testsuite/ChangeLog	(working copy)
@@ -1,5 +1,8 @@
 2010-12-15  Jakub Jelinek  <jakub@redhat.com>
 
+	PR fortran/46945
+	* gfortran.dg/pr46945.f90: New test.
+
 	PR debug/46815
 	* g++.dg/guality/pr46815.C: New test.
 
--- fortran/trans-array.c	(revision 167870)
+++ fortran/trans-array.c	(working copy)
@@ -4006,6 +4006,7 @@ gfc_array_init_size (tree descriptor, in
   tree or_expr;
   tree thencase;
   tree elsecase;
+  tree cond;
   tree var;
   stmtblock_t thenblock;
   stmtblock_t elseblock;
@@ -4091,17 +4092,15 @@ gfc_array_init_size (tree descriptor, in
 			     fold_convert (gfc_array_index_type, 
 					   TYPE_MAX_VALUE (gfc_array_index_type)),
 					   size);
-      tmp = fold_build3_loc 
-	(input_location, COND_EXPR, integer_type_node,
-	 gfc_unlikely (fold_build2_loc (input_location, LT_EXPR, 
-					boolean_type_node, tmp, stride)),
-	 integer_one_node, integer_zero_node);
-      tmp = fold_build3_loc 
-	(input_location, COND_EXPR, integer_type_node,
-	 gfc_unlikely (fold_build2_loc (input_location, EQ_EXPR,
-					boolean_type_node, size, 
-					build_zero_cst (gfc_array_index_type))),
-	 integer_zero_node, tmp);
+      cond = gfc_unlikely (fold_build2_loc (input_location, LT_EXPR,
+					    boolean_type_node, tmp, stride));
+      tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node, cond,
+			     integer_one_node, integer_zero_node);
+      cond = gfc_unlikely (fold_build2_loc (input_location, EQ_EXPR,
+					    boolean_type_node, size,
+					    gfc_index_zero_node));
+      tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node, cond,
+			     integer_zero_node, tmp);
       tmp = fold_build2_loc (input_location, PLUS_EXPR, integer_type_node,
 			     *overflow, tmp);
       *overflow = gfc_evaluate_now (tmp, pblock);
@@ -4154,31 +4153,29 @@ gfc_array_init_size (tree descriptor, in
      size of an element to get the total size.  */
   tmp = TYPE_SIZE_UNIT (gfc_get_element_type (type));
   /* Convert to size_t.  */
-  element_size = fold_convert (sizetype, tmp);
-  stride = fold_convert (sizetype, stride);
+  element_size = fold_convert (size_type_node, tmp);
+  stride = fold_convert (size_type_node, stride);
 
   /* First check for overflow. Since an array of type character can
      have zero element_size, we must check for that before
      dividing.  */
   tmp = fold_build2_loc (input_location, TRUNC_DIV_EXPR, 
-			 sizetype, 
-			 TYPE_MAX_VALUE (sizetype), element_size);
-  tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node,
-			 gfc_unlikely (fold_build2_loc (input_location, LT_EXPR, 
-							boolean_type_node, tmp, 
-							stride)),
+			 size_type_node,
+			 TYPE_MAX_VALUE (size_type_node), element_size);
+  cond = gfc_unlikely (fold_build2_loc (input_location, LT_EXPR,
+					boolean_type_node, tmp, stride));
+  tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node, cond,
 			 integer_one_node, integer_zero_node);
-  tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node,
-			 gfc_unlikely (fold_build2_loc (input_location, EQ_EXPR,
-							boolean_type_node, 
-							element_size, 
-							size_zero_node)),
+  cond = gfc_unlikely (fold_build2_loc (input_location, EQ_EXPR,
+					boolean_type_node, element_size,
+					build_int_cst (size_type_node, 0)));
+  tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node, cond,
 			 integer_zero_node, tmp);
   tmp = fold_build2_loc (input_location, PLUS_EXPR, integer_type_node,
 			 *overflow, tmp);
   *overflow = gfc_evaluate_now (tmp, pblock);
 
-  size = fold_build2_loc (input_location, MULT_EXPR, sizetype,
+  size = fold_build2_loc (input_location, MULT_EXPR, size_type_node,
 			  stride, element_size);
 
   if (poffset != NULL)
@@ -4190,11 +4187,11 @@ gfc_array_init_size (tree descriptor, in
   if (integer_zerop (or_expr))
     return size;
   if (integer_onep (or_expr))
-    return gfc_index_zero_node;
+    return build_int_cst (size_type_node, 0);
 
   var = gfc_create_var (TREE_TYPE (size), "size");
   gfc_start_block (&thenblock);
-  gfc_add_modify (&thenblock, var, size_zero_node);
+  gfc_add_modify (&thenblock, var, build_int_cst (size_type_node, 0));
   thencase = gfc_finish_block (&thenblock);
 
   gfc_start_block (&elseblock);
--- testsuite/gfortran.dg/pr46945.f90	(revision 0)
+++ testsuite/gfortran.dg/pr46945.f90	(revision 0)
@@ -0,0 +1,10 @@
+! PR fortran/46945
+! { dg-do run }
+! { dg-options "-O -ftree-vrp -fno-tree-ccp -fno-tree-fre" }
+
+program pr46945
+  real, allocatable :: a(:,:,:)
+  integer :: n
+  n = 0
+  allocate (a(n,n,n))
+end program pr46945


	Jakub