* tree-data-ref.c (analyze_subscript_affine_affine): Correctly

	compute the first overlapping iterations.

	PR middle-end/18005
	* tree-data-ref.c (estimate_niter_from_size_of_data): Ensure
	that arguments of EXACT_DIV_EXPR are INTEGER_CST.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@90510 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 492c501..3ed9d24 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+2004-11-12  Sebastian Pop  <pop@cri.ensmp.fr>
+
+       * tree-data-ref.c (analyze_subscript_affine_affine): Correctly
+       compute the first overlapping iterations.
+
+2004-11-12  Sebastian Pop  <pop@cri.ensmp.fr>
+
+       PR middle-end/18005
+       * tree-data-ref.c (estimate_niter_from_size_of_data): Ensure 
+       that arguments of EXACT_DIV_EXPR are INTEGER_CST.
+
 2004-11-12  Steven Bosscher  <stevenb@suse.de>
 
        PR tree-optimization/18419

diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index 3c88346..718059f 100644 (file)
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -513,11 +513,12 @@ estimate_niter_from_size_of_data (struct loop *loop,
   array_size = TYPE_SIZE (TREE_TYPE (opnd0));
   element_size = TYPE_SIZE (TREE_TYPE (TREE_TYPE (opnd0)));
   if (array_size == NULL_TREE 
-      || element_size == NULL_TREE)
+      || TREE_CODE (array_size) != INTEGER_CST
+      || TREE_CODE (element_size) != INTEGER_CST)
     return;
 
   data_size = fold (build2 (EXACT_DIV_EXPR, integer_type_node, 
-                          array_size, element_size));
+                           array_size, element_size));
 
   if (init != NULL_TREE
       && step != NULL_TREE
@@ -1435,12 +1436,21 @@ analyze_subscript_affine_affine (tree chrec_a,
 
                  if (j1 > 0)
                    {
-                     int last_conflict;
+                     int last_conflict, min_multiple;
                      tau1 = MAX (tau1, CEIL (-j0, j1));
                      tau2 = MIN (tau2, FLOOR_DIV (niter - j0, j1));
 
-                     x0 = (i1 * tau1 + i0) % i1;
-                     y0 = (j1 * tau1 + j0) % j1;
+                     x0 = i1 * tau1 + i0;
+                     y0 = j1 * tau1 + j0;
+
+                     /* At this point (x0, y0) is one of the
+                        solutions to the Diophantine equation.  The
+                        next step has to compute the smallest
+                        positive solution: the first conflicts.  */
+                     min_multiple = MIN (x0 / i1, y0 / j1);
+                     x0 -= i1 * min_multiple;
+                     y0 -= j1 * min_multiple;
+
                      tau1 = (x0 - i0)/i1;
                      last_conflict = tau2 - tau1;