[graphite] Remove checks for flag_loop_strip_mine, flag_loop_block, flag_loop_interchange in graphite_trans_bb_block.

[Tobias Grosser <grosser at fim dot uni-passau dot de>]

Hi graphities, hi world,

as we are discussing about merging graphite to trunk, I think more people
will be interested in graphite changes. So I will send all my patches
to gcc-patches.

Have fun and follow the graphite development!

I worked on the last remaining polyhedron problems reported by Jack. Now
graphite compiles all polyhedron test cases.
(BTW: Jack, thanks for testing graphite so much)

Problem:

In some functions graphite failed with the options ï-floop-strip-mine
-floop-interchange -floop-block enabled.


Details:

1. -floop-block:
We check for strip_mine_profitable_p, while doing the transformations.
So we can end up e.g. to just stripe mine every second loop, if the first is
profitable and the second is not. This might be a valid transformation, but
it seems, that nobody thought about the effects until know, as the current code
leads to index out of bound exceptions.

Solution: I check all loops, and only apply the transformation, if strip mining
is profitable for all loops.

2. ï-floop-strip-mine -floop-interchange:

They where implemented as -floop-block with disabled strip-mining or loop
interchange. This does not make sense as they need different heuristics.

Solution: We ignore these options and I will implement them in the next
days. 

ïPatch: graphite-trans_bb_block_polyhedron_fixes_2008-08-14.patch

This patch also contains a test case, that triggered this error.

See you
Tobi

2008-08-14  Tobias Grosser  <grosser@fim.uni-passau.de>

        * graphite.c (graphite_trans_bb_block): Remove check for
        flag_loop_strip_mine, flag_loop_block, flag_loop_interchange.
        Check if loop blocking is profitable for every loop, before applying
	the changes.
	(graphite_apply_transformations): Call graphite_trans_bb_block only,
	if flag_loop_block is set.
	
	* testsuite/gcc.dg/graphite/scop-19.c: Add testcase to reproduce
	bug in broken -floop-block found with polyhedron.
diff --git a/gcc/graphite.c b/gcc/graphite.c
index a51139c..a9ec55f 100644
--- a/gcc/graphite.c
+++ b/gcc/graphite.c
@@ -4414,42 +4414,34 @@ graphite_trans_bb_block (graphite_bb_p gb, int stride, int loops)
   int start = nb_loops - loops;
   scop_p scop = GBB_SCOP (gb);
   int outer_most_loop_index_for_gb;
-  bool transform_done = false;
-
-  if (!scop_contains_loop (scop, gbb_loop (gb)))
-    return transform_done;
 
-  outer_most_loop_index_for_gb = gbb_outer_most_loop_index (scop, gb);
+  gcc_assert (scop_contains_loop (scop, gbb_loop (gb)));
 
-  for (i = outer_most_loop_index_for_gb; i < outer_most_loop_index_for_gb + loops; i++)
-    for (j = i + 1; j < outer_most_loop_index_for_gb + loops; j++)
+  for (i = start ; i < nb_loops; i++)
+    for (j = i + 1; j < nb_loops; j++)
       if (!is_interchange_valid (scop, i, j))
 	{
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    fprintf (dump_file, "\nInterchange not valid for loops %d and %d:\n", i, j);
-	  return transform_done;
+	  return false;
 	}
       else if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "\nInterchange valid for loops %d and %d:\n", i, j);
 
+  /* Check, if strip mining is profitable for every loop.  */
+  for (i = 0; i < nb_loops - start; i++)
+    if (!strip_mine_profitable_p (gb, stride, start + i))
+      return false;
+
   /* Strip mine loops.  */
   for (i = 0; i < nb_loops - start; i++)
-    if ((flag_loop_block || flag_loop_strip_mine)
-	&& strip_mine_profitable_p (gb, stride, start + 2 * i))
-      {
-	graphite_trans_bb_strip_mine (gb, start + 2 * i, stride);
-	transform_done = true;
-      }
+    graphite_trans_bb_strip_mine (gb, start + 2 * i, stride);
 
   /* Interchange loops.  */
   for (i = 1; i < nb_loops - start; i++)
-    if (flag_loop_block || flag_loop_interchange)
-      {
-	graphite_trans_bb_move_loop (gb, start + 2 * i, start + i);
-	transform_done = true;
-      }
+    graphite_trans_bb_move_loop (gb, start + 2 * i, start + i);
 
-  return transform_done;
+  return true;
 }
 
 /*******************************************************************************
@@ -4469,7 +4461,8 @@ graphite_trans_loop_block (VEC (graphite_bb_p, heap) *bbs, int loops)
   int stride_size = 64;
 
   for (i = 0; VEC_iterate (graphite_bb_p, bbs, i, gb); i++)
-    transform_done = graphite_trans_bb_block (gb, stride_size, loops) || transform_done;
+    transform_done |= graphite_trans_bb_block (gb, stride_size, loops);
+
   return transform_done;
 }
 
@@ -4613,9 +4606,7 @@ graphite_apply_transformations (scop_p scop)
   graphite_sort_gbbs (scop);
   scop_remove_ignoreable_gbbs (scop);
 
-  if (flag_loop_block
-      || flag_loop_strip_mine
-      || flag_loop_interchange)
+  if (flag_loop_block)
     transform_done = graphite_trans_scop_block (scop);
 
   return transform_done;
diff --git a/gcc/testsuite/gcc.dg/graphite/scop-19.c b/gcc/testsuite/gcc.dg/graphite/scop-19.c
new file mode 100644
index 0000000..9fd3a36
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/scop-19.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -floop-block -fdump-tree-graphite-all" } */
+
+#define N 24
+#define M 1000
+
+void test (float *A)
+{
+  int i, j, k, l;
+
+  for (i = 0; i < N; i++)
+    for (j = 0; j < N; j++)
+      for (k = 0; k < N; k++)
+        for (l = 0; l < M; l++)
+          A[i+j+k+l] = 12;
+}
+
+/* Strip Mining is not profitable for loops 0, 1 and 2. */
+
+/* { dg-final { cleanup-tree-dump "graphite" } } */