This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: Preliminary patch for PR23820 and PR24309
On 10/12/07, Sebastian Pop <sebpop@gmail.com> wrote:
> Do we have an option to XFAIL ltrans-3.c? And of course, file an
> optimization PR
As we know that we can fix this optimization PR, and because I still
don't see how to implement a solution for that optimization PR, and
because the patch that I'm attaching, with ltrans-3 XFAIL-ed, passes
bootstrap and test on amd64-linux fixing three ICE PRs 23820, 24309,
and 33766, is the patch okay for trunk?
After this patch, as we won't have other PRs open on the loop
interchange (otherwise ping me on these and I'll give them a look),
would it be possible to enable loop interchange at -O3 or -O2 level?
Thanks,
Sebastian
Index: tree-loop-linear.c
===================================================================
--- tree-loop-linear.c (revision 129276)
+++ tree-loop-linear.c (working copy)
@@ -244,6 +244,46 @@ try_interchange_loops (lambda_trans_matr
return trans;
}
+/* Return the number of nested loops in LOOP_NEST, or 0 if the loops
+ are not perfectly nested. */
+
+static unsigned int
+perfect_loop_nest_depth (struct loop *loop_nest)
+{
+ struct loop *temp;
+ unsigned int depth = 1;
+
+ /* If it's not a loop nest, we don't want it. We also don't handle
+ sibling loops properly, which are loops of the following form:
+
+ | for (i = 0; i < 50; i++)
+ | {
+ | for (j = 0; j < 50; j++)
+ | {
+ | ...
+ | }
+ | for (j = 0; j < 50; j++)
+ | {
+ | ...
+ | }
+ | }
+ */
+
+ if (!loop_nest->inner || !single_exit (loop_nest))
+ return 0;
+
+ for (temp = loop_nest->inner; temp; temp = temp->inner)
+ {
+ /* If we have a sibling loop or multiple exit edges, jump ship. */
+ if (temp->next || !single_exit (temp))
+ return 0;
+
+ depth++;
+ }
+
+ return depth;
+}
+
/* Perform a set of linear transforms on loops. */
void
@@ -263,47 +303,18 @@ linear_transform_loops (void)
unsigned int depth = 0;
VEC (ddr_p, heap) *dependence_relations;
VEC (data_reference_p, heap) *datarefs;
- struct loop *temp;
lambda_loopnest before, after;
lambda_trans_matrix trans;
- bool problem = false;
struct obstack lambda_obstack;
gcc_obstack_init (&lambda_obstack);
- /* If it's not a loop nest, we don't want it.
- We also don't handle sibling loops properly,
- which are loops of the following form:
- for (i = 0; i < 50; i++)
- {
- for (j = 0; j < 50; j++)
- {
- ...
- }
- for (j = 0; j < 50; j++)
- {
- ...
- }
- } */
- if (!loop_nest->inner || !single_exit (loop_nest))
+ depth = perfect_loop_nest_depth (loop_nest);
+ if (depth == 0)
continue;
+
VEC_truncate (tree, oldivs, 0);
VEC_truncate (tree, invariants, 0);
- depth = 1;
- for (temp = loop_nest->inner; temp; temp = temp->inner)
- {
- /* If we have a sibling loop or multiple exit edges, jump ship. */
- if (temp->next || !single_exit (temp))
- {
- problem = true;
- break;
- }
- depth ++;
- }
- if (problem)
- continue;
- /* Analyze data references and dependence relations using scev. */
-
datarefs = VEC_alloc (data_reference_p, heap, 10);
dependence_relations = VEC_alloc (ddr_p, heap, 10 * 10);
compute_data_dependences_for_loop (loop_nest, true, &datarefs,
Index: testsuite/gcc.dg/tree-ssa/pr23820.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/pr23820.c (revision 0)
+++ testsuite/gcc.dg/tree-ssa/pr23820.c (revision 0)
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+int t [2][4];
+
+void foo (void)
+{
+ int i, j, k, v;
+ float e;
+ for (;;)
+ {
+ v = 0;
+ for (j = 0; j < 2; j ++)
+ {
+ for (k = 2; k < 4; k ++)
+ {
+ e = 0.0;
+ for (i = 0; i < 4; i ++)
+ e += t [j][i];
+ if (e)
+ v = j;
+ }
+ }
+ t [v][0] = 0;
+ }
+}
Index: testsuite/gcc.dg/tree-ssa/ltrans-3.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/ltrans-3.c (revision 129276)
+++ testsuite/gcc.dg/tree-ssa/ltrans-3.c (working copy)
@@ -17,5 +17,5 @@ int foo(int N, int *res)
*res = sum + N;
}
-/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */
+/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans" { xfail *-*-* } } } */
/* { dg-final { cleanup-tree-dump "ltrans" } } */
Index: testsuite/gcc.dg/tree-ssa/pr33766.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/pr33766.c (revision 0)
+++ testsuite/gcc.dg/tree-ssa/pr33766.c (revision 0)
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+float
+fxt1_quantize_ALPHA1()
+{
+ int j1;
+ int i;
+ float *tv;
+ for (j1 = 1; j1; j1++) {
+ float e;
+ for (i = 1; i; i++)
+ e = tv[i];
+ if (e)
+ i = j1;
+ }
+ return tv[i];
+}
+
Index: testsuite/gcc.dg/tree-ssa/pr24309.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/pr24309.c (revision 0)
+++ testsuite/gcc.dg/tree-ssa/pr24309.c (revision 0)
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+float weight[10];
+void lsp_weight_quant(float *x, char *cdbk)
+{
+ int i,j;
+ float dist;
+ int best_id=0;
+ for (i=0;i<16;i++)
+ {
+ for (j=0;j<10;j++)
+ dist=dist+weight[j];
+ if (dist<0)
+ best_id=i;
+ }
+ x[j] = cdbk[best_id*10+j];
+}
Index: lambda-code.c
===================================================================
--- lambda-code.c (revision 129276)
+++ lambda-code.c (working copy)
@@ -1972,32 +1972,42 @@ perfect_nest_p (struct loop *loop)
size_t i;
tree exit_cond;
+ /* Loops at depth 0 are perfect nests. */
if (!loop->inner)
return true;
+
bbs = get_loop_body (loop);
exit_cond = get_loop_exit_condition (loop);
+
for (i = 0; i < loop->num_nodes; i++)
{
if (bbs[i]->loop_father == loop)
{
block_stmt_iterator bsi;
+
for (bsi = bsi_start (bbs[i]); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
+
+ if (TREE_CODE (stmt) == COND_EXPR
+ && exit_cond != stmt)
+ goto non_perfectly_nested;
+
if (stmt == exit_cond
|| not_interesting_stmt (stmt)
|| stmt_is_bumper_for_loop (loop, stmt))
continue;
+
+ non_perfectly_nested:
free (bbs);
return false;
}
}
}
+
free (bbs);
- /* See if the inner loops are perfectly nested as well. */
- if (loop->inner)
- return perfect_nest_p (loop->inner);
- return true;
+
+ return perfect_nest_p (loop->inner);
}
/* Replace the USES of X in STMT, or uses with the same step as X with Y.