OSDN Git Service

Remove the lambda framework and make -ftree-loop-linear an alias of -floop-interchange.
authorspop <spop@138bc75d-0d04-0410-961f-82ee72b054a4>
Tue, 25 Jan 2011 21:24:23 +0000 (21:24 +0000)
committerspop <spop@138bc75d-0d04-0410-961f-82ee72b054a4>
Tue, 25 Jan 2011 21:24:23 +0000 (21:24 +0000)
2011-01-17  Sebastian Pop  <sebastian.pop@amd.com>

toplev/
* MAINTAINERS (linear loop transforms): Removed.

toplev/gcc/
* Makefile.in (LAMBDA_H): Removed.
(TREE_DATA_REF_H): Remove dependence on LAMBDA_H.
(OBJS-common): Remove dependence on lambda-code.o, lambda-mat.o,
lambda-trans.o, and tree-loop-linear.o.
(lto-symtab.o): Remove dependence on LAMBDA_H.
(tree-loop-linear.o): Remove rule.
(lambda-mat.o): Same.
(lambda-trans.o): Same.
(lambda-code.o): Same.
(tree-vect-loop.o): Add missing dependence on TREE_DATA_REF_H.
(tree-vect-slp.o): Same.
* hwint.h (gcd): Moved here.
(least_common_multiple): Same.
* lambda-code.c: Removed.
* lambda-mat.c: Removed.
* lambda-trans.c: Removed.
* lambda.h: Removed.
* tree-loop-linear.c: Removed.
* lto-symtab.c: Do not include lambda.h.
* omega.c (gcd): Removed.
* passes.c (init_optimization_passes): Remove pass_linear_transform.
* tree-data-ref.c (print_lambda_vector): Moved here.
(lambda_vector_copy): Same.
(lambda_matrix_copy): Same.
(lambda_matrix_id): Same.
(lambda_vector_first_nz): Same.
(lambda_matrix_row_add): Same.
(lambda_matrix_row_exchange): Same.
(lambda_vector_mult_const): Same.
(lambda_vector_negate): Same.
(lambda_matrix_row_negate): Same.
(lambda_vector_equal): Same.
(lambda_matrix_right_hermite): Same.
* tree-data-ref.h: Do not include lambda.h.
(lambda_vector): Moved here.
(lambda_matrix): Same.
(dependence_level): Same.
(lambda_transform_legal_p): Removed declaration.
(lambda_collect_parameters): Same.
(lambda_compute_access_matrices): Same.
(lambda_vector_gcd): Same.
(lambda_vector_new): Same.
(lambda_vector_clear): Same.
(lambda_vector_lexico_pos): Same.
(lambda_vector_zerop): Same.
(lambda_matrix_new): Same.
* tree-flow.h (least_common_multiple): Removed declaration.
* tree-parloops.c (lambda_trans_matrix): Moved here.
(LTM_MATRIX): Same.
(LTM_ROWSIZE): Same.
(LTM_COLSIZE): Same.
(LTM_DENOMINATOR): Same.
(lambda_trans_matrix_new): Same.
(lambda_matrix_vector_mult): Same.
(lambda_transform_legal_p): Same.
* tree-pass.h (pass_linear_transform): Removed declaration.
* tree-ssa-loop.c (tree_linear_transform): Removed.
(gate_tree_linear_transform): Removed.
(pass_linear_transform): Removed.
(gate_graphite_transforms): Make flag_tree_loop_linear an alias of
flag_loop_interchange.

toplev/gcc/testsuite/
* gfortran.dg/graphite/interchange-4.f: New.
* gfortran.dg/graphite/interchange-5.f: New.

* gcc.dg/tree-ssa/ltrans-1.c: Removed.
* gcc.dg/tree-ssa/ltrans-2.c: Removed.
* gcc.dg/tree-ssa/ltrans-3.c: Removed.
* gcc.dg/tree-ssa/ltrans-4.c: Removed.
* gcc.dg/tree-ssa/ltrans-5.c: Removed.
* gcc.dg/tree-ssa/ltrans-6.c: Removed.
* gcc.dg/tree-ssa/ltrans-8.c: Removed.
* gfortran.dg/ltrans-7.f90: Removed.
* gcc.dg/tree-ssa/data-dep-1.c: Removed.

* gcc.dg/pr18792.c: -> gcc.dg/graphite/pr18792.c
* gcc.dg/pr19910.c: -> gcc.dg/graphite/pr19910.c
* gcc.dg/tree-ssa/20041110-1.c: -> gcc.dg/graphite/pr20041110-1.c
* gcc.dg/tree-ssa/pr20256.c: -> gcc.dg/graphite/pr20256.c
* gcc.dg/pr23625.c: -> gcc.dg/graphite/pr23625.c
* gcc.dg/tree-ssa/pr23820.c: -> gcc.dg/graphite/pr23820.c
* gcc.dg/tree-ssa/pr24309.c: -> gcc.dg/graphite/pr24309.c
* gcc.dg/tree-ssa/pr26435.c: -> gcc.dg/graphite/pr26435.c
* gcc.dg/pr29330.c: -> gcc.dg/graphite/pr29330.c
* gcc.dg/pr29581-1.c: -> gcc.dg/graphite/pr29581-1.c
* gcc.dg/pr29581-2.c: -> gcc.dg/graphite/pr29581-2.c
* gcc.dg/pr29581-3.c: -> gcc.dg/graphite/pr29581-3.c
* gcc.dg/pr29581-4.c: -> gcc.dg/graphite/pr29581-4.c
* gcc.dg/tree-ssa/loop-27.c: -> gcc.dg/graphite/pr30565.c
* gcc.dg/tree-ssa/pr31183.c: -> gcc.dg/graphite/pr31183.c
* gcc.dg/tree-ssa/pr33576.c: -> gcc.dg/graphite/pr33576.c
* gcc.dg/tree-ssa/pr33766.c: -> gcc.dg/graphite/pr33766.c
* gcc.dg/pr34016.c: -> gcc.dg/graphite/pr34016.c
* gcc.dg/tree-ssa/pr34017.c: -> gcc.dg/graphite/pr34017.c
* gcc.dg/tree-ssa/pr34123.c: -> gcc.dg/graphite/pr34123.c
* gcc.dg/tree-ssa/pr36287.c: -> gcc.dg/graphite/pr36287.c
* gcc.dg/tree-ssa/pr37686.c: -> gcc.dg/graphite/pr37686.c
* gcc.dg/pr42917.c: -> gcc.dg/graphite/pr42917.c
* gfortran.dg/loop_nest_1.f90: -> gfortran.dg/graphite/pr29290.f90
* gfortran.dg/pr29581.f90: -> gfortran.dg/graphite/pr29581.f90
* gfortran.dg/pr36286.f90: -> gfortran.dg/graphite/pr36286.f90
* gfortran.dg/pr36922.f: -> gfortran.dg/graphite/pr36922.f
* gfortran.dg/pr39516.f: -> gfortran.dg/graphite/pr39516.f

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

60 files changed:
ChangeLog
MAINTAINERS
gcc/ChangeLog
gcc/Makefile.in
gcc/hwint.h
gcc/lambda-code.c [deleted file]
gcc/lambda-mat.c [deleted file]
gcc/lambda-trans.c [deleted file]
gcc/lambda.h [deleted file]
gcc/lto-symtab.c
gcc/omega.c
gcc/passes.c
gcc/testsuite/ChangeLog
gcc/testsuite/gcc.dg/graphite/pr18792.c [moved from gcc/testsuite/gcc.dg/pr18792.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr19910.c [moved from gcc/testsuite/gcc.dg/pr19910.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr20041110-1.c [moved from gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr20256.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr20256.c with 63% similarity]
gcc/testsuite/gcc.dg/graphite/pr23625.c [moved from gcc/testsuite/gcc.dg/pr23625.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr23820.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr23820.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr24309.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr24309.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr26435.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr26435.c with 60% similarity]
gcc/testsuite/gcc.dg/graphite/pr29330.c [moved from gcc/testsuite/gcc.dg/pr29330.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr29581-1.c [moved from gcc/testsuite/gcc.dg/pr29581-1.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr29581-2.c [moved from gcc/testsuite/gcc.dg/pr29581-2.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr29581-3.c [moved from gcc/testsuite/gcc.dg/pr29581-3.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr29581-4.c [moved from gcc/testsuite/gcc.dg/pr29581-4.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr30565.c [moved from gcc/testsuite/gcc.dg/tree-ssa/loop-27.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr31183.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr31183.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr33576.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr33576.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr33766.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr33766.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr34016.c [moved from gcc/testsuite/gcc.dg/pr34016.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr34017.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr34017.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr34123.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr34123.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr36287.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr36287.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr37686.c [moved from gcc/testsuite/gcc.dg/tree-ssa/pr37686.c with 100% similarity]
gcc/testsuite/gcc.dg/graphite/pr42917.c [new file with mode: 0644]
gcc/testsuite/gcc.dg/pr42917.c [deleted file]
gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c [deleted file]
gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c [deleted file]
gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c [deleted file]
gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c [deleted file]
gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c [deleted file]
gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c [deleted file]
gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c [deleted file]
gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c [deleted file]
gcc/testsuite/gfortran.dg/graphite/interchange-4.f [new file with mode: 0644]
gcc/testsuite/gfortran.dg/graphite/interchange-5.f [new file with mode: 0644]
gcc/testsuite/gfortran.dg/graphite/pr29290.f90 [moved from gcc/testsuite/gfortran.dg/loop_nest_1.f90 with 100% similarity]
gcc/testsuite/gfortran.dg/graphite/pr29581.f90 [moved from gcc/testsuite/gfortran.dg/pr29581.f90 with 100% similarity]
gcc/testsuite/gfortran.dg/graphite/pr36286.f90 [moved from gcc/testsuite/gfortran.dg/pr36286.f90 with 100% similarity]
gcc/testsuite/gfortran.dg/graphite/pr36922.f [moved from gcc/testsuite/gfortran.dg/pr36922.f with 100% similarity]
gcc/testsuite/gfortran.dg/graphite/pr39516.f [moved from gcc/testsuite/gfortran.dg/pr39516.f with 100% similarity]
gcc/testsuite/gfortran.dg/ltrans-7.f90 [deleted file]
gcc/tree-data-ref.c
gcc/tree-data-ref.h
gcc/tree-flow.h
gcc/tree-loop-linear.c [deleted file]
gcc/tree-parloops.c
gcc/tree-pass.h
gcc/tree-ssa-loop.c

index e4233e5..ad8d8f9 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2011-01-25  Sebastian Pop  <sebastian.pop@amd.com>
+
+       * MAINTAINERS (linear loop transforms): Removed.
+
 2011-01-25  Jakub Jelinek  <jakub@redhat.com>
 
        * config/cloog.m4 (CLOOG_REQUESTED): Use $2 if --without-cloog.
index fb887a8..cffbdb0 100644 (file)
@@ -221,7 +221,6 @@ mudflap                     Frank Ch. Eigler        fche@redhat.com
 tree browser/unparser  Sebastian Pop           sebastian.pop@amd.com
 scev, data dependence  Daniel Berlin           dberlin@dberlin.org
 scev, data dependence  Sebastian Pop           sebastian.pop@amd.com
-linear loop transforms Daniel Berlin           dberlin@dberlin.org
 profile feedback       Jan Hubicka             jh@suse.cz
 type-safe vectors      Nathan Sidwell          nathan@codesourcery.com
 alias analysis         Daniel Berlin           dberlin@dberlin.org
index 6e1c8f5..514ab55 100644 (file)
@@ -1,3 +1,67 @@
+2011-01-25  Sebastian Pop  <sebastian.pop@amd.com>
+
+       * Makefile.in (LAMBDA_H): Removed.
+       (TREE_DATA_REF_H): Remove dependence on LAMBDA_H.
+       (OBJS-common): Remove dependence on lambda-code.o, lambda-mat.o,
+       lambda-trans.o, and tree-loop-linear.o.
+       (lto-symtab.o): Remove dependence on LAMBDA_H.
+       (tree-loop-linear.o): Remove rule.
+       (lambda-mat.o): Same.
+       (lambda-trans.o): Same.
+       (lambda-code.o): Same.
+       (tree-vect-loop.o): Add missing dependence on TREE_DATA_REF_H.
+       (tree-vect-slp.o): Same.
+       * hwint.h (gcd): Moved here.
+       (least_common_multiple): Same.
+       * lambda-code.c: Removed.
+       * lambda-mat.c: Removed.
+       * lambda-trans.c: Removed.
+       * lambda.h: Removed.
+       * tree-loop-linear.c: Removed.
+       * lto-symtab.c: Do not include lambda.h.
+       * omega.c (gcd): Removed.
+       * passes.c (init_optimization_passes): Remove pass_linear_transform.
+       * tree-data-ref.c (print_lambda_vector): Moved here.
+       (lambda_vector_copy): Same.
+       (lambda_matrix_copy): Same.
+       (lambda_matrix_id): Same.
+       (lambda_vector_first_nz): Same.
+       (lambda_matrix_row_add): Same.
+       (lambda_matrix_row_exchange): Same.
+       (lambda_vector_mult_const): Same.
+       (lambda_vector_negate): Same.
+       (lambda_matrix_row_negate): Same.
+       (lambda_vector_equal): Same.
+       (lambda_matrix_right_hermite): Same.
+       * tree-data-ref.h: Do not include lambda.h.
+       (lambda_vector): Moved here.
+       (lambda_matrix): Same.
+       (dependence_level): Same.
+       (lambda_transform_legal_p): Removed declaration.
+       (lambda_collect_parameters): Same.
+       (lambda_compute_access_matrices): Same.
+       (lambda_vector_gcd): Same.
+       (lambda_vector_new): Same.
+       (lambda_vector_clear): Same.
+       (lambda_vector_lexico_pos): Same.
+       (lambda_vector_zerop): Same.
+       (lambda_matrix_new): Same.
+       * tree-flow.h (least_common_multiple): Removed declaration.
+       * tree-parloops.c (lambda_trans_matrix): Moved here.
+       (LTM_MATRIX): Same.
+       (LTM_ROWSIZE): Same.
+       (LTM_COLSIZE): Same.
+       (LTM_DENOMINATOR): Same.
+       (lambda_trans_matrix_new): Same.
+       (lambda_matrix_vector_mult): Same.
+       (lambda_transform_legal_p): Same.
+       * tree-pass.h (pass_linear_transform): Removed declaration.
+       * tree-ssa-loop.c (tree_linear_transform): Removed.
+       (gate_tree_linear_transform): Removed.
+       (pass_linear_transform): Removed.
+       (gate_graphite_transforms): Make flag_tree_loop_linear an alias of
+       flag_loop_interchange.
+
 2011-01-25  Jakub Jelinek  <jakub@redhat.com>
 
        PR tree-optimization/47265
index eeb77e4..48b49e9 100644 (file)
@@ -966,8 +966,7 @@ DIAGNOSTIC_H = diagnostic.h $(DIAGNOSTIC_CORE_H) $(PRETTY_PRINT_H)
 C_PRETTY_PRINT_H = c-family/c-pretty-print.h $(PRETTY_PRINT_H) \
        $(C_COMMON_H) $(TREE_H)
 SCEV_H = tree-scalar-evolution.h $(GGC_H) tree-chrec.h $(PARAMS_H)
-LAMBDA_H = lambda.h $(TREE_H) $(VEC_H) $(GGC_H)
-TREE_DATA_REF_H = tree-data-ref.h $(LAMBDA_H) omega.h graphds.h $(SCEV_H)
+TREE_DATA_REF_H = tree-data-ref.h omega.h graphds.h $(SCEV_H)
 TREE_INLINE_H = tree-inline.h vecir.h
 REAL_H = real.h $(MACHMODE_H)
 IRA_INT_H = ira.h ira-int.h $(CFGLOOP_H) alloc-pool.h
@@ -1279,9 +1278,6 @@ OBJS-common = \
        ira-emit.o \
        ira-lives.o \
        jump.o \
-       lambda-code.o \
-       lambda-mat.o \
-       lambda-trans.o \
        langhooks.o \
        lcm.o \
        lists.o \
@@ -1379,7 +1375,6 @@ OBJS-common = \
        tree-into-ssa.o \
        tree-iterator.o \
        tree-loop-distribution.o \
-       tree-loop-linear.o \
        tree-nested.o \
        tree-nrv.o \
        tree-object-size.o \
@@ -2331,7 +2326,7 @@ lto-section-out.o : lto-section-out.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
    $(CGRAPH_H) $(FUNCTION_H) $(GGC_H) $(EXCEPT_H) pointer-set.h \
    $(BITMAP_H) langhooks.h $(LTO_STREAMER_H) lto-compress.h
 lto-symtab.o: lto-symtab.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
-   $(TREE_H) $(GIMPLE_H) $(GGC_H) $(LAMBDA_H) $(HASHTAB_H) \
+   $(TREE_H) $(GIMPLE_H) $(GGC_H) $(HASHTAB_H) \
    $(LTO_STREAMER_H) $(LINKER_PLUGIN_API_H) gt-lto-symtab.h
 lto-opts.o: lto-opts.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \
    $(HASHTAB_H) $(GGC_H) $(BITMAP_H) $(FLAGS_H) $(OPTS_H) $(OPTIONS_H) \
@@ -2711,7 +2706,7 @@ tree-vect-loop.o: tree-vect-loop.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
    $(TM_H) $(GGC_H) $(TREE_H) $(BASIC_BLOCK_H) $(DIAGNOSTIC_H) $(TREE_FLOW_H) \
    $(TREE_DUMP_H) $(CFGLOOP_H) $(CFGLAYOUT_H) $(EXPR_H) $(RECOG_H) $(OPTABS_H) \
    $(DIAGNOSTIC_CORE_H) $(SCEV_H) $(TREE_VECTORIZER_H) tree-pretty-print.h \
-   gimple-pretty-print.h $(TARGET_H)
+   gimple-pretty-print.h $(TARGET_H) $(TREE_DATA_REF_H)
 tree-vect-loop-manip.o: tree-vect-loop-manip.c $(CONFIG_H) $(SYSTEM_H) \
    coretypes.h $(TM_H) $(GGC_H) $(TREE_H) $(BASIC_BLOCK_H) $(DIAGNOSTIC_H) \
    $(TREE_FLOW_H) $(TREE_DUMP_H) $(CFGLOOP_H) $(CFGLAYOUT_H) $(EXPR_H) $(DIAGNOSTIC_CORE_H) \
@@ -2726,7 +2721,7 @@ tree-vect-slp.o: tree-vect-slp.c $(CONFIG_H) $(SYSTEM_H) \
    coretypes.h $(TM_H) $(GGC_H) $(TREE_H) $(TARGET_H) $(BASIC_BLOCK_H) \
    $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) $(CFGLOOP_H) $(CFGLAYOUT_H) \
    $(EXPR_H) $(RECOG_H) $(OPTABS_H) $(TREE_VECTORIZER_H) tree-pretty-print.h \
-   gimple-pretty-print.h
+   gimple-pretty-print.h $(TREE_DATA_REF_H)
 tree-vect-stmts.o: tree-vect-stmts.c $(CONFIG_H) $(SYSTEM_H) \
    coretypes.h $(TM_H) $(GGC_H) $(TREE_H) $(TARGET_H) $(BASIC_BLOCK_H) \
    $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) $(CFGLOOP_H) $(CFGLAYOUT_H) \
@@ -2742,8 +2737,6 @@ tree-vectorizer.o: tree-vectorizer.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
    $(TM_H) $(GGC_H) $(TREE_H) $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) \
    $(CFGLOOP_H) $(TREE_PASS_H) $(TREE_VECTORIZER_H) $(TIMEVAR_H) \
    tree-pretty-print.h
-tree-loop-linear.o: tree-loop-linear.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
-   $(TREE_FLOW_H) $(CFGLOOP_H) $(TREE_DATA_REF_H) $(TREE_PASS_H) $(LAMBDA_H)
 tree-loop-distribution.o: tree-loop-distribution.c $(CONFIG_H) $(SYSTEM_H) \
    coretypes.h $(TREE_FLOW_H) $(CFGLOOP_H) $(TREE_DATA_REF_H) $(TREE_PASS_H)
 tree-parloops.o: tree-parloops.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
@@ -3462,12 +3455,6 @@ ifcvt.o : ifcvt.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
    $(TARGET_H) $(BASIC_BLOCK_H) $(EXPR_H) output.h $(EXCEPT_H) $(TM_P_H) \
    $(OPTABS_H) $(CFGLOOP_H) hard-reg-set.h $(TIMEVAR_H) \
    $(TREE_PASS_H) $(DF_H) $(DBGCNT_H)
-lambda-mat.o : lambda-mat.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_FLOW_H) \
-   $(LAMBDA_H)
-lambda-trans.o : lambda-trans.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
-   $(TREE_FLOW_H) $(LAMBDA_H)
-lambda-code.o : lambda-code.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
-   $(TREE_FLOW_H) $(CFGLOOP_H) $(TREE_DATA_REF_H) $(LAMBDA_H) $(TREE_PASS_H)
 params.o : params.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(PARAMS_H) \
    $(DIAGNOSTIC_CORE_H)
 pointer-set.o: pointer-set.c pointer-set.h $(CONFIG_H) $(SYSTEM_H)
index 8bd7c5e..1eadd45 100644 (file)
@@ -228,4 +228,33 @@ exact_log2 (unsigned HOST_WIDE_INT x)
 
 #endif /* GCC_VERSION >= 3004 */
 
+/* Compute the greatest common divisor of two numbers using
+   Euclid's algorithm.  */
+
+static inline int
+gcd (int a, int b)
+{
+  int x, y, z;
+
+  x = abs (a);
+  y = abs (b);
+
+  while (x > 0)
+    {
+      z = y % x;
+      y = x;
+      x = z;
+    }
+
+  return y;
+}
+
+/* Compute the least common multiple of two numbers A and B .  */
+
+static inline int
+least_common_multiple (int a, int b)
+{
+  return (abs (a) * abs (b) / gcd (a, b));
+}
+
 #endif /* ! GCC_HWINT_H */
diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c
deleted file mode 100644 (file)
index f462071..0000000
+++ /dev/null
@@ -1,2855 +0,0 @@
-/*  Loop transformation code generation
-    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-    Free Software Foundation, Inc.
-    Contributed by Daniel Berlin <dberlin@dberlin.org>
-
-    This file is part of GCC.
-
-    GCC is free software; you can redistribute it and/or modify it under
-    the terms of the GNU General Public License as published by the Free
-    Software Foundation; either version 3, or (at your option) any later
-    version.
-
-    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-    WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with GCC; see the file COPYING3.  If not see
-    <http://www.gnu.org/licenses/>.  */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tree-flow.h"
-#include "cfgloop.h"
-#include "tree-chrec.h"
-#include "tree-data-ref.h"
-#include "tree-scalar-evolution.h"
-#include "lambda.h"
-#include "tree-pass.h"
-
-/* This loop nest code generation is based on non-singular matrix
-   math.
-
- A little terminology and a general sketch of the algorithm.  See "A singular
- loop transformation framework based on non-singular matrices" by Wei Li and
- Keshav Pingali for formal proofs that the various statements below are
- correct.
-
- A loop iteration space represents the points traversed by the loop.  A point in the
- iteration space can be represented by a vector of size <loop depth>.  You can
- therefore represent the iteration space as an integral combinations of a set
- of basis vectors.
-
- A loop iteration space is dense if every integer point between the loop
- bounds is a point in the iteration space.  Every loop with a step of 1
- therefore has a dense iteration space.
-
- for i = 1 to 3, step 1 is a dense iteration space.
-
- A loop iteration space is sparse if it is not dense.  That is, the iteration
- space skips integer points that are within the loop bounds.
-
- for i = 1 to 3, step 2 is a sparse iteration space, because the integer point
- 2 is skipped.
-
- Dense source spaces are easy to transform, because they don't skip any
- points to begin with.  Thus we can compute the exact bounds of the target
- space using min/max and floor/ceil.
-
- For a dense source space, we take the transformation matrix, decompose it
- into a lower triangular part (H) and a unimodular part (U).
- We then compute the auxiliary space from the unimodular part (source loop
- nest . U = auxiliary space) , which has two important properties:
-  1. It traverses the iterations in the same lexicographic order as the source
-  space.
-  2. It is a dense space when the source is a dense space (even if the target
-  space is going to be sparse).
-
- Given the auxiliary space, we use the lower triangular part to compute the
- bounds in the target space by simple matrix multiplication.
- The gaps in the target space (IE the new loop step sizes) will be the
- diagonals of the H matrix.
-
- Sparse source spaces require another step, because you can't directly compute
- the exact bounds of the auxiliary and target space from the sparse space.
- Rather than try to come up with a separate algorithm to handle sparse source
- spaces directly, we just find a legal transformation matrix that gives you
- the sparse source space, from a dense space, and then transform the dense
- space.
-
- For a regular sparse space, you can represent the source space as an integer
- lattice, and the base space of that lattice will always be dense.  Thus, we
- effectively use the lattice to figure out the transformation from the lattice
- base space, to the sparse iteration space (IE what transform was applied to
- the dense space to make it sparse).  We then compose this transform with the
- transformation matrix specified by the user (since our matrix transformations
- are closed under composition, this is okay).  We can then use the base space
- (which is dense) plus the composed transformation matrix, to compute the rest
- of the transform using the dense space algorithm above.
-
- In other words, our sparse source space (B) is decomposed into a dense base
- space (A), and a matrix (L) that transforms A into B, such that A.L = B.
- We then compute the composition of L and the user transformation matrix (T),
- so that T is now a transform from A to the result, instead of from B to the
- result.
- IE A.(LT) = result instead of B.T = result
- Since A is now a dense source space, we can use the dense source space
- algorithm above to compute the result of applying transform (LT) to A.
-
- Fourier-Motzkin elimination is used to compute the bounds of the base space
- of the lattice.  */
-
-static bool perfect_nestify (struct loop *, VEC(tree,heap) *,
-                            VEC(tree,heap) *, VEC(int,heap) *,
-                            VEC(tree,heap) *);
-/* Lattice stuff that is internal to the code generation algorithm.  */
-
-typedef struct lambda_lattice_s
-{
-  /* Lattice base matrix.  */
-  lambda_matrix base;
-  /* Lattice dimension.  */
-  int dimension;
-  /* Origin vector for the coefficients.  */
-  lambda_vector origin;
-  /* Origin matrix for the invariants.  */
-  lambda_matrix origin_invariants;
-  /* Number of invariants.  */
-  int invariants;
-} *lambda_lattice;
-
-#define LATTICE_BASE(T) ((T)->base)
-#define LATTICE_DIMENSION(T) ((T)->dimension)
-#define LATTICE_ORIGIN(T) ((T)->origin)
-#define LATTICE_ORIGIN_INVARIANTS(T) ((T)->origin_invariants)
-#define LATTICE_INVARIANTS(T) ((T)->invariants)
-
-static bool lle_equal (lambda_linear_expression, lambda_linear_expression,
-                      int, int);
-static lambda_lattice lambda_lattice_new (int, int, struct obstack *);
-static lambda_lattice lambda_lattice_compute_base (lambda_loopnest,
-                                                   struct obstack *);
-
-static bool can_convert_to_perfect_nest (struct loop *);
-
-/* Create a new lambda loop in LAMBDA_OBSTACK.  */
-
-static lambda_loop
-lambda_loop_new (struct obstack * lambda_obstack)
-{
-  lambda_loop result = (lambda_loop)
-    obstack_alloc (lambda_obstack, sizeof (struct lambda_loop_s));
-  memset (result, 0, sizeof (struct lambda_loop_s));
-  return result;
-}
-
-/* Create a new lambda body vector.  */
-
-lambda_body_vector
-lambda_body_vector_new (int size, struct obstack * lambda_obstack)
-{
-  lambda_body_vector ret;
-
-  ret = (lambda_body_vector) obstack_alloc (lambda_obstack,
-                                           sizeof (*ret));
-  LBV_COEFFICIENTS (ret) = lambda_vector_new (size);
-  LBV_SIZE (ret) = size;
-  LBV_DENOMINATOR (ret) = 1;
-  return ret;
-}
-
-/* Compute the new coefficients for the vector based on the
-  *inverse* of the transformation matrix.  */
-
-lambda_body_vector
-lambda_body_vector_compute_new (lambda_trans_matrix transform,
-                                lambda_body_vector vect,
-                                struct obstack * lambda_obstack)
-{
-  lambda_body_vector temp;
-  int depth;
-
-  /* Make sure the matrix is square.  */
-  gcc_assert (LTM_ROWSIZE (transform) == LTM_COLSIZE (transform));
-
-  depth = LTM_ROWSIZE (transform);
-
-  temp = lambda_body_vector_new (depth, lambda_obstack);
-  LBV_DENOMINATOR (temp) =
-    LBV_DENOMINATOR (vect) * LTM_DENOMINATOR (transform);
-  lambda_vector_matrix_mult (LBV_COEFFICIENTS (vect), depth,
-                            LTM_MATRIX (transform), depth,
-                            LBV_COEFFICIENTS (temp));
-  LBV_SIZE (temp) = LBV_SIZE (vect);
-  return temp;
-}
-
-/* Print out a lambda body vector.  */
-
-void
-print_lambda_body_vector (FILE * outfile, lambda_body_vector body)
-{
-  print_lambda_vector (outfile, LBV_COEFFICIENTS (body), LBV_SIZE (body));
-}
-
-/* Return TRUE if two linear expressions are equal.  */
-
-static bool
-lle_equal (lambda_linear_expression lle1, lambda_linear_expression lle2,
-          int depth, int invariants)
-{
-  int i;
-
-  if (lle1 == NULL || lle2 == NULL)
-    return false;
-  if (LLE_CONSTANT (lle1) != LLE_CONSTANT (lle2))
-    return false;
-  if (LLE_DENOMINATOR (lle1) != LLE_DENOMINATOR (lle2))
-    return false;
-  for (i = 0; i < depth; i++)
-    if (LLE_COEFFICIENTS (lle1)[i] != LLE_COEFFICIENTS (lle2)[i])
-      return false;
-  for (i = 0; i < invariants; i++)
-    if (LLE_INVARIANT_COEFFICIENTS (lle1)[i] !=
-       LLE_INVARIANT_COEFFICIENTS (lle2)[i])
-      return false;
-  return true;
-}
-
-/* Create a new linear expression with dimension DIM, and total number
-   of invariants INVARIANTS.  */
-
-lambda_linear_expression
-lambda_linear_expression_new (int dim, int invariants,
-                              struct obstack * lambda_obstack)
-{
-  lambda_linear_expression ret;
-
-  ret = (lambda_linear_expression)obstack_alloc (lambda_obstack,
-                                                 sizeof (*ret));
-  LLE_COEFFICIENTS (ret) = lambda_vector_new (dim);
-  LLE_CONSTANT (ret) = 0;
-  LLE_INVARIANT_COEFFICIENTS (ret) = lambda_vector_new (invariants);
-  LLE_DENOMINATOR (ret) = 1;
-  LLE_NEXT (ret) = NULL;
-
-  return ret;
-}
-
-/* Print out a linear expression EXPR, with SIZE coefficients, to OUTFILE.
-   The starting letter used for variable names is START.  */
-
-static void
-print_linear_expression (FILE * outfile, lambda_vector expr, int size,
-                        char start)
-{
-  int i;
-  bool first = true;
-  for (i = 0; i < size; i++)
-    {
-      if (expr[i] != 0)
-       {
-         if (first)
-           {
-             if (expr[i] < 0)
-               fprintf (outfile, "-");
-             first = false;
-           }
-         else if (expr[i] > 0)
-           fprintf (outfile, " + ");
-         else
-           fprintf (outfile, " - ");
-         if (abs (expr[i]) == 1)
-           fprintf (outfile, "%c", start + i);
-         else
-           fprintf (outfile, "%d%c", abs (expr[i]), start + i);
-       }
-    }
-}
-
-/* Print out a lambda linear expression structure, EXPR, to OUTFILE. The
-   depth/number of coefficients is given by DEPTH, the number of invariants is
-   given by INVARIANTS, and the character to start variable names with is given
-   by START.  */
-
-void
-print_lambda_linear_expression (FILE * outfile,
-                               lambda_linear_expression expr,
-                               int depth, int invariants, char start)
-{
-  fprintf (outfile, "\tLinear expression: ");
-  print_linear_expression (outfile, LLE_COEFFICIENTS (expr), depth, start);
-  fprintf (outfile, " constant: %d ", LLE_CONSTANT (expr));
-  fprintf (outfile, "  invariants: ");
-  print_linear_expression (outfile, LLE_INVARIANT_COEFFICIENTS (expr),
-                          invariants, 'A');
-  fprintf (outfile, "  denominator: %d\n", LLE_DENOMINATOR (expr));
-}
-
-/* Print a lambda loop structure LOOP to OUTFILE.  The depth/number of
-   coefficients is given by DEPTH, the number of invariants is
-   given by INVARIANTS, and the character to start variable names with is given
-   by START.  */
-
-void
-print_lambda_loop (FILE * outfile, lambda_loop loop, int depth,
-                  int invariants, char start)
-{
-  int step;
-  lambda_linear_expression expr;
-
-  gcc_assert (loop);
-
-  expr = LL_LINEAR_OFFSET (loop);
-  step = LL_STEP (loop);
-  fprintf (outfile, "  step size = %d \n", step);
-
-  if (expr)
-    {
-      fprintf (outfile, "  linear offset: \n");
-      print_lambda_linear_expression (outfile, expr, depth, invariants,
-                                     start);
-    }
-
-  fprintf (outfile, "  lower bound: \n");
-  for (expr = LL_LOWER_BOUND (loop); expr != NULL; expr = LLE_NEXT (expr))
-    print_lambda_linear_expression (outfile, expr, depth, invariants, start);
-  fprintf (outfile, "  upper bound: \n");
-  for (expr = LL_UPPER_BOUND (loop); expr != NULL; expr = LLE_NEXT (expr))
-    print_lambda_linear_expression (outfile, expr, depth, invariants, start);
-}
-
-/* Create a new loop nest structure with DEPTH loops, and INVARIANTS as the
-   number of invariants.  */
-
-lambda_loopnest
-lambda_loopnest_new (int depth, int invariants,
-                     struct obstack * lambda_obstack)
-{
-  lambda_loopnest ret;
-  ret = (lambda_loopnest)obstack_alloc (lambda_obstack, sizeof (*ret));
-
-  LN_LOOPS (ret) = (lambda_loop *)
-      obstack_alloc (lambda_obstack, depth * sizeof(LN_LOOPS(ret)));
-  LN_DEPTH (ret) = depth;
-  LN_INVARIANTS (ret) = invariants;
-
-  return ret;
-}
-
-/* Print a lambda loopnest structure, NEST, to OUTFILE.  The starting
-   character to use for loop names is given by START.  */
-
-void
-print_lambda_loopnest (FILE * outfile, lambda_loopnest nest, char start)
-{
-  int i;
-  for (i = 0; i < LN_DEPTH (nest); i++)
-    {
-      fprintf (outfile, "Loop %c\n", start + i);
-      print_lambda_loop (outfile, LN_LOOPS (nest)[i], LN_DEPTH (nest),
-                        LN_INVARIANTS (nest), 'i');
-      fprintf (outfile, "\n");
-    }
-}
-
-/* Allocate a new lattice structure of DEPTH x DEPTH, with INVARIANTS number
-   of invariants.  */
-
-static lambda_lattice
-lambda_lattice_new (int depth, int invariants, struct obstack * lambda_obstack)
-{
-  lambda_lattice ret
-      = (lambda_lattice)obstack_alloc (lambda_obstack, sizeof (*ret));
-  LATTICE_BASE (ret) = lambda_matrix_new (depth, depth, lambda_obstack);
-  LATTICE_ORIGIN (ret) = lambda_vector_new (depth);
-  LATTICE_ORIGIN_INVARIANTS (ret) = lambda_matrix_new (depth, invariants,
-                                                      lambda_obstack);
-  LATTICE_DIMENSION (ret) = depth;
-  LATTICE_INVARIANTS (ret) = invariants;
-  return ret;
-}
-
-/* Compute the lattice base for NEST.  The lattice base is essentially a
-   non-singular transform from a dense base space to a sparse iteration space.
-   We use it so that we don't have to specially handle the case of a sparse
-   iteration space in other parts of the algorithm.  As a result, this routine
-   only does something interesting (IE produce a matrix that isn't the
-   identity matrix) if NEST is a sparse space.  */
-
-static lambda_lattice
-lambda_lattice_compute_base (lambda_loopnest nest,
-                             struct obstack * lambda_obstack)
-{
-  lambda_lattice ret;
-  int depth, invariants;
-  lambda_matrix base;
-
-  int i, j, step;
-  lambda_loop loop;
-  lambda_linear_expression expression;
-
-  depth = LN_DEPTH (nest);
-  invariants = LN_INVARIANTS (nest);
-
-  ret = lambda_lattice_new (depth, invariants, lambda_obstack);
-  base = LATTICE_BASE (ret);
-  for (i = 0; i < depth; i++)
-    {
-      loop = LN_LOOPS (nest)[i];
-      gcc_assert (loop);
-      step = LL_STEP (loop);
-      /* If we have a step of 1, then the base is one, and the
-         origin and invariant coefficients are 0.  */
-      if (step == 1)
-       {
-         for (j = 0; j < depth; j++)
-           base[i][j] = 0;
-         base[i][i] = 1;
-         LATTICE_ORIGIN (ret)[i] = 0;
-         for (j = 0; j < invariants; j++)
-           LATTICE_ORIGIN_INVARIANTS (ret)[i][j] = 0;
-       }
-      else
-       {
-         /* Otherwise, we need the lower bound expression (which must
-            be an affine function)  to determine the base.  */
-         expression = LL_LOWER_BOUND (loop);
-         gcc_assert (expression && !LLE_NEXT (expression)
-                     && LLE_DENOMINATOR (expression) == 1);
-
-         /* The lower triangular portion of the base is going to be the
-            coefficient times the step */
-         for (j = 0; j < i; j++)
-           base[i][j] = LLE_COEFFICIENTS (expression)[j]
-             * LL_STEP (LN_LOOPS (nest)[j]);
-         base[i][i] = step;
-         for (j = i + 1; j < depth; j++)
-           base[i][j] = 0;
-
-         /* Origin for this loop is the constant of the lower bound
-            expression.  */
-         LATTICE_ORIGIN (ret)[i] = LLE_CONSTANT (expression);
-
-         /* Coefficient for the invariants are equal to the invariant
-            coefficients in the expression.  */
-         for (j = 0; j < invariants; j++)
-           LATTICE_ORIGIN_INVARIANTS (ret)[i][j] =
-             LLE_INVARIANT_COEFFICIENTS (expression)[j];
-       }
-    }
-  return ret;
-}
-
-/* Compute the least common multiple of two numbers A and B .  */
-
-int
-least_common_multiple (int a, int b)
-{
-  return (abs (a) * abs (b) / gcd (a, b));
-}
-
-/* Perform Fourier-Motzkin elimination to calculate the bounds of the
-   auxiliary nest.
-   Fourier-Motzkin is a way of reducing systems of linear inequalities so that
-   it is easy to calculate the answer and bounds.
-   A sketch of how it works:
-   Given a system of linear inequalities, ai * xj >= bk, you can always
-   rewrite the constraints so they are all of the form
-   a <= x, or x <= b, or x >= constant for some x in x1 ... xj (and some b
-   in b1 ... bk, and some a in a1...ai)
-   You can then eliminate this x from the non-constant inequalities by
-   rewriting these as a <= b, x >= constant, and delete the x variable.
-   You can then repeat this for any remaining x variables, and then we have
-   an easy to use variable <= constant (or no variables at all) form that we
-   can construct our bounds from.
-
-   In our case, each time we eliminate, we construct part of the bound from
-   the ith variable, then delete the ith variable.
-
-   Remember the constant are in our vector a, our coefficient matrix is A,
-   and our invariant coefficient matrix is B.
-
-   SIZE is the size of the matrices being passed.
-   DEPTH is the loop nest depth.
-   INVARIANTS is the number of loop invariants.
-   A, B, and a are the coefficient matrix, invariant coefficient, and a
-   vector of constants, respectively.  */
-
-static lambda_loopnest
-compute_nest_using_fourier_motzkin (int size,
-                                   int depth,
-                                   int invariants,
-                                   lambda_matrix A,
-                                   lambda_matrix B,
-                                    lambda_vector a,
-                                    struct obstack * lambda_obstack)
-{
-
-  int multiple, f1, f2;
-  int i, j, k;
-  lambda_linear_expression expression;
-  lambda_loop loop;
-  lambda_loopnest auxillary_nest;
-  lambda_matrix swapmatrix, A1, B1;
-  lambda_vector swapvector, a1;
-  int newsize;
-
-  A1 = lambda_matrix_new (128, depth, lambda_obstack);
-  B1 = lambda_matrix_new (128, invariants, lambda_obstack);
-  a1 = lambda_vector_new (128);
-
-  auxillary_nest = lambda_loopnest_new (depth, invariants, lambda_obstack);
-
-  for (i = depth - 1; i >= 0; i--)
-    {
-      loop = lambda_loop_new (lambda_obstack);
-      LN_LOOPS (auxillary_nest)[i] = loop;
-      LL_STEP (loop) = 1;
-
-      for (j = 0; j < size; j++)
-       {
-         if (A[j][i] < 0)
-           {
-             /* Any linear expression in the matrix with a coefficient less
-                than 0 becomes part of the new lower bound.  */
-              expression = lambda_linear_expression_new (depth, invariants,
-                                                         lambda_obstack);
-
-             for (k = 0; k < i; k++)
-               LLE_COEFFICIENTS (expression)[k] = A[j][k];
-
-             for (k = 0; k < invariants; k++)
-               LLE_INVARIANT_COEFFICIENTS (expression)[k] = -1 * B[j][k];
-
-             LLE_DENOMINATOR (expression) = -1 * A[j][i];
-             LLE_CONSTANT (expression) = -1 * a[j];
-
-             /* Ignore if identical to the existing lower bound.  */
-             if (!lle_equal (LL_LOWER_BOUND (loop),
-                             expression, depth, invariants))
-               {
-                 LLE_NEXT (expression) = LL_LOWER_BOUND (loop);
-                 LL_LOWER_BOUND (loop) = expression;
-               }
-
-           }
-         else if (A[j][i] > 0)
-           {
-             /* Any linear expression with a coefficient greater than 0
-                becomes part of the new upper bound.  */
-              expression = lambda_linear_expression_new (depth, invariants,
-                                                         lambda_obstack);
-             for (k = 0; k < i; k++)
-               LLE_COEFFICIENTS (expression)[k] = -1 * A[j][k];
-
-             for (k = 0; k < invariants; k++)
-               LLE_INVARIANT_COEFFICIENTS (expression)[k] = B[j][k];
-
-             LLE_DENOMINATOR (expression) = A[j][i];
-             LLE_CONSTANT (expression) = a[j];
-
-             /* Ignore if identical to the existing upper bound.  */
-             if (!lle_equal (LL_UPPER_BOUND (loop),
-                             expression, depth, invariants))
-               {
-                 LLE_NEXT (expression) = LL_UPPER_BOUND (loop);
-                 LL_UPPER_BOUND (loop) = expression;
-               }
-
-           }
-       }
-
-      /* This portion creates a new system of linear inequalities by deleting
-        the i'th variable, reducing the system by one variable.  */
-      newsize = 0;
-      for (j = 0; j < size; j++)
-       {
-         /* If the coefficient for the i'th variable is 0, then we can just
-            eliminate the variable straightaway.  Otherwise, we have to
-            multiply through by the coefficients we are eliminating.  */
-         if (A[j][i] == 0)
-           {
-             lambda_vector_copy (A[j], A1[newsize], depth);
-             lambda_vector_copy (B[j], B1[newsize], invariants);
-             a1[newsize] = a[j];
-             newsize++;
-           }
-         else if (A[j][i] > 0)
-           {
-             for (k = 0; k < size; k++)
-               {
-                 if (A[k][i] < 0)
-                   {
-                     multiple = least_common_multiple (A[j][i], A[k][i]);
-                     f1 = multiple / A[j][i];
-                     f2 = -1 * multiple / A[k][i];
-
-                     lambda_vector_add_mc (A[j], f1, A[k], f2,
-                                           A1[newsize], depth);
-                     lambda_vector_add_mc (B[j], f1, B[k], f2,
-                                           B1[newsize], invariants);
-                     a1[newsize] = f1 * a[j] + f2 * a[k];
-                     newsize++;
-                   }
-               }
-           }
-       }
-
-      swapmatrix = A;
-      A = A1;
-      A1 = swapmatrix;
-
-      swapmatrix = B;
-      B = B1;
-      B1 = swapmatrix;
-
-      swapvector = a;
-      a = a1;
-      a1 = swapvector;
-
-      size = newsize;
-    }
-
-  return auxillary_nest;
-}
-
-/* Compute the loop bounds for the auxiliary space NEST.
-   Input system used is Ax <= b.  TRANS is the unimodular transformation.
-   Given the original nest, this function will
-   1. Convert the nest into matrix form, which consists of a matrix for the
-   coefficients, a matrix for the
-   invariant coefficients, and a vector for the constants.
-   2. Use the matrix form to calculate the lattice base for the nest (which is
-   a dense space)
-   3. Compose the dense space transform with the user specified transform, to
-   get a transform we can easily calculate transformed bounds for.
-   4. Multiply the composed transformation matrix times the matrix form of the
-   loop.
-   5. Transform the newly created matrix (from step 4) back into a loop nest
-   using Fourier-Motzkin elimination to figure out the bounds.  */
-
-static lambda_loopnest
-lambda_compute_auxillary_space (lambda_loopnest nest,
-                                lambda_trans_matrix trans,
-                                struct obstack * lambda_obstack)
-{
-  lambda_matrix A, B, A1, B1;
-  lambda_vector a, a1;
-  lambda_matrix invertedtrans;
-  int depth, invariants, size;
-  int i, j;
-  lambda_loop loop;
-  lambda_linear_expression expression;
-  lambda_lattice lattice;
-
-  depth = LN_DEPTH (nest);
-  invariants = LN_INVARIANTS (nest);
-
-  /* Unfortunately, we can't know the number of constraints we'll have
-     ahead of time, but this should be enough even in ridiculous loop nest
-     cases. We must not go over this limit.  */
-  A = lambda_matrix_new (128, depth, lambda_obstack);
-  B = lambda_matrix_new (128, invariants, lambda_obstack);
-  a = lambda_vector_new (128);
-
-  A1 = lambda_matrix_new (128, depth, lambda_obstack);
-  B1 = lambda_matrix_new (128, invariants, lambda_obstack);
-  a1 = lambda_vector_new (128);
-
-  /* Store the bounds in the equation matrix A, constant vector a, and
-     invariant matrix B, so that we have Ax <= a + B.
-     This requires a little equation rearranging so that everything is on the
-     correct side of the inequality.  */
-  size = 0;
-  for (i = 0; i < depth; i++)
-    {
-      loop = LN_LOOPS (nest)[i];
-
-      /* First we do the lower bound.  */
-      if (LL_STEP (loop) > 0)
-       expression = LL_LOWER_BOUND (loop);
-      else
-       expression = LL_UPPER_BOUND (loop);
-
-      for (; expression != NULL; expression = LLE_NEXT (expression))
-       {
-         /* Fill in the coefficient.  */
-         for (j = 0; j < i; j++)
-           A[size][j] = LLE_COEFFICIENTS (expression)[j];
-
-         /* And the invariant coefficient.  */
-         for (j = 0; j < invariants; j++)
-           B[size][j] = LLE_INVARIANT_COEFFICIENTS (expression)[j];
-
-         /* And the constant.  */
-         a[size] = LLE_CONSTANT (expression);
-
-         /* Convert (2x+3y+2+b)/4 <= z to 2x+3y-4z <= -2-b.  IE put all
-            constants and single variables on   */
-         A[size][i] = -1 * LLE_DENOMINATOR (expression);
-         a[size] *= -1;
-         for (j = 0; j < invariants; j++)
-           B[size][j] *= -1;
-
-         size++;
-         /* Need to increase matrix sizes above.  */
-         gcc_assert (size <= 127);
-
-       }
-
-      /* Then do the exact same thing for the upper bounds.  */
-      if (LL_STEP (loop) > 0)
-       expression = LL_UPPER_BOUND (loop);
-      else
-       expression = LL_LOWER_BOUND (loop);
-
-      for (; expression != NULL; expression = LLE_NEXT (expression))
-       {
-         /* Fill in the coefficient.  */
-         for (j = 0; j < i; j++)
-           A[size][j] = LLE_COEFFICIENTS (expression)[j];
-
-         /* And the invariant coefficient.  */
-         for (j = 0; j < invariants; j++)
-           B[size][j] = LLE_INVARIANT_COEFFICIENTS (expression)[j];
-
-         /* And the constant.  */
-         a[size] = LLE_CONSTANT (expression);
-
-         /* Convert z <= (2x+3y+2+b)/4 to -2x-3y+4z <= 2+b.  */
-         for (j = 0; j < i; j++)
-           A[size][j] *= -1;
-         A[size][i] = LLE_DENOMINATOR (expression);
-         size++;
-         /* Need to increase matrix sizes above.  */
-         gcc_assert (size <= 127);
-
-       }
-    }
-
-  /* Compute the lattice base x = base * y + origin, where y is the
-     base space.  */
-  lattice = lambda_lattice_compute_base (nest, lambda_obstack);
-
-  /* Ax <= a + B then becomes ALy <= a+B - A*origin.  L is the lattice base  */
-
-  /* A1 = A * L */
-  lambda_matrix_mult (A, LATTICE_BASE (lattice), A1, size, depth, depth);
-
-  /* a1 = a - A * origin constant.  */
-  lambda_matrix_vector_mult (A, size, depth, LATTICE_ORIGIN (lattice), a1);
-  lambda_vector_add_mc (a, 1, a1, -1, a1, size);
-
-  /* B1 = B - A * origin invariant.  */
-  lambda_matrix_mult (A, LATTICE_ORIGIN_INVARIANTS (lattice), B1, size, depth,
-                     invariants);
-  lambda_matrix_add_mc (B, 1, B1, -1, B1, size, invariants);
-
-  /* Now compute the auxiliary space bounds by first inverting U, multiplying
-     it by A1, then performing Fourier-Motzkin.  */
-
-  invertedtrans = lambda_matrix_new (depth, depth, lambda_obstack);
-
-  /* Compute the inverse of U.  */
-  lambda_matrix_inverse (LTM_MATRIX (trans),
-                        invertedtrans, depth, lambda_obstack);
-
-  /* A = A1 inv(U).  */
-  lambda_matrix_mult (A1, invertedtrans, A, size, depth, depth);
-
-  return compute_nest_using_fourier_motzkin (size, depth, invariants,
-                                             A, B1, a1, lambda_obstack);
-}
-
-/* Compute the loop bounds for the target space, using the bounds of
-   the auxiliary nest AUXILLARY_NEST, and the triangular matrix H.
-   The target space loop bounds are computed by multiplying the triangular
-   matrix H by the auxiliary nest, to get the new loop bounds.  The sign of
-   the loop steps (positive or negative) is then used to swap the bounds if
-   the loop counts downwards.
-   Return the target loopnest.  */
-
-static lambda_loopnest
-lambda_compute_target_space (lambda_loopnest auxillary_nest,
-                             lambda_trans_matrix H, lambda_vector stepsigns,
-                             struct obstack * lambda_obstack)
-{
-  lambda_matrix inverse, H1;
-  int determinant, i, j;
-  int gcd1, gcd2;
-  int factor;
-
-  lambda_loopnest target_nest;
-  int depth, invariants;
-  lambda_matrix target;
-
-  lambda_loop auxillary_loop, target_loop;
-  lambda_linear_expression expression, auxillary_expr, target_expr, tmp_expr;
-
-  depth = LN_DEPTH (auxillary_nest);
-  invariants = LN_INVARIANTS (auxillary_nest);
-
-  inverse = lambda_matrix_new (depth, depth, lambda_obstack);
-  determinant = lambda_matrix_inverse (LTM_MATRIX (H), inverse, depth,
-                                      lambda_obstack);
-
-  /* H1 is H excluding its diagonal.  */
-  H1 = lambda_matrix_new (depth, depth, lambda_obstack);
-  lambda_matrix_copy (LTM_MATRIX (H), H1, depth, depth);
-
-  for (i = 0; i < depth; i++)
-    H1[i][i] = 0;
-
-  /* Computes the linear offsets of the loop bounds.  */
-  target = lambda_matrix_new (depth, depth, lambda_obstack);
-  lambda_matrix_mult (H1, inverse, target, depth, depth, depth);
-
-  target_nest = lambda_loopnest_new (depth, invariants, lambda_obstack);
-
-  for (i = 0; i < depth; i++)
-    {
-
-      /* Get a new loop structure.  */
-      target_loop = lambda_loop_new (lambda_obstack);
-      LN_LOOPS (target_nest)[i] = target_loop;
-
-      /* Computes the gcd of the coefficients of the linear part.  */
-      gcd1 = lambda_vector_gcd (target[i], i);
-
-      /* Include the denominator in the GCD.  */
-      gcd1 = gcd (gcd1, determinant);
-
-      /* Now divide through by the gcd.  */
-      for (j = 0; j < i; j++)
-       target[i][j] = target[i][j] / gcd1;
-
-      expression = lambda_linear_expression_new (depth, invariants,
-                                                 lambda_obstack);
-      lambda_vector_copy (target[i], LLE_COEFFICIENTS (expression), depth);
-      LLE_DENOMINATOR (expression) = determinant / gcd1;
-      LLE_CONSTANT (expression) = 0;
-      lambda_vector_clear (LLE_INVARIANT_COEFFICIENTS (expression),
-                          invariants);
-      LL_LINEAR_OFFSET (target_loop) = expression;
-    }
-
-  /* For each loop, compute the new bounds from H.  */
-  for (i = 0; i < depth; i++)
-    {
-      auxillary_loop = LN_LOOPS (auxillary_nest)[i];
-      target_loop = LN_LOOPS (target_nest)[i];
-      LL_STEP (target_loop) = LTM_MATRIX (H)[i][i];
-      factor = LTM_MATRIX (H)[i][i];
-
-      /* First we do the lower bound.  */
-      auxillary_expr = LL_LOWER_BOUND (auxillary_loop);
-
-      for (; auxillary_expr != NULL;
-          auxillary_expr = LLE_NEXT (auxillary_expr))
-       {
-          target_expr = lambda_linear_expression_new (depth, invariants,
-                                                      lambda_obstack);
-         lambda_vector_matrix_mult (LLE_COEFFICIENTS (auxillary_expr),
-                                    depth, inverse, depth,
-                                    LLE_COEFFICIENTS (target_expr));
-         lambda_vector_mult_const (LLE_COEFFICIENTS (target_expr),
-                                   LLE_COEFFICIENTS (target_expr), depth,
-                                   factor);
-
-         LLE_CONSTANT (target_expr) = LLE_CONSTANT (auxillary_expr) * factor;
-         lambda_vector_copy (LLE_INVARIANT_COEFFICIENTS (auxillary_expr),
-                             LLE_INVARIANT_COEFFICIENTS (target_expr),
-                             invariants);
-         lambda_vector_mult_const (LLE_INVARIANT_COEFFICIENTS (target_expr),
-                                   LLE_INVARIANT_COEFFICIENTS (target_expr),
-                                   invariants, factor);
-         LLE_DENOMINATOR (target_expr) = LLE_DENOMINATOR (auxillary_expr);
-
-         if (!lambda_vector_zerop (LLE_COEFFICIENTS (target_expr), depth))
-           {
-             LLE_CONSTANT (target_expr) = LLE_CONSTANT (target_expr)
-               * determinant;
-             lambda_vector_mult_const (LLE_INVARIANT_COEFFICIENTS
-                                       (target_expr),
-                                       LLE_INVARIANT_COEFFICIENTS
-                                       (target_expr), invariants,
-                                       determinant);
-             LLE_DENOMINATOR (target_expr) =
-               LLE_DENOMINATOR (target_expr) * determinant;
-           }
-         /* Find the gcd and divide by it here, rather than doing it
-            at the tree level.  */
-         gcd1 = lambda_vector_gcd (LLE_COEFFICIENTS (target_expr), depth);
-         gcd2 = lambda_vector_gcd (LLE_INVARIANT_COEFFICIENTS (target_expr),
-                                   invariants);
-         gcd1 = gcd (gcd1, gcd2);
-         gcd1 = gcd (gcd1, LLE_CONSTANT (target_expr));
-         gcd1 = gcd (gcd1, LLE_DENOMINATOR (target_expr));
-         for (j = 0; j < depth; j++)
-           LLE_COEFFICIENTS (target_expr)[j] /= gcd1;
-         for (j = 0; j < invariants; j++)
-           LLE_INVARIANT_COEFFICIENTS (target_expr)[j] /= gcd1;
-         LLE_CONSTANT (target_expr) /= gcd1;
-         LLE_DENOMINATOR (target_expr) /= gcd1;
-         /* Ignore if identical to existing bound.  */
-         if (!lle_equal (LL_LOWER_BOUND (target_loop), target_expr, depth,
-                         invariants))
-           {
-             LLE_NEXT (target_expr) = LL_LOWER_BOUND (target_loop);
-             LL_LOWER_BOUND (target_loop) = target_expr;
-           }
-       }
-      /* Now do the upper bound.  */
-      auxillary_expr = LL_UPPER_BOUND (auxillary_loop);
-
-      for (; auxillary_expr != NULL;
-          auxillary_expr = LLE_NEXT (auxillary_expr))
-       {
-          target_expr = lambda_linear_expression_new (depth, invariants,
-                                                      lambda_obstack);
-         lambda_vector_matrix_mult (LLE_COEFFICIENTS (auxillary_expr),
-                                    depth, inverse, depth,
-                                    LLE_COEFFICIENTS (target_expr));
-         lambda_vector_mult_const (LLE_COEFFICIENTS (target_expr),
-                                   LLE_COEFFICIENTS (target_expr), depth,
-                                   factor);
-         LLE_CONSTANT (target_expr) = LLE_CONSTANT (auxillary_expr) * factor;
-         lambda_vector_copy (LLE_INVARIANT_COEFFICIENTS (auxillary_expr),
-                             LLE_INVARIANT_COEFFICIENTS (target_expr),
-                             invariants);
-         lambda_vector_mult_const (LLE_INVARIANT_COEFFICIENTS (target_expr),
-                                   LLE_INVARIANT_COEFFICIENTS (target_expr),
-                                   invariants, factor);
-         LLE_DENOMINATOR (target_expr) = LLE_DENOMINATOR (auxillary_expr);
-
-         if (!lambda_vector_zerop (LLE_COEFFICIENTS (target_expr), depth))
-           {
-             LLE_CONSTANT (target_expr) = LLE_CONSTANT (target_expr)
-               * determinant;
-             lambda_vector_mult_const (LLE_INVARIANT_COEFFICIENTS
-                                       (target_expr),
-                                       LLE_INVARIANT_COEFFICIENTS
-                                       (target_expr), invariants,
-                                       determinant);
-             LLE_DENOMINATOR (target_expr) =
-               LLE_DENOMINATOR (target_expr) * determinant;
-           }
-         /* Find the gcd and divide by it here, instead of at the
-            tree level.  */
-         gcd1 = lambda_vector_gcd (LLE_COEFFICIENTS (target_expr), depth);
-         gcd2 = lambda_vector_gcd (LLE_INVARIANT_COEFFICIENTS (target_expr),
-                                   invariants);
-         gcd1 = gcd (gcd1, gcd2);
-         gcd1 = gcd (gcd1, LLE_CONSTANT (target_expr));
-         gcd1 = gcd (gcd1, LLE_DENOMINATOR (target_expr));
-         for (j = 0; j < depth; j++)
-           LLE_COEFFICIENTS (target_expr)[j] /= gcd1;
-         for (j = 0; j < invariants; j++)
-           LLE_INVARIANT_COEFFICIENTS (target_expr)[j] /= gcd1;
-         LLE_CONSTANT (target_expr) /= gcd1;
-         LLE_DENOMINATOR (target_expr) /= gcd1;
-         /* Ignore if equal to existing bound.  */
-         if (!lle_equal (LL_UPPER_BOUND (target_loop), target_expr, depth,
-                         invariants))
-           {
-             LLE_NEXT (target_expr) = LL_UPPER_BOUND (target_loop);
-             LL_UPPER_BOUND (target_loop) = target_expr;
-           }
-       }
-    }
-  for (i = 0; i < depth; i++)
-    {
-      target_loop = LN_LOOPS (target_nest)[i];
-      /* If necessary, exchange the upper and lower bounds and negate
-         the step size.  */
-      if (stepsigns[i] < 0)
-       {
-         LL_STEP (target_loop) *= -1;
-         tmp_expr = LL_LOWER_BOUND (target_loop);
-         LL_LOWER_BOUND (target_loop) = LL_UPPER_BOUND (target_loop);
-         LL_UPPER_BOUND (target_loop) = tmp_expr;
-       }
-    }
-  return target_nest;
-}
-
-/* Compute the step signs of TRANS, using TRANS and stepsigns.  Return the new
-   result.  */
-
-static lambda_vector
-lambda_compute_step_signs (lambda_trans_matrix trans,
-                           lambda_vector stepsigns,
-                           struct obstack * lambda_obstack)
-{
-  lambda_matrix matrix, H;
-  int size;
-  lambda_vector newsteps;
-  int i, j, factor, minimum_column;
-  int temp;
-
-  matrix = LTM_MATRIX (trans);
-  size = LTM_ROWSIZE (trans);
-  H = lambda_matrix_new (size, size, lambda_obstack);
-
-  newsteps = lambda_vector_new (size);
-  lambda_vector_copy (stepsigns, newsteps, size);
-
-  lambda_matrix_copy (matrix, H, size, size);
-
-  for (j = 0; j < size; j++)
-    {
-      lambda_vector row;
-      row = H[j];
-      for (i = j; i < size; i++)
-       if (row[i] < 0)
-         lambda_matrix_col_negate (H, size, i);
-      while (lambda_vector_first_nz (row, size, j + 1) < size)
-       {
-         minimum_column = lambda_vector_min_nz (row, size, j);
-         lambda_matrix_col_exchange (H, size, j, minimum_column);
-
-         temp = newsteps[j];
-         newsteps[j] = newsteps[minimum_column];
-         newsteps[minimum_column] = temp;
-
-         for (i = j + 1; i < size; i++)
-           {
-             factor = row[i] / row[j];
-             lambda_matrix_col_add (H, size, j, i, -1 * factor);
-           }
-       }
-    }
-  return newsteps;
-}
-
-/* Transform NEST according to TRANS, and return the new loopnest.
-   This involves
-   1. Computing a lattice base for the transformation
-   2. Composing the dense base with the specified transformation (TRANS)
-   3. Decomposing the combined transformation into a lower triangular portion,
-   and a unimodular portion.
-   4. Computing the auxiliary nest using the unimodular portion.
-   5. Computing the target nest using the auxiliary nest and the lower
-   triangular portion.  */
-
-lambda_loopnest
-lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans,
-                           struct obstack * lambda_obstack)
-{
-  lambda_loopnest auxillary_nest, target_nest;
-
-  int depth, invariants;
-  int i, j;
-  lambda_lattice lattice;
-  lambda_trans_matrix trans1, H, U;
-  lambda_loop loop;
-  lambda_linear_expression expression;
-  lambda_vector origin;
-  lambda_matrix origin_invariants;
-  lambda_vector stepsigns;
-  int f;
-
-  depth = LN_DEPTH (nest);
-  invariants = LN_INVARIANTS (nest);
-
-  /* Keep track of the signs of the loop steps.  */
-  stepsigns = lambda_vector_new (depth);
-  for (i = 0; i < depth; i++)
-    {
-      if (LL_STEP (LN_LOOPS (nest)[i]) > 0)
-       stepsigns[i] = 1;
-      else
-       stepsigns[i] = -1;
-    }
-
-  /* Compute the lattice base.  */
-  lattice = lambda_lattice_compute_base (nest, lambda_obstack);
-  trans1 = lambda_trans_matrix_new (depth, depth, lambda_obstack);
-
-  /* Multiply the transformation matrix by the lattice base.  */
-
-  lambda_matrix_mult (LTM_MATRIX (trans), LATTICE_BASE (lattice),
-                     LTM_MATRIX (trans1), depth, depth, depth);
-
-  /* Compute the Hermite normal form for the new transformation matrix.  */
-  H = lambda_trans_matrix_new (depth, depth, lambda_obstack);
-  U = lambda_trans_matrix_new (depth, depth, lambda_obstack);
-  lambda_matrix_hermite (LTM_MATRIX (trans1), depth, LTM_MATRIX (H),
-                        LTM_MATRIX (U));
-
-  /* Compute the auxiliary loop nest's space from the unimodular
-     portion.  */
-  auxillary_nest = lambda_compute_auxillary_space (nest, U,
-                                                  lambda_obstack);
-
-  /* Compute the loop step signs from the old step signs and the
-     transformation matrix.  */
-  stepsigns = lambda_compute_step_signs (trans1, stepsigns,
-                                        lambda_obstack);
-
-  /* Compute the target loop nest space from the auxiliary nest and
-     the lower triangular matrix H.  */
-  target_nest = lambda_compute_target_space (auxillary_nest, H, stepsigns,
-                                             lambda_obstack);
-  origin = lambda_vector_new (depth);
-  origin_invariants = lambda_matrix_new (depth, invariants, lambda_obstack);
-  lambda_matrix_vector_mult (LTM_MATRIX (trans), depth, depth,
-                            LATTICE_ORIGIN (lattice), origin);
-  lambda_matrix_mult (LTM_MATRIX (trans), LATTICE_ORIGIN_INVARIANTS (lattice),
-                     origin_invariants, depth, depth, invariants);
-
-  for (i = 0; i < depth; i++)
-    {
-      loop = LN_LOOPS (target_nest)[i];
-      expression = LL_LINEAR_OFFSET (loop);
-      if (lambda_vector_zerop (LLE_COEFFICIENTS (expression), depth))
-       f = 1;
-      else
-       f = LLE_DENOMINATOR (expression);
-
-      LLE_CONSTANT (expression) += f * origin[i];
-
-      for (j = 0; j < invariants; j++)
-       LLE_INVARIANT_COEFFICIENTS (expression)[j] +=
-         f * origin_invariants[i][j];
-    }
-
-  return target_nest;
-
-}
-
-/* Convert a gcc tree expression EXPR to a lambda linear expression, and
-   return the new expression.  DEPTH is the depth of the loopnest.
-   OUTERINDUCTIONVARS is an array of the induction variables for outer loops
-   in this nest.  INVARIANTS is the array of invariants for the loop.  EXTRA
-   is the amount we have to add/subtract from the expression because of the
-   type of comparison it is used in.  */
-
-static lambda_linear_expression
-gcc_tree_to_linear_expression (int depth, tree expr,
-                              VEC(tree,heap) *outerinductionvars,
-                               VEC(tree,heap) *invariants, int extra,
-                               struct obstack * lambda_obstack)
-{
-  lambda_linear_expression lle = NULL;
-  switch (TREE_CODE (expr))
-    {
-    case INTEGER_CST:
-      {
-        lle = lambda_linear_expression_new (depth, 2 * depth, lambda_obstack);
-       LLE_CONSTANT (lle) = TREE_INT_CST_LOW (expr);
-       if (extra != 0)
-         LLE_CONSTANT (lle) += extra;
-
-       LLE_DENOMINATOR (lle) = 1;
-      }
-      break;
-    case SSA_NAME:
-      {
-       tree iv, invar;
-       size_t i;
-       FOR_EACH_VEC_ELT (tree, outerinductionvars, i, iv)
-         if (iv != NULL)
-           {
-             if (SSA_NAME_VAR (iv) == SSA_NAME_VAR (expr))
-               {
-                  lle = lambda_linear_expression_new (depth, 2 * depth,
-                                                      lambda_obstack);
-                 LLE_COEFFICIENTS (lle)[i] = 1;
-                 if (extra != 0)
-                   LLE_CONSTANT (lle) = extra;
-
-                 LLE_DENOMINATOR (lle) = 1;
-               }
-           }
-       FOR_EACH_VEC_ELT (tree, invariants, i, invar)
-         if (invar != NULL)
-           {
-             if (SSA_NAME_VAR (invar) == SSA_NAME_VAR (expr))
-               {
-                  lle = lambda_linear_expression_new (depth, 2 * depth,
-                                                      lambda_obstack);
-                 LLE_INVARIANT_COEFFICIENTS (lle)[i] = 1;
-                 if (extra != 0)
-                   LLE_CONSTANT (lle) = extra;
-                 LLE_DENOMINATOR (lle) = 1;
-               }
-           }
-      }
-      break;
-    default:
-      return NULL;
-    }
-
-  return lle;
-}
-
-/* Return the depth of the loopnest NEST */
-
-static int
-depth_of_nest (struct loop *nest)
-{
-  size_t depth = 0;
-  while (nest)
-    {
-      depth++;
-      nest = nest->inner;
-    }
-  return depth;
-}
-
-
-/* Return true if OP is invariant in LOOP and all outer loops.  */
-
-static bool
-invariant_in_loop_and_outer_loops (struct loop *loop, tree op)
-{
-  if (is_gimple_min_invariant (op))
-    return true;
-  if (loop_depth (loop) == 0)
-    return true;
-  if (!expr_invariant_in_loop_p (loop, op))
-    return false;
-  if (!invariant_in_loop_and_outer_loops (loop_outer (loop), op))
-    return false;
-  return true;
-}
-
-/* Generate a lambda loop from a gcc loop LOOP.  Return the new lambda loop,
-   or NULL if it could not be converted.
-   DEPTH is the depth of the loop.
-   INVARIANTS is a pointer to the array of loop invariants.
-   The induction variable for this loop should be stored in the parameter
-   OURINDUCTIONVAR.
-   OUTERINDUCTIONVARS is an array of induction variables for outer loops.  */
-
-static lambda_loop
-gcc_loop_to_lambda_loop (struct loop *loop, int depth,
-                        VEC(tree,heap) ** invariants,
-                        tree * ourinductionvar,
-                        VEC(tree,heap) * outerinductionvars,
-                        VEC(tree,heap) ** lboundvars,
-                        VEC(tree,heap) ** uboundvars,
-                        VEC(int,heap) ** steps,
-                         struct obstack * lambda_obstack)
-{
-  gimple phi;
-  gimple exit_cond;
-  tree access_fn, inductionvar;
-  tree step;
-  lambda_loop lloop = NULL;
-  lambda_linear_expression lbound, ubound;
-  tree test_lhs, test_rhs;
-  int stepint;
-  int extra = 0;
-  tree lboundvar, uboundvar, uboundresult;
-
-  /* Find out induction var and exit condition.  */
-  inductionvar = find_induction_var_from_exit_cond (loop);
-  exit_cond = get_loop_exit_condition (loop);
-
-  if (inductionvar == NULL || exit_cond == NULL)
-    {
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       fprintf (dump_file,
-                "Unable to convert loop: Cannot determine exit condition or induction variable for loop.\n");
-      return NULL;
-    }
-
-  if (SSA_NAME_DEF_STMT (inductionvar) == NULL)
-    {
-
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       fprintf (dump_file,
-                "Unable to convert loop: Cannot find PHI node for induction variable\n");
-
-      return NULL;
-    }
-
-  phi = SSA_NAME_DEF_STMT (inductionvar);
-  if (gimple_code (phi) != GIMPLE_PHI)
-    {
-      tree op = SINGLE_SSA_TREE_OPERAND (phi, SSA_OP_USE);
-      if (!op)
-       {
-
-         if (dump_file && (dump_flags & TDF_DETAILS))
-           fprintf (dump_file,
-                    "Unable to convert loop: Cannot find PHI node for induction variable\n");
-
-         return NULL;
-       }
-
-      phi = SSA_NAME_DEF_STMT (op);
-      if (gimple_code (phi) != GIMPLE_PHI)
-       {
-         if (dump_file && (dump_flags & TDF_DETAILS))
-           fprintf (dump_file,
-                    "Unable to convert loop: Cannot find PHI node for induction variable\n");
-         return NULL;
-       }
-    }
-
-  /* The induction variable name/version we want to put in the array is the
-     result of the induction variable phi node.  */
-  *ourinductionvar = PHI_RESULT (phi);
-  access_fn = instantiate_parameters
-    (loop, analyze_scalar_evolution (loop, PHI_RESULT (phi)));
-  if (access_fn == chrec_dont_know)
-    {
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       fprintf (dump_file,
-                "Unable to convert loop: Access function for induction variable phi is unknown\n");
-
-      return NULL;
-    }
-
-  step = evolution_part_in_loop_num (access_fn, loop->num);
-  if (!step || step == chrec_dont_know)
-    {
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       fprintf (dump_file,
-                "Unable to convert loop: Cannot determine step of loop.\n");
-
-      return NULL;
-    }
-  if (TREE_CODE (step) != INTEGER_CST)
-    {
-
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       fprintf (dump_file,
-                "Unable to convert loop: Step of loop is not integer.\n");
-      return NULL;
-    }
-
-  stepint = TREE_INT_CST_LOW (step);
-
-  /* Only want phis for induction vars, which will have two
-     arguments.  */
-  if (gimple_phi_num_args (phi) != 2)
-    {
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       fprintf (dump_file,
-                "Unable to convert loop: PHI node for induction variable has >2 arguments\n");
-      return NULL;
-    }
-
-  /* Another induction variable check. One argument's source should be
-     in the loop, one outside the loop.  */
-  if (flow_bb_inside_loop_p (loop, gimple_phi_arg_edge (phi, 0)->src)
-      && flow_bb_inside_loop_p (loop, gimple_phi_arg_edge (phi, 1)->src))
-    {
-
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       fprintf (dump_file,
-                "Unable to convert loop: PHI edges both inside loop, or both outside loop.\n");
-
-      return NULL;
-    }
-
-  if (flow_bb_inside_loop_p (loop, gimple_phi_arg_edge (phi, 0)->src))
-    {
-      lboundvar = PHI_ARG_DEF (phi, 1);
-      lbound = gcc_tree_to_linear_expression (depth, lboundvar,
-                                             outerinductionvars, *invariants,
-                                              0, lambda_obstack);
-    }
-  else
-    {
-      lboundvar = PHI_ARG_DEF (phi, 0);
-      lbound = gcc_tree_to_linear_expression (depth, lboundvar,
-                                             outerinductionvars, *invariants,
-                                              0, lambda_obstack);
-    }
-
-  if (!lbound)
-    {
-
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       fprintf (dump_file,
-                "Unable to convert loop: Cannot convert lower bound to linear expression\n");
-
-      return NULL;
-    }
-  /* One part of the test may be a loop invariant tree.  */
-  VEC_reserve (tree, heap, *invariants, 1);
-  test_lhs = gimple_cond_lhs (exit_cond);
-  test_rhs = gimple_cond_rhs (exit_cond);
-
-  if (TREE_CODE (test_rhs) == SSA_NAME
-      && invariant_in_loop_and_outer_loops (loop, test_rhs))
-    VEC_quick_push (tree, *invariants, test_rhs);
-  else if (TREE_CODE (test_lhs) == SSA_NAME
-          && invariant_in_loop_and_outer_loops (loop, test_lhs))
-    VEC_quick_push (tree, *invariants, test_lhs);
-
-  /* The non-induction variable part of the test is the upper bound variable.
-   */
-  if (test_lhs == inductionvar)
-    uboundvar = test_rhs;
-  else
-    uboundvar = test_lhs;
-
-  /* We only size the vectors assuming we have, at max, 2 times as many
-     invariants as we do loops (one for each bound).
-     This is just an arbitrary number, but it has to be matched against the
-     code below.  */
-  gcc_assert (VEC_length (tree, *invariants) <= (unsigned int) (2 * depth));
-
-
-  /* We might have some leftover.  */
-  if (gimple_cond_code (exit_cond) == LT_EXPR)
-    extra = -1 * stepint;
-  else if (gimple_cond_code (exit_cond) == NE_EXPR)
-    extra = -1 * stepint;
-  else if (gimple_cond_code (exit_cond) == GT_EXPR)
-    extra = -1 * stepint;
-  else if (gimple_cond_code (exit_cond) == EQ_EXPR)
-    extra = 1 * stepint;
-
-  ubound = gcc_tree_to_linear_expression (depth, uboundvar,
-                                         outerinductionvars,
-                                          *invariants, extra, lambda_obstack);
-  uboundresult = build2 (PLUS_EXPR, TREE_TYPE (uboundvar), uboundvar,
-                        build_int_cst (TREE_TYPE (uboundvar), extra));
-  VEC_safe_push (tree, heap, *uboundvars, uboundresult);
-  VEC_safe_push (tree, heap, *lboundvars, lboundvar);
-  VEC_safe_push (int, heap, *steps, stepint);
-  if (!ubound)
-    {
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       fprintf (dump_file,
-                "Unable to convert loop: Cannot convert upper bound to linear expression\n");
-      return NULL;
-    }
-
-  lloop = lambda_loop_new (lambda_obstack);
-  LL_STEP (lloop) = stepint;
-  LL_LOWER_BOUND (lloop) = lbound;
-  LL_UPPER_BOUND (lloop) = ubound;
-  return lloop;
-}
-
-/* Given a LOOP, find the induction variable it is testing against in the exit
-   condition.  Return the induction variable if found, NULL otherwise.  */
-
-tree
-find_induction_var_from_exit_cond (struct loop *loop)
-{
-  gimple expr = get_loop_exit_condition (loop);
-  tree ivarop;
-  tree test_lhs, test_rhs;
-  if (expr == NULL)
-    return NULL_TREE;
-  if (gimple_code (expr) != GIMPLE_COND)
-    return NULL_TREE;
-  test_lhs = gimple_cond_lhs (expr);
-  test_rhs = gimple_cond_rhs (expr);
-
-  /* Find the side that is invariant in this loop. The ivar must be the other
-     side.  */
-
-  if (expr_invariant_in_loop_p (loop, test_lhs))
-      ivarop = test_rhs;
-  else if (expr_invariant_in_loop_p (loop, test_rhs))
-      ivarop = test_lhs;
-  else
-    return NULL_TREE;
-
-  if (TREE_CODE (ivarop) != SSA_NAME)
-    return NULL_TREE;
-  return ivarop;
-}
-
-DEF_VEC_P(lambda_loop);
-DEF_VEC_ALLOC_P(lambda_loop,heap);
-
-/* Generate a lambda loopnest from a gcc loopnest LOOP_NEST.
-   Return the new loop nest.
-   INDUCTIONVARS is a pointer to an array of induction variables for the
-   loopnest that will be filled in during this process.
-   INVARIANTS is a pointer to an array of invariants that will be filled in
-   during this process.  */
-
-lambda_loopnest
-gcc_loopnest_to_lambda_loopnest (struct loop *loop_nest,
-                                VEC(tree,heap) **inductionvars,
-                                 VEC(tree,heap) **invariants,
-                                 struct obstack * lambda_obstack)
-{
-  lambda_loopnest ret = NULL;
-  struct loop *temp = loop_nest;
-  int depth = depth_of_nest (loop_nest);
-  size_t i;
-  VEC(lambda_loop,heap) *loops = NULL;
-  VEC(tree,heap) *uboundvars = NULL;
-  VEC(tree,heap) *lboundvars  = NULL;
-  VEC(int,heap) *steps = NULL;
-  lambda_loop newloop;
-  tree inductionvar = NULL;
-  bool perfect_nest = perfect_nest_p (loop_nest);
-
-  if (!perfect_nest && !can_convert_to_perfect_nest (loop_nest))
-    goto fail;
-
-  while (temp)
-    {
-      newloop = gcc_loop_to_lambda_loop (temp, depth, invariants,
-                                        &inductionvar, *inductionvars,
-                                        &lboundvars, &uboundvars,
-                                         &steps, lambda_obstack);
-      if (!newloop)
-       goto fail;
-
-      VEC_safe_push (tree, heap, *inductionvars, inductionvar);
-      VEC_safe_push (lambda_loop, heap, loops, newloop);
-      temp = temp->inner;
-    }
-
-  if (!perfect_nest)
-    {
-      if (!perfect_nestify (loop_nest, lboundvars, uboundvars, steps,
-                           *inductionvars))
-       {
-         if (dump_file)
-           fprintf (dump_file,
-                    "Not a perfect loop nest and couldn't convert to one.\n");
-         goto fail;
-       }
-      else if (dump_file)
-       fprintf (dump_file,
-                "Successfully converted loop nest to perfect loop nest.\n");
-    }
-
-  ret = lambda_loopnest_new (depth, 2 * depth, lambda_obstack);
-
-  FOR_EACH_VEC_ELT (lambda_loop, loops, i, newloop)
-    LN_LOOPS (ret)[i] = newloop;
-
- fail:
-  VEC_free (lambda_loop, heap, loops);
-  VEC_free (tree, heap, uboundvars);
-  VEC_free (tree, heap, lboundvars);
-  VEC_free (int, heap, steps);
-
-  return ret;
-}
-
-/* Convert a lambda body vector LBV to a gcc tree, and return the new tree.
-   STMTS_TO_INSERT is a pointer to a tree where the statements we need to be
-   inserted for us are stored.  INDUCTION_VARS is the array of induction
-   variables for the loop this LBV is from.  TYPE is the tree type to use for
-   the variables and trees involved.  */
-
-static tree
-lbv_to_gcc_expression (lambda_body_vector lbv,
-                      tree type, VEC(tree,heap) *induction_vars,
-                      gimple_seq *stmts_to_insert)
-{
-  int k;
-  tree resvar;
-  tree expr = build_linear_expr (type, LBV_COEFFICIENTS (lbv), induction_vars);
-
-  k = LBV_DENOMINATOR (lbv);
-  gcc_assert (k != 0);
-  if (k != 1)
-    expr = fold_build2 (CEIL_DIV_EXPR, type, expr, build_int_cst (type, k));
-
-  resvar = create_tmp_var (type, "lbvtmp");
-  add_referenced_var (resvar);
-  return force_gimple_operand (fold (expr), stmts_to_insert, true, resvar);
-}
-
-/* Convert a linear expression from coefficient and constant form to a
-   gcc tree.
-   Return the tree that represents the final value of the expression.
-   LLE is the linear expression to convert.
-   OFFSET is the linear offset to apply to the expression.
-   TYPE is the tree type to use for the variables and math.
-   INDUCTION_VARS is a vector of induction variables for the loops.
-   INVARIANTS is a vector of the loop nest invariants.
-   WRAP specifies what tree code to wrap the results in, if there is more than
-   one (it is either MAX_EXPR, or MIN_EXPR).
-   STMTS_TO_INSERT Is a pointer to the statement list we fill in with
-   statements that need to be inserted for the linear expression.  */
-
-static tree
-lle_to_gcc_expression (lambda_linear_expression lle,
-                      lambda_linear_expression offset,
-                      tree type,
-                      VEC(tree,heap) *induction_vars,
-                      VEC(tree,heap) *invariants,
-                      enum tree_code wrap, gimple_seq *stmts_to_insert)
-{
-  int k;
-  tree resvar;
-  tree expr = NULL_TREE;
-  VEC(tree,heap) *results = NULL;
-
-  gcc_assert (wrap == MAX_EXPR || wrap == MIN_EXPR);
-
-  /* Build up the linear expressions.  */
-  for (; lle != NULL; lle = LLE_NEXT (lle))
-    {
-      expr = build_linear_expr (type, LLE_COEFFICIENTS (lle), induction_vars);
-      expr = fold_build2 (PLUS_EXPR, type, expr,
-                         build_linear_expr (type,
-                                            LLE_INVARIANT_COEFFICIENTS (lle),
-                                            invariants));
-
-      k = LLE_CONSTANT (lle);
-      if (k)
-       expr = fold_build2 (PLUS_EXPR, type, expr, build_int_cst (type, k));
-
-      k = LLE_CONSTANT (offset);
-      if (k)
-       expr = fold_build2 (PLUS_EXPR, type, expr, build_int_cst (type, k));
-
-      k = LLE_DENOMINATOR (lle);
-      if (k != 1)
-       expr = fold_build2 (wrap == MAX_EXPR ? CEIL_DIV_EXPR : FLOOR_DIV_EXPR,
-                           type, expr, build_int_cst (type, k));
-
-      expr = fold (expr);
-      VEC_safe_push (tree, heap, results, expr);
-    }
-
-  gcc_assert (expr);
-
-  /* We may need to wrap the results in a MAX_EXPR or MIN_EXPR.  */
-  if (VEC_length (tree, results) > 1)
-    {
-      size_t i;
-      tree op;
-
-      expr = VEC_index (tree, results, 0);
-      for (i = 1; VEC_iterate (tree, results, i, op); i++)
-       expr = fold_build2 (wrap, type, expr, op);
-    }
-
-  VEC_free (tree, heap, results);
-
-  resvar = create_tmp_var (type, "lletmp");
-  add_referenced_var (resvar);
-  return force_gimple_operand (fold (expr), stmts_to_insert, true, resvar);
-}
-
-/* Remove the induction variable defined at IV_STMT.  */
-
-void
-remove_iv (gimple iv_stmt)
-{
-  gimple_stmt_iterator si = gsi_for_stmt (iv_stmt);
-
-  if (gimple_code (iv_stmt) == GIMPLE_PHI)
-    {
-      unsigned i;
-
-      for (i = 0; i < gimple_phi_num_args (iv_stmt); i++)
-       {
-         gimple stmt;
-         imm_use_iterator imm_iter;
-         tree arg = gimple_phi_arg_def (iv_stmt, i);
-         bool used = false;
-
-         if (TREE_CODE (arg) != SSA_NAME)
-           continue;
-
-         FOR_EACH_IMM_USE_STMT (stmt, imm_iter, arg)
-           if (stmt != iv_stmt && !is_gimple_debug (stmt))
-             used = true;
-
-         if (!used)
-           remove_iv (SSA_NAME_DEF_STMT (arg));
-       }
-
-      remove_phi_node (&si, true);
-    }
-  else
-    {
-      gsi_remove (&si, true);
-      release_defs (iv_stmt);
-    }
-}
-
-/* Transform a lambda loopnest NEW_LOOPNEST, which had TRANSFORM applied to
-   it, back into gcc code.  This changes the
-   loops, their induction variables, and their bodies, so that they
-   match the transformed loopnest.
-   OLD_LOOPNEST is the loopnest before we've replaced it with the new
-   loopnest.
-   OLD_IVS is a vector of induction variables from the old loopnest.
-   INVARIANTS is a vector of loop invariants from the old loopnest.
-   NEW_LOOPNEST is the new lambda loopnest to replace OLD_LOOPNEST with.
-   TRANSFORM is the matrix transform that was applied to OLD_LOOPNEST to get
-   NEW_LOOPNEST.  */
-
-void 
-lambda_loopnest_to_gcc_loopnest (struct loop *old_loopnest,
-                                VEC(tree,heap) *old_ivs,
-                                VEC(tree,heap) *invariants,
-                                VEC(gimple,heap) **remove_ivs,
-                                lambda_loopnest new_loopnest,
-                                 lambda_trans_matrix transform,
-                                 struct obstack * lambda_obstack)
-{
-  struct loop *temp;
-  size_t i = 0;
-  unsigned j;
-  size_t depth = 0;
-  VEC(tree,heap) *new_ivs = NULL;
-  tree oldiv;
-  gimple_stmt_iterator bsi;
-
-  transform = lambda_trans_matrix_inverse (transform, lambda_obstack);
-
-  if (dump_file)
-    {
-      fprintf (dump_file, "Inverse of transformation matrix:\n");
-      print_lambda_trans_matrix (dump_file, transform);
-    }
-  depth = depth_of_nest (old_loopnest);
-  temp = old_loopnest;
-
-  while (temp)
-    {
-      lambda_loop newloop;
-      basic_block bb;
-      edge exit;
-      tree ivvar, ivvarinced;
-      gimple exitcond;
-      gimple_seq stmts;
-      enum tree_code testtype;
-      tree newupperbound, newlowerbound;
-      lambda_linear_expression offset;
-      tree type;
-      bool insert_after;
-      gimple inc_stmt;
-
-      oldiv = VEC_index (tree, old_ivs, i);
-      type = TREE_TYPE (oldiv);
-
-      /* First, build the new induction variable temporary  */
-
-      ivvar = create_tmp_var (type, "lnivtmp");
-      add_referenced_var (ivvar);
-
-      VEC_safe_push (tree, heap, new_ivs, ivvar);
-
-      newloop = LN_LOOPS (new_loopnest)[i];
-
-      /* Linear offset is a bit tricky to handle.  Punt on the unhandled
-         cases for now.  */
-      offset = LL_LINEAR_OFFSET (newloop);
-
-      gcc_assert (LLE_DENOMINATOR (offset) == 1 &&
-                 lambda_vector_zerop (LLE_COEFFICIENTS (offset), depth));
-
-      /* Now build the  new lower bounds, and insert the statements
-         necessary to generate it on the loop preheader.  */
-      stmts = NULL;
-      newlowerbound = lle_to_gcc_expression (LL_LOWER_BOUND (newloop),
-                                            LL_LINEAR_OFFSET (newloop),
-                                            type,
-                                            new_ivs,
-                                            invariants, MAX_EXPR, &stmts);
-
-      if (stmts)
-       {
-         gsi_insert_seq_on_edge (loop_preheader_edge (temp), stmts);
-         gsi_commit_edge_inserts ();
-       }
-      /* Build the new upper bound and insert its statements in the
-         basic block of the exit condition */
-      stmts = NULL;
-      newupperbound = lle_to_gcc_expression (LL_UPPER_BOUND (newloop),
-                                            LL_LINEAR_OFFSET (newloop),
-                                            type,
-                                            new_ivs,
-                                            invariants, MIN_EXPR, &stmts);
-      exit = single_exit (temp);
-      exitcond = get_loop_exit_condition (temp);
-      bb = gimple_bb (exitcond);
-      bsi = gsi_after_labels (bb);
-      if (stmts)
-       gsi_insert_seq_before (&bsi, stmts, GSI_NEW_STMT);
-
-      /* Create the new iv.  */
-
-      standard_iv_increment_position (temp, &bsi, &insert_after);
-      create_iv (newlowerbound,
-                build_int_cst (type, LL_STEP (newloop)),
-                ivvar, temp, &bsi, insert_after, &ivvar,
-                NULL);
-
-      /* Unfortunately, the incremented ivvar that create_iv inserted may not
-        dominate the block containing the exit condition.
-        So we simply create our own incremented iv to use in the new exit
-        test,  and let redundancy elimination sort it out.  */
-      inc_stmt = gimple_build_assign_with_ops (PLUS_EXPR, SSA_NAME_VAR (ivvar),
-                                              ivvar,
-                                              build_int_cst (type, LL_STEP (newloop)));
-
-      ivvarinced = make_ssa_name (SSA_NAME_VAR (ivvar), inc_stmt);
-      gimple_assign_set_lhs (inc_stmt, ivvarinced);
-      bsi = gsi_for_stmt (exitcond);
-      gsi_insert_before (&bsi, inc_stmt, GSI_SAME_STMT);
-
-      /* Replace the exit condition with the new upper bound
-         comparison.  */
-
-      testtype = LL_STEP (newloop) >= 0 ? LE_EXPR : GE_EXPR;
-
-      /* We want to build a conditional where true means exit the loop, and
-        false means continue the loop.
-        So swap the testtype if this isn't the way things are.*/
-
-      if (exit->flags & EDGE_FALSE_VALUE)
-       testtype = swap_tree_comparison (testtype);
-
-      gimple_cond_set_condition (exitcond, testtype, newupperbound, ivvarinced);
-      update_stmt (exitcond);
-      VEC_replace (tree, new_ivs, i, ivvar);
-
-      i++;
-      temp = temp->inner;
-    }
-
-  /* Rewrite uses of the old ivs so that they are now specified in terms of
-     the new ivs.  */
-
-  FOR_EACH_VEC_ELT (tree, old_ivs, i, oldiv)
-    {
-      imm_use_iterator imm_iter;
-      use_operand_p use_p;
-      tree oldiv_def;
-      gimple oldiv_stmt = SSA_NAME_DEF_STMT (oldiv);
-      gimple stmt;
-
-      if (gimple_code (oldiv_stmt) == GIMPLE_PHI)
-        oldiv_def = PHI_RESULT (oldiv_stmt);
-      else
-       oldiv_def = SINGLE_SSA_TREE_OPERAND (oldiv_stmt, SSA_OP_DEF);
-      gcc_assert (oldiv_def != NULL_TREE);
-
-      FOR_EACH_IMM_USE_STMT (stmt, imm_iter, oldiv_def)
-        {
-         tree newiv;
-         gimple_seq stmts;
-         lambda_body_vector lbv, newlbv;
-
-         if (is_gimple_debug (stmt))
-           continue;
-
-         /* Compute the new expression for the induction
-            variable.  */
-         depth = VEC_length (tree, new_ivs);
-          lbv = lambda_body_vector_new (depth, lambda_obstack);
-         LBV_COEFFICIENTS (lbv)[i] = 1;
-
-          newlbv = lambda_body_vector_compute_new (transform, lbv,
-                                                   lambda_obstack);
-
-         stmts = NULL;
-         newiv = lbv_to_gcc_expression (newlbv, TREE_TYPE (oldiv),
-                                        new_ivs, &stmts);
-
-         if (stmts && gimple_code (stmt) != GIMPLE_PHI)
-           {
-             bsi = gsi_for_stmt (stmt);
-             gsi_insert_seq_before (&bsi, stmts, GSI_SAME_STMT);
-           }
-
-         FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
-           propagate_value (use_p, newiv);
-
-         if (stmts && gimple_code (stmt) == GIMPLE_PHI)
-           for (j = 0; j < gimple_phi_num_args (stmt); j++)
-             if (gimple_phi_arg_def (stmt, j) == newiv)
-               gsi_insert_seq_on_edge (gimple_phi_arg_edge (stmt, j), stmts);
-
-         update_stmt (stmt);
-       }
-
-      /* Remove the now unused induction variable.  */
-      VEC_safe_push (gimple, heap, *remove_ivs, oldiv_stmt);
-    }
-  VEC_free (tree, heap, new_ivs);
-}
-
-/* Return TRUE if this is not interesting statement from the perspective of
-   determining if we have a perfect loop nest.  */
-
-static bool
-not_interesting_stmt (gimple stmt)
-{
-  /* Note that COND_EXPR's aren't interesting because if they were exiting the
-     loop, we would have already failed the number of exits tests.  */
-  if (gimple_code (stmt) == GIMPLE_LABEL
-      || gimple_code (stmt) == GIMPLE_GOTO
-      || gimple_code (stmt) == GIMPLE_COND
-      || is_gimple_debug (stmt))
-    return true;
-  return false;
-}
-
-/* Return TRUE if PHI uses DEF for it's in-the-loop edge for LOOP.  */
-
-static bool
-phi_loop_edge_uses_def (struct loop *loop, gimple phi, tree def)
-{
-  unsigned i;
-  for (i = 0; i < gimple_phi_num_args (phi); i++)
-    if (flow_bb_inside_loop_p (loop, gimple_phi_arg_edge (phi, i)->src))
-      if (PHI_ARG_DEF (phi, i) == def)
-       return true;
-  return false;
-}
-
-/* Return TRUE if STMT is a use of PHI_RESULT.  */
-
-static bool
-stmt_uses_phi_result (gimple stmt, tree phi_result)
-{
-  tree use = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_USE);
-
-  /* This is conservatively true, because we only want SIMPLE bumpers
-     of the form x +- constant for our pass.  */
-  return (use == phi_result);
-}
-
-/* STMT is a bumper stmt for LOOP if the version it defines is used in the
-   in-loop-edge in a phi node, and the operand it uses is the result of that
-   phi node.
-   I.E. i_29 = i_3 + 1
-        i_3 = PHI (0, i_29);  */
-
-static bool
-stmt_is_bumper_for_loop (struct loop *loop, gimple stmt)
-{
-  gimple use;
-  tree def;
-  imm_use_iterator iter;
-  use_operand_p use_p;
-
-  def = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF);
-  if (!def)
-    return false;
-
-  FOR_EACH_IMM_USE_FAST (use_p, iter, def)
-    {
-      use = USE_STMT (use_p);
-      if (gimple_code (use) == GIMPLE_PHI)
-       {
-         if (phi_loop_edge_uses_def (loop, use, def))
-           if (stmt_uses_phi_result (stmt, PHI_RESULT (use)))
-             return true;
-       }
-    }
-  return false;
-}
-
-
-/* Return true if LOOP is a perfect loop nest.
-   Perfect loop nests are those loop nests where all code occurs in the
-   innermost loop body.
-   If S is a program statement, then
-
-   i.e.
-   DO I = 1, 20
-       S1
-       DO J = 1, 20
-       ...
-       END DO
-   END DO
-   is not a perfect loop nest because of S1.
-
-   DO I = 1, 20
-      DO J = 1, 20
-        S1
-       ...
-      END DO
-   END DO
-   is a perfect loop nest.
-
-   Since we don't have high level loops anymore, we basically have to walk our
-   statements and ignore those that are there because the loop needs them (IE
-   the induction variable increment, and jump back to the top of the loop).  */
-
-bool
-perfect_nest_p (struct loop *loop)
-{
-  basic_block *bbs;
-  size_t i;
-  gimple 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)
-       {
-         gimple_stmt_iterator bsi;
-
-         for (bsi = gsi_start_bb (bbs[i]); !gsi_end_p (bsi); gsi_next (&bsi))
-           {
-             gimple stmt = gsi_stmt (bsi);
-
-             if (gimple_code (stmt) == GIMPLE_COND
-                 && 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);
-
-  return perfect_nest_p (loop->inner);
-}
-
-/* Replace the USES of X in STMT, or uses with the same step as X with Y.
-   YINIT is the initial value of Y, REPLACEMENTS is a hash table to
-   avoid creating duplicate temporaries and FIRSTBSI is statement
-   iterator where new temporaries should be inserted at the beginning
-   of body basic block.  */
-
-static void
-replace_uses_equiv_to_x_with_y (struct loop *loop, gimple stmt, tree x,
-                               int xstep, tree y, tree yinit,
-                               htab_t replacements,
-                               gimple_stmt_iterator *firstbsi)
-{
-  ssa_op_iter iter;
-  use_operand_p use_p;
-
-  FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
-    {
-      tree use = USE_FROM_PTR (use_p);
-      tree step = NULL_TREE;
-      tree scev, init, val, var;
-      gimple setstmt;
-      struct tree_map *h, in;
-      void **loc;
-
-      /* Replace uses of X with Y right away.  */
-      if (use == x)
-       {
-         SET_USE (use_p, y);
-         continue;
-       }
-
-      scev = instantiate_parameters (loop,
-                                    analyze_scalar_evolution (loop, use));
-
-      if (scev == NULL || scev == chrec_dont_know)
-       continue;
-
-      step = evolution_part_in_loop_num (scev, loop->num);
-      if (step == NULL
-         || step == chrec_dont_know
-         || TREE_CODE (step) != INTEGER_CST
-         || int_cst_value (step) != xstep)
-       continue;
-
-      /* Use REPLACEMENTS hash table to cache already created
-        temporaries.  */
-      in.hash = htab_hash_pointer (use);
-      in.base.from = use;
-      h = (struct tree_map *) htab_find_with_hash (replacements, &in, in.hash);
-      if (h != NULL)
-       {
-         SET_USE (use_p, h->to);
-         continue;
-       }
-
-      /* USE which has the same step as X should be replaced
-        with a temporary set to Y + YINIT - INIT.  */
-      init = initial_condition_in_loop_num (scev, loop->num);
-      gcc_assert (init != NULL && init != chrec_dont_know);
-      if (TREE_TYPE (use) == TREE_TYPE (y))
-       {
-         val = fold_build2 (MINUS_EXPR, TREE_TYPE (y), init, yinit);
-         val = fold_build2 (PLUS_EXPR, TREE_TYPE (y), y, val);
-         if (val == y)
-           {
-             /* If X has the same type as USE, the same step
-                and same initial value, it can be replaced by Y.  */
-             SET_USE (use_p, y);
-             continue;
-           }
-       }
-      else
-       {
-         val = fold_build2 (MINUS_EXPR, TREE_TYPE (y), y, yinit);
-         val = fold_convert (TREE_TYPE (use), val);
-         val = fold_build2 (PLUS_EXPR, TREE_TYPE (use), val, init);
-       }
-
-      /* Create a temporary variable and insert it at the beginning
-        of the loop body basic block, right after the PHI node
-        which sets Y.  */
-      var = create_tmp_var (TREE_TYPE (use), "perfecttmp");
-      add_referenced_var (var);
-      val = force_gimple_operand_gsi (firstbsi, val, false, NULL,
-                                     true, GSI_SAME_STMT);
-      setstmt = gimple_build_assign (var, val);
-      var = make_ssa_name (var, setstmt);
-      gimple_assign_set_lhs (setstmt, var);
-      gsi_insert_before (firstbsi, setstmt, GSI_SAME_STMT);
-      update_stmt (setstmt);
-      SET_USE (use_p, var);
-      h = ggc_alloc_tree_map ();
-      h->hash = in.hash;
-      h->base.from = use;
-      h->to = var;
-      loc = htab_find_slot_with_hash (replacements, h, in.hash, INSERT);
-      gcc_assert ((*(struct tree_map **)loc) == NULL);
-      *(struct tree_map **) loc = h;
-    }
-}
-
-/* Return true if STMT is an exit PHI for LOOP */
-
-static bool
-exit_phi_for_loop_p (struct loop *loop, gimple stmt)
-{
-  if (gimple_code (stmt) != GIMPLE_PHI
-      || gimple_phi_num_args (stmt) != 1
-      || gimple_bb (stmt) != single_exit (loop)->dest)
-    return false;
-
-  return true;
-}
-
-/* Return true if STMT can be put back into the loop INNER, by
-   copying it to the beginning of that loop and changing the uses.  */
-
-static bool
-can_put_in_inner_loop (struct loop *inner, gimple stmt)
-{
-  imm_use_iterator imm_iter;
-  use_operand_p use_p;
-
-  gcc_assert (is_gimple_assign (stmt));
-  if (gimple_vuse (stmt)
-      || !stmt_invariant_in_loop_p (inner, stmt))
-    return false;
-
-  FOR_EACH_IMM_USE_FAST (use_p, imm_iter, gimple_assign_lhs (stmt))
-    {
-      if (!exit_phi_for_loop_p (inner, USE_STMT (use_p)))
-       {
-         basic_block immbb = gimple_bb (USE_STMT (use_p));
-
-         if (!flow_bb_inside_loop_p (inner, immbb))
-           return false;
-       }
-    }
-  return true;
-}
-
-/* Return true if STMT can be put *after* the inner loop of LOOP.  */
-
-static bool
-can_put_after_inner_loop (struct loop *loop, gimple stmt)
-{
-  imm_use_iterator imm_iter;
-  use_operand_p use_p;
-
-  if (gimple_vuse (stmt))
-    return false;
-
-  FOR_EACH_IMM_USE_FAST (use_p, imm_iter, gimple_assign_lhs (stmt))
-    {
-      if (!exit_phi_for_loop_p (loop, USE_STMT (use_p)))
-       {
-         basic_block immbb = gimple_bb (USE_STMT (use_p));
-
-         if (!dominated_by_p (CDI_DOMINATORS,
-                              immbb,
-                              loop->inner->header)
-             && !can_put_in_inner_loop (loop->inner, stmt))
-           return false;
-       }
-    }
-  return true;
-}
-
-/* Return true when the induction variable IV is simple enough to be
-   re-synthesized.  */
-
-static bool
-can_duplicate_iv (tree iv, struct loop *loop)
-{
-  tree scev = instantiate_parameters
-    (loop, analyze_scalar_evolution (loop, iv));
-
-  if (!automatically_generated_chrec_p (scev))
-    {
-      tree step = evolution_part_in_loop_num (scev, loop->num);
-
-      if (step && step != chrec_dont_know && TREE_CODE (step) == INTEGER_CST)
-       return true;
-    }
-
-  return false;
-}
-
-/* If this is a scalar operation that can be put back into the inner
-   loop, or after the inner loop, through copying, then do so. This
-   works on the theory that any amount of scalar code we have to
-   reduplicate into or after the loops is less expensive that the win
-   we get from rearranging the memory walk the loop is doing so that
-   it has better cache behavior.  */
-
-static bool
-cannot_convert_modify_to_perfect_nest (gimple stmt, struct loop *loop)
-{
-  use_operand_p use_a, use_b;
-  imm_use_iterator imm_iter;
-  ssa_op_iter op_iter, op_iter1;
-  tree op0 = gimple_assign_lhs (stmt);
-
-  /* The statement should not define a variable used in the inner
-     loop.  */
-  if (TREE_CODE (op0) == SSA_NAME
-      && !can_duplicate_iv (op0, loop))
-    FOR_EACH_IMM_USE_FAST (use_a, imm_iter, op0)
-      if (gimple_bb (USE_STMT (use_a))->loop_father == loop->inner)
-       return true;
-
-  FOR_EACH_SSA_USE_OPERAND (use_a, stmt, op_iter, SSA_OP_USE)
-    {
-      gimple node;
-      tree op = USE_FROM_PTR (use_a);
-
-      /* The variables should not be used in both loops.  */
-      if (!can_duplicate_iv (op, loop))
-       FOR_EACH_IMM_USE_FAST (use_b, imm_iter, op)
-         if (gimple_bb (USE_STMT (use_b))->loop_father == loop->inner)
-           return true;
-
-      /* The statement should not use the value of a scalar that was
-        modified in the loop.  */
-      node = SSA_NAME_DEF_STMT (op);
-      if (gimple_code (node) == GIMPLE_PHI)
-       FOR_EACH_PHI_ARG (use_b, node, op_iter1, SSA_OP_USE)
-         {
-           tree arg = USE_FROM_PTR (use_b);
-
-           if (TREE_CODE (arg) == SSA_NAME)
-             {
-               gimple arg_stmt = SSA_NAME_DEF_STMT (arg);
-
-               if (gimple_bb (arg_stmt)
-                   && (gimple_bb (arg_stmt)->loop_father == loop->inner))
-                 return true;
-             }
-         }
-    }
-
-  return false;
-}
-/* Return true when BB contains statements that can harm the transform
-   to a perfect loop nest.  */
-
-static bool
-cannot_convert_bb_to_perfect_nest (basic_block bb, struct loop *loop)
-{
-  gimple_stmt_iterator bsi;
-  gimple exit_condition = get_loop_exit_condition (loop);
-
-  for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
-    {
-      gimple stmt = gsi_stmt (bsi);
-
-      if (stmt == exit_condition
-         || not_interesting_stmt (stmt)
-         || stmt_is_bumper_for_loop (loop, stmt))
-       continue;
-
-      if (is_gimple_assign (stmt))
-       {
-         if (cannot_convert_modify_to_perfect_nest (stmt, loop))
-           return true;
-
-         if (can_duplicate_iv (gimple_assign_lhs (stmt), loop))
-           continue;
-
-         if (can_put_in_inner_loop (loop->inner, stmt)
-             || can_put_after_inner_loop (loop, stmt))
-           continue;
-       }
-
-      /* If the bb of a statement we care about isn't dominated by the
-        header of the inner loop, then we can't handle this case
-        right now.  This test ensures that the statement comes
-        completely *after* the inner loop.  */
-      if (!dominated_by_p (CDI_DOMINATORS,
-                          gimple_bb (stmt),
-                          loop->inner->header))
-       return true;
-    }
-
-  return false;
-}
-
-
-/* Return TRUE if LOOP is an imperfect nest that we can convert to a
-   perfect one.  At the moment, we only handle imperfect nests of
-   depth 2, where all of the statements occur after the inner loop.  */
-
-static bool
-can_convert_to_perfect_nest (struct loop *loop)
-{
-  basic_block *bbs;
-  size_t i;
-  gimple_stmt_iterator si;
-
-  /* Can't handle triply nested+ loops yet.  */
-  if (!loop->inner || loop->inner->inner)
-    return false;
-
-  bbs = get_loop_body (loop);
-  for (i = 0; i < loop->num_nodes; i++)
-    if (bbs[i]->loop_father == loop
-       && cannot_convert_bb_to_perfect_nest (bbs[i], loop))
-      goto fail;
-
-  /* We also need to make sure the loop exit only has simple copy phis in it,
-     otherwise we don't know how to transform it into a perfect nest.  */
-  for (si = gsi_start_phis (single_exit (loop)->dest);
-       !gsi_end_p (si);
-       gsi_next (&si))
-    if (gimple_phi_num_args (gsi_stmt (si)) != 1)
-      goto fail;
-
-  free (bbs);
-  return true;
-
- fail:
-  free (bbs);
-  return false;
-}
-
-
-DEF_VEC_I(source_location);
-DEF_VEC_ALLOC_I(source_location,heap);
-
-/* Transform the loop nest into a perfect nest, if possible.
-   LOOP is the loop nest to transform into a perfect nest
-   LBOUNDS are the lower bounds for the loops to transform
-   UBOUNDS are the upper bounds for the loops to transform
-   STEPS is the STEPS for the loops to transform.
-   LOOPIVS is the induction variables for the loops to transform.
-
-   Basically, for the case of
-
-   FOR (i = 0; i < 50; i++)
-    {
-     FOR (j =0; j < 50; j++)
-     {
-        <whatever>
-     }
-     <some code>
-    }
-
-   This function will transform it into a perfect loop nest by splitting the
-   outer loop into two loops, like so:
-
-   FOR (i = 0; i < 50; i++)
-   {
-     FOR (j = 0; j < 50; j++)
-     {
-         <whatever>
-     }
-   }
-
-   FOR (i = 0; i < 50; i ++)
-   {
-    <some code>
-   }
-
-   Return FALSE if we can't make this loop into a perfect nest.  */
-
-static bool
-perfect_nestify (struct loop *loop,
-                VEC(tree,heap) *lbounds,
-                VEC(tree,heap) *ubounds,
-                VEC(int,heap) *steps,
-                VEC(tree,heap) *loopivs)
-{
-  basic_block *bbs;
-  gimple exit_condition;
-  gimple cond_stmt;
-  basic_block preheaderbb, headerbb, bodybb, latchbb, olddest;
-  int i;
-  gimple_stmt_iterator bsi, firstbsi;
-  bool insert_after;
-  edge e;
-  struct loop *newloop;
-  gimple phi;
-  tree uboundvar;
-  gimple stmt;
-  tree oldivvar, ivvar, ivvarinced;
-  VEC(tree,heap) *phis = NULL;
-  VEC(source_location,heap) *locations = NULL;
-  htab_t replacements = NULL;
-
-  /* Create the new loop.  */
-  olddest = single_exit (loop)->dest;
-  preheaderbb = split_edge (single_exit (loop));
-  headerbb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
-
-  /* Push the exit phi nodes that we are moving.  */
-  for (bsi = gsi_start_phis (olddest); !gsi_end_p (bsi); gsi_next (&bsi))
-    {
-      phi = gsi_stmt (bsi);
-      VEC_reserve (tree, heap, phis, 2);
-      VEC_reserve (source_location, heap, locations, 1);
-      VEC_quick_push (tree, phis, PHI_RESULT (phi));
-      VEC_quick_push (tree, phis, PHI_ARG_DEF (phi, 0));
-      VEC_quick_push (source_location, locations,
-                     gimple_phi_arg_location (phi, 0));
-    }
-  e = redirect_edge_and_branch (single_succ_edge (preheaderbb), headerbb);
-
-  /* Remove the exit phis from the old basic block.  */
-  for (bsi = gsi_start_phis (olddest); !gsi_end_p (bsi); )
-    remove_phi_node (&bsi, false);
-
-  /* and add them back to the new basic block.  */
-  while (VEC_length (tree, phis) != 0)
-    {
-      tree def;
-      tree phiname;
-      source_location locus;
-      def = VEC_pop (tree, phis);
-      phiname = VEC_pop (tree, phis);
-      locus = VEC_pop (source_location, locations);
-      phi = create_phi_node (phiname, preheaderbb);
-      add_phi_arg (phi, def, single_pred_edge (preheaderbb), locus);
-    }
-  flush_pending_stmts (e);
-  VEC_free (tree, heap, phis);
-
-  bodybb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
-  latchbb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
-  make_edge (headerbb, bodybb, EDGE_FALLTHRU);
-  cond_stmt = gimple_build_cond (NE_EXPR, integer_one_node, integer_zero_node,
-                                NULL_TREE, NULL_TREE);
-  bsi = gsi_start_bb (bodybb);
-  gsi_insert_after (&bsi, cond_stmt, GSI_NEW_STMT);
-  e = make_edge (bodybb, olddest, EDGE_FALSE_VALUE);
-  make_edge (bodybb, latchbb, EDGE_TRUE_VALUE);
-  make_edge (latchbb, headerbb, EDGE_FALLTHRU);
-
-  /* Update the loop structures.  */
-  newloop = duplicate_loop (loop, olddest->loop_father);
-  newloop->header = headerbb;
-  newloop->latch = latchbb;
-  add_bb_to_loop (latchbb, newloop);
-  add_bb_to_loop (bodybb, newloop);
-  add_bb_to_loop (headerbb, newloop);
-  set_immediate_dominator (CDI_DOMINATORS, bodybb, headerbb);
-  set_immediate_dominator (CDI_DOMINATORS, headerbb, preheaderbb);
-  set_immediate_dominator (CDI_DOMINATORS, preheaderbb,
-                          single_exit (loop)->src);
-  set_immediate_dominator (CDI_DOMINATORS, latchbb, bodybb);
-  set_immediate_dominator (CDI_DOMINATORS, olddest,
-                          recompute_dominator (CDI_DOMINATORS, olddest));
-  /* Create the new iv.  */
-  oldivvar = VEC_index (tree, loopivs, 0);
-  ivvar = create_tmp_var (TREE_TYPE (oldivvar), "perfectiv");
-  add_referenced_var (ivvar);
-  standard_iv_increment_position (newloop, &bsi, &insert_after);
-  create_iv (VEC_index (tree, lbounds, 0),
-            build_int_cst (TREE_TYPE (oldivvar), VEC_index (int, steps, 0)),
-            ivvar, newloop, &bsi, insert_after, &ivvar, &ivvarinced);
-
-  /* Create the new upper bound.  This may be not just a variable, so we copy
-     it to one just in case.  */
-
-  exit_condition = get_loop_exit_condition (newloop);
-  uboundvar = create_tmp_var (TREE_TYPE (VEC_index (tree, ubounds, 0)),
-                             "uboundvar");
-  add_referenced_var (uboundvar);
-  stmt = gimple_build_assign (uboundvar, VEC_index (tree, ubounds, 0));
-  uboundvar = make_ssa_name (uboundvar, stmt);
-  gimple_assign_set_lhs (stmt, uboundvar);
-
-  if (insert_after)
-    gsi_insert_after (&bsi, stmt, GSI_SAME_STMT);
-  else
-    gsi_insert_before (&bsi, stmt, GSI_SAME_STMT);
-  update_stmt (stmt);
-  gimple_cond_set_condition (exit_condition, GE_EXPR, uboundvar, ivvarinced);
-  update_stmt (exit_condition);
-  replacements = htab_create_ggc (20, tree_map_hash,
-                                 tree_map_eq, NULL);
-  bbs = get_loop_body_in_dom_order (loop);
-  /* Now move the statements, and replace the induction variable in the moved
-     statements with the correct loop induction variable.  */
-  oldivvar = VEC_index (tree, loopivs, 0);
-  firstbsi = gsi_start_bb (bodybb);
-  for (i = loop->num_nodes - 1; i >= 0 ; i--)
-    {
-      gimple_stmt_iterator tobsi = gsi_last_bb (bodybb);
-      if (bbs[i]->loop_father == loop)
-       {
-         /* If this is true, we are *before* the inner loop.
-            If this isn't true, we are *after* it.
-
-            The only time can_convert_to_perfect_nest returns true when we
-            have statements before the inner loop is if they can be moved
-            into the inner loop.
-
-            The only time can_convert_to_perfect_nest returns true when we
-            have statements after the inner loop is if they can be moved into
-            the new split loop.  */
-
-         if (dominated_by_p (CDI_DOMINATORS, loop->inner->header, bbs[i]))
-           {
-             gimple_stmt_iterator header_bsi
-               = gsi_after_labels (loop->inner->header);
-
-             for (bsi = gsi_start_bb (bbs[i]); !gsi_end_p (bsi);)
-               {
-                 gimple stmt = gsi_stmt (bsi);
-
-                 if (stmt == exit_condition
-                     || not_interesting_stmt (stmt)
-                     || stmt_is_bumper_for_loop (loop, stmt))
-                   {
-                     gsi_next (&bsi);
-                     continue;
-                   }
-
-                 gsi_move_before (&bsi, &header_bsi);
-               }
-           }
-         else
-           {
-             /* Note that the bsi only needs to be explicitly incremented
-                when we don't move something, since it is automatically
-                incremented when we do.  */
-             for (bsi = gsi_start_bb (bbs[i]); !gsi_end_p (bsi);)
-               {
-                 gimple stmt = gsi_stmt (bsi);
-
-                 if (stmt == exit_condition
-                     || not_interesting_stmt (stmt)
-                     || stmt_is_bumper_for_loop (loop, stmt))
-                   {
-                     gsi_next (&bsi);
-                     continue;
-                   }
-
-                 replace_uses_equiv_to_x_with_y
-                   (loop, stmt, oldivvar, VEC_index (int, steps, 0), ivvar,
-                    VEC_index (tree, lbounds, 0), replacements, &firstbsi);
-
-                 gsi_move_before (&bsi, &tobsi);
-
-                 /* If the statement has any virtual operands, they may
-                    need to be rewired because the original loop may
-                    still reference them.  */
-                 if (gimple_vuse (stmt))
-                   mark_sym_for_renaming (gimple_vop (cfun));
-               }
-           }
-
-       }
-    }
-
-  free (bbs);
-  htab_delete (replacements);
-  return perfect_nest_p (loop);
-}
-
-/* Return true if TRANS is a legal transformation matrix that respects
-   the dependence vectors in DISTS and DIRS.  The conservative answer
-   is false.
-
-   "Wolfe proves that a unimodular transformation represented by the
-   matrix T is legal when applied to a loop nest with a set of
-   lexicographically non-negative distance vectors RDG if and only if
-   for each vector d in RDG, (T.d >= 0) is lexicographically positive.
-   i.e.: if and only if it transforms the lexicographically positive
-   distance vectors to lexicographically positive vectors.  Note that
-   a unimodular matrix must transform the zero vector (and only it) to
-   the zero vector." S.Muchnick.  */
-
-bool
-lambda_transform_legal_p (lambda_trans_matrix trans,
-                         int nb_loops,
-                         VEC (ddr_p, heap) *dependence_relations)
-{
-  unsigned int i, j;
-  lambda_vector distres;
-  struct data_dependence_relation *ddr;
-
-  gcc_assert (LTM_COLSIZE (trans) == nb_loops
-             && LTM_ROWSIZE (trans) == nb_loops);
-
-  /* When there are no dependences, the transformation is correct.  */
-  if (VEC_length (ddr_p, dependence_relations) == 0)
-    return true;
-
-  ddr = VEC_index (ddr_p, dependence_relations, 0);
-  if (ddr == NULL)
-    return true;
-
-  /* When there is an unknown relation in the dependence_relations, we
-     know that it is no worth looking at this loop nest: give up.  */
-  if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
-    return false;
-
-  distres = lambda_vector_new (nb_loops);
-
-  /* For each distance vector in the dependence graph.  */
-  FOR_EACH_VEC_ELT (ddr_p, dependence_relations, i, ddr)
-    {
-      /* Don't care about relations for which we know that there is no
-        dependence, nor about read-read (aka. output-dependences):
-        these data accesses can happen in any order.  */
-      if (DDR_ARE_DEPENDENT (ddr) == chrec_known
-         || (DR_IS_READ (DDR_A (ddr)) && DR_IS_READ (DDR_B (ddr))))
-       continue;
-
-      /* Conservatively answer: "this transformation is not valid".  */
-      if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
-       return false;
-
-      /* If the dependence could not be captured by a distance vector,
-        conservatively answer that the transform is not valid.  */
-      if (DDR_NUM_DIST_VECTS (ddr) == 0)
-       return false;
-
-      /* Compute trans.dist_vect */
-      for (j = 0; j < DDR_NUM_DIST_VECTS (ddr); j++)
-       {
-         lambda_matrix_vector_mult (LTM_MATRIX (trans), nb_loops, nb_loops,
-                                    DDR_DIST_VECT (ddr, j), distres);
-
-         if (!lambda_vector_lexico_pos (distres, nb_loops))
-           return false;
-       }
-    }
-  return true;
-}
-
-
-/* Collects parameters from affine function ACCESS_FUNCTION, and push
-   them in PARAMETERS.  */
-
-static void
-lambda_collect_parameters_from_af (tree access_function,
-                                  struct pointer_set_t *param_set,
-                                  VEC (tree, heap) **parameters)
-{
-  if (access_function == NULL)
-    return;
-
-  if (TREE_CODE (access_function) == SSA_NAME
-      && pointer_set_contains (param_set, access_function) == 0)
-    {
-      pointer_set_insert (param_set, access_function);
-      VEC_safe_push (tree, heap, *parameters, access_function);
-    }
-  else
-    {
-      int i, num_operands = tree_operand_length (access_function);
-
-      for (i = 0; i < num_operands; i++)
-       lambda_collect_parameters_from_af (TREE_OPERAND (access_function, i),
-                                          param_set, parameters);
-    }
-}
-
-/* Collects parameters from DATAREFS, and push them in PARAMETERS.  */
-
-void
-lambda_collect_parameters (VEC (data_reference_p, heap) *datarefs,
-                          VEC (tree, heap) **parameters)
-{
-  unsigned i, j;
-  struct pointer_set_t *parameter_set = pointer_set_create ();
-  data_reference_p data_reference;
-
-  FOR_EACH_VEC_ELT (data_reference_p, datarefs, i, data_reference)
-    for (j = 0; j < DR_NUM_DIMENSIONS (data_reference); j++)
-      lambda_collect_parameters_from_af (DR_ACCESS_FN (data_reference, j),
-                                        parameter_set, parameters);
-  pointer_set_destroy (parameter_set);
-}
-
-/* Translates BASE_EXPR to vector CY.  AM is needed for inferring
-   indexing positions in the data access vector.  CST is the analyzed
-   integer constant.  */
-
-static bool
-av_for_af_base (tree base_expr, lambda_vector cy, struct access_matrix *am,
-               int cst)
-{
-  bool result = true;
-
-  switch (TREE_CODE (base_expr))
-    {
-    case INTEGER_CST:
-      /* Constant part.  */
-      cy[AM_CONST_COLUMN_INDEX (am)] += int_cst_value (base_expr) * cst;
-      return true;
-
-    case SSA_NAME:
-      {
-       int param_index =
-         access_matrix_get_index_for_parameter (base_expr, am);
-
-       if (param_index >= 0)
-         {
-           cy[param_index] = cst + cy[param_index];
-           return true;
-         }
-
-       return false;
-      }
-
-    case PLUS_EXPR:
-      return av_for_af_base (TREE_OPERAND (base_expr, 0), cy, am, cst)
-       && av_for_af_base (TREE_OPERAND (base_expr, 1), cy, am, cst);
-
-    case MINUS_EXPR:
-      return av_for_af_base (TREE_OPERAND (base_expr, 0), cy, am, cst)
-       && av_for_af_base (TREE_OPERAND (base_expr, 1), cy, am, -1 * cst);
-
-    case MULT_EXPR:
-      if (TREE_CODE (TREE_OPERAND (base_expr, 0)) == INTEGER_CST)
-       result = av_for_af_base (TREE_OPERAND (base_expr, 1),
-                                cy, am, cst *
-                                int_cst_value (TREE_OPERAND (base_expr, 0)));
-      else if (TREE_CODE (TREE_OPERAND (base_expr, 1)) == INTEGER_CST)
-       result = av_for_af_base (TREE_OPERAND (base_expr, 0),
-                                cy, am, cst *
-                                int_cst_value (TREE_OPERAND (base_expr, 1)));
-      else
-       result = false;
-
-      return result;
-
-    case NEGATE_EXPR:
-      return av_for_af_base (TREE_OPERAND (base_expr, 0), cy, am, -1 * cst);
-
-    default:
-      return false;
-    }
-
-  return result;
-}
-
-/* Translates ACCESS_FUN to vector CY.  AM is needed for inferring
-   indexing positions in the data access vector.  */
-
-static bool
-av_for_af (tree access_fun, lambda_vector cy, struct access_matrix *am)
-{
-  switch (TREE_CODE (access_fun))
-    {
-    case POLYNOMIAL_CHREC:
-      {
-       tree left = CHREC_LEFT (access_fun);
-       tree right = CHREC_RIGHT (access_fun);
-       unsigned var;
-
-       if (TREE_CODE (right) != INTEGER_CST)
-         return false;
-
-       var = am_vector_index_for_loop (am, CHREC_VARIABLE (access_fun));
-       cy[var] = int_cst_value (right);
-
-       if (TREE_CODE (left) == POLYNOMIAL_CHREC)
-         return av_for_af (left, cy, am);
-       else
-         return av_for_af_base (left, cy, am, 1);
-      }
-
-    case INTEGER_CST:
-      /* Constant part.  */
-      return av_for_af_base (access_fun, cy, am, 1);
-
-    default:
-      return false;
-    }
-}
-
-/* Initializes the access matrix for DATA_REFERENCE.  */
-
-static bool
-build_access_matrix (data_reference_p data_reference,
-                    VEC (tree, heap) *parameters,
-                    VEC (loop_p, heap) *nest,
-                    struct obstack * lambda_obstack)
-{
-  struct access_matrix *am = (struct access_matrix *)
-    obstack_alloc(lambda_obstack, sizeof (struct access_matrix));
-  unsigned i, ndim = DR_NUM_DIMENSIONS (data_reference);
-  unsigned nivs = VEC_length (loop_p, nest);
-  unsigned lambda_nb_columns;
-
-  AM_LOOP_NEST (am) = nest;
-  AM_NB_INDUCTION_VARS (am) = nivs;
-  AM_PARAMETERS (am) = parameters;
-
-  lambda_nb_columns = AM_NB_COLUMNS (am);
-  AM_MATRIX (am) = VEC_alloc (lambda_vector, gc, ndim);
-
-  for (i = 0; i < ndim; i++)
-    {
-      lambda_vector access_vector = lambda_vector_new (lambda_nb_columns);
-      tree access_function = DR_ACCESS_FN (data_reference, i);
-
-      if (!av_for_af (access_function, access_vector, am))
-       return false;
-
-      VEC_quick_push (lambda_vector, AM_MATRIX (am), access_vector);
-    }
-
-  DR_ACCESS_MATRIX (data_reference) = am;
-  return true;
-}
-
-/* Returns false when one of the access matrices cannot be built.  */
-
-bool
-lambda_compute_access_matrices (VEC (data_reference_p, heap) *datarefs,
-                               VEC (tree, heap) *parameters,
-                               VEC (loop_p, heap) *nest,
-                               struct obstack * lambda_obstack)
-{
-  data_reference_p dataref;
-  unsigned ix;
-
-  FOR_EACH_VEC_ELT (data_reference_p, datarefs, ix, dataref)
-    if (!build_access_matrix (dataref, parameters, nest, lambda_obstack))
-      return false;
-
-  return true;
-}
diff --git a/gcc/lambda-mat.c b/gcc/lambda-mat.c
deleted file mode 100644 (file)
index c57fb58..0000000
+++ /dev/null
@@ -1,608 +0,0 @@
-/* Integer matrix math routines
-   Copyright (C) 2003, 2004, 2005, 2007, 2008, 2010
-   Free Software Foundation, Inc.
-   Contributed by Daniel Berlin <dberlin@dberlin.org>.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 3, or (at your option) any later
-version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3.  If not see
-<http://www.gnu.org/licenses/>.  */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tree-flow.h"
-#include "lambda.h"
-
-/* Allocate a matrix of M rows x  N cols.  */
-
-lambda_matrix
-lambda_matrix_new (int m, int n, struct obstack * lambda_obstack)
-{
-  lambda_matrix mat;
-  int i;
-
-  mat = (lambda_matrix) obstack_alloc (lambda_obstack,
-                                      sizeof (lambda_vector *) * m);
-
-  for (i = 0; i < m; i++)
-    mat[i] = lambda_vector_new (n);
-
-  return mat;
-}
-
-/* Copy the elements of M x N matrix MAT1 to MAT2.  */
-
-void
-lambda_matrix_copy (lambda_matrix mat1, lambda_matrix mat2,
-                   int m, int n)
-{
-  int i;
-
-  for (i = 0; i < m; i++)
-    lambda_vector_copy (mat1[i], mat2[i], n);
-}
-
-/* Store the N x N identity matrix in MAT.  */
-
-void
-lambda_matrix_id (lambda_matrix mat, int size)
-{
-  int i, j;
-
-  for (i = 0; i < size; i++)
-    for (j = 0; j < size; j++)
-      mat[i][j] = (i == j) ? 1 : 0;
-}
-
-/* Return true if MAT is the identity matrix of SIZE */
-
-bool
-lambda_matrix_id_p (lambda_matrix mat, int size)
-{
-  int i, j;
-  for (i = 0; i < size; i++)
-    for (j = 0; j < size; j++)
-      {
-       if (i == j)
-         {
-           if (mat[i][j] != 1)
-             return false;
-         }
-       else
-         {
-           if (mat[i][j] != 0)
-             return false;
-         }
-      }
-  return true;
-}
-
-/* Negate the elements of the M x N matrix MAT1 and store it in MAT2.  */
-
-void
-lambda_matrix_negate (lambda_matrix mat1, lambda_matrix mat2, int m, int n)
-{
-  int i;
-
-  for (i = 0; i < m; i++)
-    lambda_vector_negate (mat1[i], mat2[i], n);
-}
-
-/* Take the transpose of matrix MAT1 and store it in MAT2.
-   MAT1 is an M x N matrix, so MAT2 must be N x M.  */
-
-void
-lambda_matrix_transpose (lambda_matrix mat1, lambda_matrix mat2, int m, int n)
-{
-  int i, j;
-
-  for (i = 0; i < n; i++)
-    for (j = 0; j < m; j++)
-      mat2[i][j] = mat1[j][i];
-}
-
-
-/* Add two M x N matrices together: MAT3 = MAT1+MAT2.  */
-
-void
-lambda_matrix_add (lambda_matrix mat1, lambda_matrix mat2,
-                  lambda_matrix mat3, int m, int n)
-{
-  int i;
-
-  for (i = 0; i < m; i++)
-    lambda_vector_add (mat1[i], mat2[i], mat3[i], n);
-}
-
-/* MAT3 = CONST1 * MAT1 + CONST2 * MAT2.  All matrices are M x N.  */
-
-void
-lambda_matrix_add_mc (lambda_matrix mat1, int const1,
-                     lambda_matrix mat2, int const2,
-                     lambda_matrix mat3, int m, int n)
-{
-  int i;
-
-  for (i = 0; i < m; i++)
-    lambda_vector_add_mc (mat1[i], const1, mat2[i], const2, mat3[i], n);
-}
-
-/* Multiply two matrices: MAT3 = MAT1 * MAT2.
-   MAT1 is an M x R matrix, and MAT2 is R x N.  The resulting MAT2
-   must therefore be M x N.  */
-
-void
-lambda_matrix_mult (lambda_matrix mat1, lambda_matrix mat2,
-                   lambda_matrix mat3, int m, int r, int n)
-{
-
-  int i, j, k;
-
-  for (i = 0; i < m; i++)
-    {
-      for (j = 0; j < n; j++)
-       {
-         mat3[i][j] = 0;
-         for (k = 0; k < r; k++)
-           mat3[i][j] += mat1[i][k] * mat2[k][j];
-       }
-    }
-}
-
-/* Delete rows r1 to r2 (not including r2).  */
-
-void
-lambda_matrix_delete_rows (lambda_matrix mat, int rows, int from, int to)
-{
-  int i;
-  int dist;
-  dist = to - from;
-
-  for (i = to; i < rows; i++)
-    mat[i - dist] = mat[i];
-
-  for (i = rows - dist; i < rows; i++)
-    mat[i] = NULL;
-}
-
-/* Swap rows R1 and R2 in matrix MAT.  */
-
-void
-lambda_matrix_row_exchange (lambda_matrix mat, int r1, int r2)
-{
-  lambda_vector row;
-
-  row = mat[r1];
-  mat[r1] = mat[r2];
-  mat[r2] = row;
-}
-
-/* Add a multiple of row R1 of matrix MAT with N columns to row R2:
-   R2 = R2 + CONST1 * R1.  */
-
-void
-lambda_matrix_row_add (lambda_matrix mat, int n, int r1, int r2, int const1)
-{
-  int i;
-
-  if (const1 == 0)
-    return;
-
-  for (i = 0; i < n; i++)
-    mat[r2][i] += const1 * mat[r1][i];
-}
-
-/* Negate row R1 of matrix MAT which has N columns.  */
-
-void
-lambda_matrix_row_negate (lambda_matrix mat, int n, int r1)
-{
-  lambda_vector_negate (mat[r1], mat[r1], n);
-}
-
-/* Multiply row R1 of matrix MAT with N columns by CONST1.  */
-
-void
-lambda_matrix_row_mc (lambda_matrix mat, int n, int r1, int const1)
-{
-  int i;
-
-  for (i = 0; i < n; i++)
-    mat[r1][i] *= const1;
-}
-
-/* Exchange COL1 and COL2 in matrix MAT. M is the number of rows.  */
-
-void
-lambda_matrix_col_exchange (lambda_matrix mat, int m, int col1, int col2)
-{
-  int i;
-  int tmp;
-  for (i = 0; i < m; i++)
-    {
-      tmp = mat[i][col1];
-      mat[i][col1] = mat[i][col2];
-      mat[i][col2] = tmp;
-    }
-}
-
-/* Add a multiple of column C1 of matrix MAT with M rows to column C2:
-   C2 = C2 + CONST1 * C1.  */
-
-void
-lambda_matrix_col_add (lambda_matrix mat, int m, int c1, int c2, int const1)
-{
-  int i;
-
-  if (const1 == 0)
-    return;
-
-  for (i = 0; i < m; i++)
-    mat[i][c2] += const1 * mat[i][c1];
-}
-
-/* Negate column C1 of matrix MAT which has M rows.  */
-
-void
-lambda_matrix_col_negate (lambda_matrix mat, int m, int c1)
-{
-  int i;
-
-  for (i = 0; i < m; i++)
-    mat[i][c1] *= -1;
-}
-
-/* Multiply column C1 of matrix MAT with M rows by CONST1.  */
-
-void
-lambda_matrix_col_mc (lambda_matrix mat, int m, int c1, int const1)
-{
-  int i;
-
-  for (i = 0; i < m; i++)
-    mat[i][c1] *= const1;
-}
-
-/* Compute the inverse of the N x N matrix MAT and store it in INV.
-
-   We don't _really_ compute the inverse of MAT.  Instead we compute
-   det(MAT)*inv(MAT), and we return det(MAT) to the caller as the function
-   result.  This is necessary to preserve accuracy, because we are dealing
-   with integer matrices here.
-
-   The algorithm used here is a column based Gauss-Jordan elimination on MAT
-   and the identity matrix in parallel.  The inverse is the result of applying
-   the same operations on the identity matrix that reduce MAT to the identity
-   matrix.
-
-   When MAT is a 2 x 2 matrix, we don't go through the whole process, because
-   it is easily inverted by inspection and it is a very common case.  */
-
-static int lambda_matrix_inverse_hard (lambda_matrix, lambda_matrix, int,
-                                      struct obstack *);
-
-int
-lambda_matrix_inverse (lambda_matrix mat, lambda_matrix inv, int n,
-                      struct obstack * lambda_obstack)
-{
-  if (n == 2)
-    {
-      int a, b, c, d, det;
-      a = mat[0][0];
-      b = mat[1][0];
-      c = mat[0][1];
-      d = mat[1][1];
-      inv[0][0] =  d;
-      inv[0][1] = -c;
-      inv[1][0] = -b;
-      inv[1][1] =  a;
-      det = (a * d - b * c);
-      if (det < 0)
-       {
-         det *= -1;
-         inv[0][0] *= -1;
-         inv[1][0] *= -1;
-         inv[0][1] *= -1;
-         inv[1][1] *= -1;
-       }
-      return det;
-    }
-  else
-    return lambda_matrix_inverse_hard (mat, inv, n, lambda_obstack);
-}
-
-/* If MAT is not a special case, invert it the hard way.  */
-
-static int
-lambda_matrix_inverse_hard (lambda_matrix mat, lambda_matrix inv, int n,
-                           struct obstack * lambda_obstack)
-{
-  lambda_vector row;
-  lambda_matrix temp;
-  int i, j;
-  int determinant;
-
-  temp = lambda_matrix_new (n, n, lambda_obstack);
-  lambda_matrix_copy (mat, temp, n, n);
-  lambda_matrix_id (inv, n);
-
-  /* Reduce TEMP to a lower triangular form, applying the same operations on
-     INV which starts as the identity matrix.  N is the number of rows and
-     columns.  */
-  for (j = 0; j < n; j++)
-    {
-      row = temp[j];
-
-      /* Make every element in the current row positive.  */
-      for (i = j; i < n; i++)
-       if (row[i] < 0)
-         {
-           lambda_matrix_col_negate (temp, n, i);
-           lambda_matrix_col_negate (inv, n, i);
-         }
-
-      /* Sweep the upper triangle.  Stop when only the diagonal element in the
-        current row is nonzero.  */
-      while (lambda_vector_first_nz (row, n, j + 1) < n)
-       {
-         int min_col = lambda_vector_min_nz (row, n, j);
-         lambda_matrix_col_exchange (temp, n, j, min_col);
-         lambda_matrix_col_exchange (inv, n, j, min_col);
-
-         for (i = j + 1; i < n; i++)
-           {
-             int factor;
-
-             factor = -1 * row[i];
-             if (row[j] != 1)
-               factor /= row[j];
-
-             lambda_matrix_col_add (temp, n, j, i, factor);
-             lambda_matrix_col_add (inv, n, j, i, factor);
-           }
-       }
-    }
-
-  /* Reduce TEMP from a lower triangular to the identity matrix.  Also compute
-     the determinant, which now is simply the product of the elements on the
-     diagonal of TEMP.  If one of these elements is 0, the matrix has 0 as an
-     eigenvalue so it is singular and hence not invertible.  */
-  determinant = 1;
-  for (j = n - 1; j >= 0; j--)
-    {
-      int diagonal;
-
-      row = temp[j];
-      diagonal = row[j];
-
-      /* The matrix must not be singular.  */
-      gcc_assert (diagonal);
-
-      determinant = determinant * diagonal;
-
-      /* If the diagonal is not 1, then multiply the each row by the
-         diagonal so that the middle number is now 1, rather than a
-         rational.  */
-      if (diagonal != 1)
-       {
-         for (i = 0; i < j; i++)
-           lambda_matrix_col_mc (inv, n, i, diagonal);
-         for (i = j + 1; i < n; i++)
-           lambda_matrix_col_mc (inv, n, i, diagonal);
-
-         row[j] = diagonal = 1;
-       }
-
-      /* Sweep the lower triangle column wise.  */
-      for (i = j - 1; i >= 0; i--)
-       {
-         if (row[i])
-           {
-             int factor = -row[i];
-             lambda_matrix_col_add (temp, n, j, i, factor);
-             lambda_matrix_col_add (inv, n, j, i, factor);
-           }
-
-       }
-    }
-
-  return determinant;
-}
-
-/* Decompose a N x N matrix MAT to a product of a lower triangular H
-   and a unimodular U matrix such that MAT = H.U.  N is the size of
-   the rows of MAT.  */
-
-void
-lambda_matrix_hermite (lambda_matrix mat, int n,
-                      lambda_matrix H, lambda_matrix U)
-{
-  lambda_vector row;
-  int i, j, factor, minimum_col;
-
-  lambda_matrix_copy (mat, H, n, n);
-  lambda_matrix_id (U, n);
-
-  for (j = 0; j < n; j++)
-    {
-      row = H[j];
-
-      /* Make every element of H[j][j..n] positive.  */
-      for (i = j; i < n; i++)
-       {
-         if (row[i] < 0)
-           {
-             lambda_matrix_col_negate (H, n, i);
-             lambda_vector_negate (U[i], U[i], n);
-           }
-       }
-
-      /* Stop when only the diagonal element is nonzero.  */
-      while (lambda_vector_first_nz (row, n, j + 1) < n)
-       {
-         minimum_col = lambda_vector_min_nz (row, n, j);
-         lambda_matrix_col_exchange (H, n, j, minimum_col);
-         lambda_matrix_row_exchange (U, j, minimum_col);
-
-         for (i = j + 1; i < n; i++)
-           {
-             factor = row[i] / row[j];
-             lambda_matrix_col_add (H, n, j, i, -1 * factor);
-             lambda_matrix_row_add (U, n, i, j, factor);
-           }
-       }
-    }
-}
-
-/* Given an M x N integer matrix A, this function determines an M x
-   M unimodular matrix U, and an M x N echelon matrix S such that
-   "U.A = S".  This decomposition is also known as "right Hermite".
-
-   Ref: Algorithm 2.1 page 33 in "Loop Transformations for
-   Restructuring Compilers" Utpal Banerjee.  */
-
-void
-lambda_matrix_right_hermite (lambda_matrix A, int m, int n,
-                            lambda_matrix S, lambda_matrix U)
-{
-  int i, j, i0 = 0;
-
-  lambda_matrix_copy (A, S, m, n);
-  lambda_matrix_id (U, m);
-
-  for (j = 0; j < n; j++)
-    {
-      if (lambda_vector_first_nz (S[j], m, i0) < m)
-       {
-         ++i0;
-         for (i = m - 1; i >= i0; i--)
-           {
-             while (S[i][j] != 0)
-               {
-                 int sigma, factor, a, b;
-
-                 a = S[i-1][j];
-                 b = S[i][j];
-                 sigma = (a * b < 0) ? -1: 1;
-                 a = abs (a);
-                 b = abs (b);
-                 factor = sigma * (a / b);
-
-                 lambda_matrix_row_add (S, n, i, i-1, -factor);
-                 lambda_matrix_row_exchange (S, i, i-1);
-
-                 lambda_matrix_row_add (U, m, i, i-1, -factor);
-                 lambda_matrix_row_exchange (U, i, i-1);
-               }
-           }
-       }
-    }
-}
-
-/* Given an M x N integer matrix A, this function determines an M x M
-   unimodular matrix V, and an M x N echelon matrix S such that "A =
-   V.S".  This decomposition is also known as "left Hermite".
-
-   Ref: Algorithm 2.2 page 36 in "Loop Transformations for
-   Restructuring Compilers" Utpal Banerjee.  */
-
-void
-lambda_matrix_left_hermite (lambda_matrix A, int m, int n,
-                            lambda_matrix S, lambda_matrix V)
-{
-  int i, j, i0 = 0;
-
-  lambda_matrix_copy (A, S, m, n);
-  lambda_matrix_id (V, m);
-
-  for (j = 0; j < n; j++)
-    {
-      if (lambda_vector_first_nz (S[j], m, i0) < m)
-       {
-         ++i0;
-         for (i = m - 1; i >= i0; i--)
-           {
-             while (S[i][j] != 0)
-               {
-                 int sigma, factor, a, b;
-
-                 a = S[i-1][j];
-                 b = S[i][j];
-                 sigma = (a * b < 0) ? -1: 1;
-                 a = abs (a);
-      b = abs (b);
-                 factor = sigma * (a / b);
-
-                 lambda_matrix_row_add (S, n, i, i-1, -factor);
-                 lambda_matrix_row_exchange (S, i, i-1);
-
-                 lambda_matrix_col_add (V, m, i-1, i, factor);
-                 lambda_matrix_col_exchange (V, m, i, i-1);
-               }
-           }
-       }
-    }
-}
-
-/* When it exists, return the first nonzero row in MAT after row
-   STARTROW.  Otherwise return rowsize.  */
-
-int
-lambda_matrix_first_nz_vec (lambda_matrix mat, int rowsize, int colsize,
-                           int startrow)
-{
-  int j;
-  bool found = false;
-
-  for (j = startrow; (j < rowsize) && !found; j++)
-    {
-      if ((mat[j] != NULL)
-         && (lambda_vector_first_nz (mat[j], colsize, startrow) < colsize))
-       found = true;
-    }
-
-  if (found)
-    return j - 1;
-  return rowsize;
-}
-
-/* Multiply a vector VEC by a matrix MAT.
-   MAT is an M*N matrix, and VEC is a vector with length N.  The result
-   is stored in DEST which must be a vector of length M.  */
-
-void
-lambda_matrix_vector_mult (lambda_matrix matrix, int m, int n,
-                          lambda_vector vec, lambda_vector dest)
-{
-  int i, j;
-
-  lambda_vector_clear (dest, m);
-  for (i = 0; i < m; i++)
-    for (j = 0; j < n; j++)
-      dest[i] += matrix[i][j] * vec[j];
-}
-
-/* Print out an M x N matrix MAT to OUTFILE.  */
-
-void
-print_lambda_matrix (FILE * outfile, lambda_matrix matrix, int m, int n)
-{
-  int i;
-
-  for (i = 0; i < m; i++)
-    print_lambda_vector (outfile, matrix[i], n);
-  fprintf (outfile, "\n");
-}
-
diff --git a/gcc/lambda-trans.c b/gcc/lambda-trans.c
deleted file mode 100644 (file)
index ba14499..0000000
+++ /dev/null
@@ -1,80 +0,0 @@
-/* Lambda matrix transformations.
-   Copyright (C) 2003, 2004, 2007, 2008, 2010 Free Software Foundation, Inc.
-   Contributed by Daniel Berlin <dberlin@dberlin.org>.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 3, or (at your option) any later
-version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3.  If not see
-<http://www.gnu.org/licenses/>.  */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tree-flow.h"
-#include "lambda.h"
-
-/* Allocate a new transformation matrix.  */
-
-lambda_trans_matrix
-lambda_trans_matrix_new (int colsize, int rowsize,
-                        struct obstack * lambda_obstack)
-{
-  lambda_trans_matrix ret;
-
-  ret = (lambda_trans_matrix)
-    obstack_alloc (lambda_obstack, sizeof (struct lambda_trans_matrix_s));
-  LTM_MATRIX (ret) = lambda_matrix_new (rowsize, colsize, lambda_obstack);
-  LTM_ROWSIZE (ret) = rowsize;
-  LTM_COLSIZE (ret) = colsize;
-  LTM_DENOMINATOR (ret) = 1;
-  return ret;
-}
-
-/* Return true if MAT is an identity matrix.  */
-
-bool
-lambda_trans_matrix_id_p (lambda_trans_matrix mat)
-{
-  if (LTM_ROWSIZE (mat) != LTM_COLSIZE (mat))
-    return false;
-  return lambda_matrix_id_p (LTM_MATRIX (mat), LTM_ROWSIZE (mat));
-}
-
-
-/* Compute the inverse of the transformation matrix MAT.  */
-
-lambda_trans_matrix
-lambda_trans_matrix_inverse (lambda_trans_matrix mat,
-                            struct obstack * lambda_obstack)
-{
-  lambda_trans_matrix inverse;
-  int determinant;
-
-  inverse = lambda_trans_matrix_new (LTM_ROWSIZE (mat), LTM_COLSIZE (mat),
-                                    lambda_obstack);
-  determinant = lambda_matrix_inverse (LTM_MATRIX (mat), LTM_MATRIX (inverse),
-                                      LTM_ROWSIZE (mat), lambda_obstack);
-  LTM_DENOMINATOR (inverse) = determinant;
-  return inverse;
-}
-
-
-/* Print out a transformation matrix.  */
-
-void
-print_lambda_trans_matrix (FILE *outfile, lambda_trans_matrix mat)
-{
-  print_lambda_matrix (outfile, LTM_MATRIX (mat), LTM_ROWSIZE (mat),
-                      LTM_COLSIZE (mat));
-}
diff --git a/gcc/lambda.h b/gcc/lambda.h
deleted file mode 100644 (file)
index 382b71f..0000000
+++ /dev/null
@@ -1,524 +0,0 @@
-/* Lambda matrix and vector interface.
-   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-   Free Software Foundation, Inc.
-   Contributed by Daniel Berlin <dberlin@dberlin.org>
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 3, or (at your option) any later
-version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3.  If not see
-<http://www.gnu.org/licenses/>.  */
-
-#ifndef LAMBDA_H
-#define LAMBDA_H
-
-#include "vec.h"
-
-/* An integer vector.  A vector formally consists of an element of a vector
-   space. A vector space is a set that is closed under vector addition
-   and scalar multiplication.  In this vector space, an element is a list of
-   integers.  */
-typedef int *lambda_vector;
-DEF_VEC_P(lambda_vector);
-DEF_VEC_ALLOC_P(lambda_vector,heap);
-DEF_VEC_ALLOC_P(lambda_vector,gc);
-
-typedef VEC(lambda_vector, heap) *lambda_vector_vec_p;
-DEF_VEC_P (lambda_vector_vec_p);
-DEF_VEC_ALLOC_P (lambda_vector_vec_p, heap);
-
-/* An integer matrix.  A matrix consists of m vectors of length n (IE
-   all vectors are the same length).  */
-typedef lambda_vector *lambda_matrix;
-
-DEF_VEC_P (lambda_matrix);
-DEF_VEC_ALLOC_P (lambda_matrix, heap);
-
-/* A transformation matrix, which is a self-contained ROWSIZE x COLSIZE
-   matrix.  Rather than use floats, we simply keep a single DENOMINATOR that
-   represents the denominator for every element in the matrix.  */
-typedef struct lambda_trans_matrix_s
-{
-  lambda_matrix matrix;
-  int rowsize;
-  int colsize;
-  int denominator;
-} *lambda_trans_matrix;
-#define LTM_MATRIX(T) ((T)->matrix)
-#define LTM_ROWSIZE(T) ((T)->rowsize)
-#define LTM_COLSIZE(T) ((T)->colsize)
-#define LTM_DENOMINATOR(T) ((T)->denominator)
-
-/* A vector representing a statement in the body of a loop.
-   The COEFFICIENTS vector contains a coefficient for each induction variable
-   in the loop nest containing the statement.
-   The DENOMINATOR represents the denominator for each coefficient in the
-   COEFFICIENT vector.
-
-   This structure is used during code generation in order to rewrite the old
-   induction variable uses in a statement in terms of the newly created
-   induction variables.  */
-typedef struct lambda_body_vector_s
-{
-  lambda_vector coefficients;
-  int size;
-  int denominator;
-} *lambda_body_vector;
-#define LBV_COEFFICIENTS(T) ((T)->coefficients)
-#define LBV_SIZE(T) ((T)->size)
-#define LBV_DENOMINATOR(T) ((T)->denominator)
-
-/* Piecewise linear expression.
-   This structure represents a linear expression with terms for the invariants
-   and induction variables of a loop.
-   COEFFICIENTS is a vector of coefficients for the induction variables, one
-   per loop in the loop nest.
-   CONSTANT is the constant portion of the linear expression
-   INVARIANT_COEFFICIENTS is a vector of coefficients for the loop invariants,
-   one per invariant.
-   DENOMINATOR is the denominator for all of the coefficients and constants in
-   the expression.
-   The linear expressions can be linked together using the NEXT field, in
-   order to represent MAX or MIN of a group of linear expressions.  */
-typedef struct lambda_linear_expression_s
-{
-  lambda_vector coefficients;
-  int constant;
-  lambda_vector invariant_coefficients;
-  int denominator;
-  struct lambda_linear_expression_s *next;
-} *lambda_linear_expression;
-
-#define LLE_COEFFICIENTS(T) ((T)->coefficients)
-#define LLE_CONSTANT(T) ((T)->constant)
-#define LLE_INVARIANT_COEFFICIENTS(T) ((T)->invariant_coefficients)
-#define LLE_DENOMINATOR(T) ((T)->denominator)
-#define LLE_NEXT(T) ((T)->next)
-
-struct obstack;
-
-lambda_linear_expression lambda_linear_expression_new (int, int,
-                                                       struct obstack *);
-void print_lambda_linear_expression (FILE *, lambda_linear_expression, int,
-                                    int, char);
-
-/* Loop structure.  Our loop structure consists of a constant representing the
-   STEP of the loop, a set of linear expressions representing the LOWER_BOUND
-   of the loop, a set of linear expressions representing the UPPER_BOUND of
-   the loop, and a set of linear expressions representing the LINEAR_OFFSET of
-   the loop.  The linear offset is a set of linear expressions that are
-   applied to *both* the lower bound, and the upper bound.  */
-typedef struct lambda_loop_s
-{
-  lambda_linear_expression lower_bound;
-  lambda_linear_expression upper_bound;
-  lambda_linear_expression linear_offset;
-  int step;
-} *lambda_loop;
-
-#define LL_LOWER_BOUND(T) ((T)->lower_bound)
-#define LL_UPPER_BOUND(T) ((T)->upper_bound)
-#define LL_LINEAR_OFFSET(T) ((T)->linear_offset)
-#define LL_STEP(T)   ((T)->step)
-
-/* Loop nest structure.
-   The loop nest structure consists of a set of loop structures (defined
-   above) in LOOPS, along with an integer representing the DEPTH of the loop,
-   and an integer representing the number of INVARIANTS in the loop.  Both of
-   these integers are used to size the associated coefficient vectors in the
-   linear expression structures.  */
-typedef struct lambda_loopnest_s
-{
-  lambda_loop *loops;
-  int depth;
-  int invariants;
-} *lambda_loopnest;
-
-#define LN_LOOPS(T) ((T)->loops)
-#define LN_DEPTH(T) ((T)->depth)
-#define LN_INVARIANTS(T) ((T)->invariants)
-
-lambda_loopnest lambda_loopnest_new (int, int, struct obstack *);
-lambda_loopnest lambda_loopnest_transform (lambda_loopnest,
-                                           lambda_trans_matrix,
-                                           struct obstack *);
-struct loop;
-bool perfect_nest_p (struct loop *);
-void print_lambda_loopnest (FILE *, lambda_loopnest, char);
-
-void print_lambda_loop (FILE *, lambda_loop, int, int, char);
-
-lambda_matrix lambda_matrix_new (int, int, struct obstack *);
-
-void lambda_matrix_id (lambda_matrix, int);
-bool lambda_matrix_id_p (lambda_matrix, int);
-void lambda_matrix_copy (lambda_matrix, lambda_matrix, int, int);
-void lambda_matrix_negate (lambda_matrix, lambda_matrix, int, int);
-void lambda_matrix_transpose (lambda_matrix, lambda_matrix, int, int);
-void lambda_matrix_add (lambda_matrix, lambda_matrix, lambda_matrix, int,
-                       int);
-void lambda_matrix_add_mc (lambda_matrix, int, lambda_matrix, int,
-                          lambda_matrix, int, int);
-void lambda_matrix_mult (lambda_matrix, lambda_matrix, lambda_matrix,
-                        int, int, int);
-void lambda_matrix_delete_rows (lambda_matrix, int, int, int);
-void lambda_matrix_row_exchange (lambda_matrix, int, int);
-void lambda_matrix_row_add (lambda_matrix, int, int, int, int);
-void lambda_matrix_row_negate (lambda_matrix mat, int, int);
-void lambda_matrix_row_mc (lambda_matrix, int, int, int);
-void lambda_matrix_col_exchange (lambda_matrix, int, int, int);
-void lambda_matrix_col_add (lambda_matrix, int, int, int, int);
-void lambda_matrix_col_negate (lambda_matrix, int, int);
-void lambda_matrix_col_mc (lambda_matrix, int, int, int);
-int lambda_matrix_inverse (lambda_matrix, lambda_matrix, int, struct obstack *);
-void lambda_matrix_hermite (lambda_matrix, int, lambda_matrix, lambda_matrix);
-void lambda_matrix_left_hermite (lambda_matrix, int, int, lambda_matrix, lambda_matrix);
-void lambda_matrix_right_hermite (lambda_matrix, int, int, lambda_matrix, lambda_matrix);
-int lambda_matrix_first_nz_vec (lambda_matrix, int, int, int);
-void lambda_matrix_project_to_null (lambda_matrix, int, int, int,
-                                   lambda_vector);
-void print_lambda_matrix (FILE *, lambda_matrix, int, int);
-
-lambda_trans_matrix lambda_trans_matrix_new (int, int, struct obstack *);
-bool lambda_trans_matrix_nonsingular_p (lambda_trans_matrix);
-bool lambda_trans_matrix_fullrank_p (lambda_trans_matrix);
-int lambda_trans_matrix_rank (lambda_trans_matrix);
-lambda_trans_matrix lambda_trans_matrix_basis (lambda_trans_matrix);
-lambda_trans_matrix lambda_trans_matrix_padding (lambda_trans_matrix);
-lambda_trans_matrix lambda_trans_matrix_inverse (lambda_trans_matrix,
-                                                struct obstack *);
-void print_lambda_trans_matrix (FILE *, lambda_trans_matrix);
-void lambda_matrix_vector_mult (lambda_matrix, int, int, lambda_vector,
-                               lambda_vector);
-bool lambda_trans_matrix_id_p (lambda_trans_matrix);
-
-lambda_body_vector lambda_body_vector_new (int, struct obstack *);
-lambda_body_vector lambda_body_vector_compute_new (lambda_trans_matrix,
-                                                   lambda_body_vector,
-                                                   struct obstack *);
-void print_lambda_body_vector (FILE *, lambda_body_vector);
-lambda_loopnest gcc_loopnest_to_lambda_loopnest (struct loop *,
-                                                VEC(tree,heap) **,
-                                                 VEC(tree,heap) **,
-                                                 struct obstack *);
-void lambda_loopnest_to_gcc_loopnest (struct loop *,
-                                     VEC(tree,heap) *, VEC(tree,heap) *,
-                                     VEC(gimple,heap) **,
-                                      lambda_loopnest, lambda_trans_matrix,
-                                      struct obstack *);
-void remove_iv (gimple);
-tree find_induction_var_from_exit_cond (struct loop *);
-
-static inline void lambda_vector_negate (lambda_vector, lambda_vector, int);
-static inline void lambda_vector_mult_const (lambda_vector, lambda_vector, int, int);
-static inline void lambda_vector_add (lambda_vector, lambda_vector,
-                                     lambda_vector, int);
-static inline void lambda_vector_add_mc (lambda_vector, int, lambda_vector, int,
-                                        lambda_vector, int);
-static inline void lambda_vector_copy (lambda_vector, lambda_vector, int);
-static inline bool lambda_vector_zerop (lambda_vector, int);
-static inline void lambda_vector_clear (lambda_vector, int);
-static inline bool lambda_vector_equal (lambda_vector, lambda_vector, int);
-static inline int lambda_vector_min_nz (lambda_vector, int, int);
-static inline int lambda_vector_first_nz (lambda_vector, int, int);
-static inline void print_lambda_vector (FILE *, lambda_vector, int);
-
-/* Allocate a new vector of given SIZE.  */
-
-static inline lambda_vector
-lambda_vector_new (int size)
-{
-  return (lambda_vector) ggc_alloc_cleared_atomic (sizeof (int) * size);
-}
-
-
-
-/* Multiply vector VEC1 of length SIZE by a constant CONST1,
-   and store the result in VEC2.  */
-
-static inline void
-lambda_vector_mult_const (lambda_vector vec1, lambda_vector vec2,
-                         int size, int const1)
-{
-  int i;
-
-  if (const1 == 0)
-    lambda_vector_clear (vec2, size);
-  else
-    for (i = 0; i < size; i++)
-      vec2[i] = const1 * vec1[i];
-}
-
-/* Negate vector VEC1 with length SIZE and store it in VEC2.  */
-
-static inline void
-lambda_vector_negate (lambda_vector vec1, lambda_vector vec2,
-                     int size)
-{
-  lambda_vector_mult_const (vec1, vec2, size, -1);
-}
-
-/* VEC3 = VEC1+VEC2, where all three the vectors are of length SIZE.  */
-
-static inline void
-lambda_vector_add (lambda_vector vec1, lambda_vector vec2,
-                  lambda_vector vec3, int size)
-{
-  int i;
-  for (i = 0; i < size; i++)
-    vec3[i] = vec1[i] + vec2[i];
-}
-
-/* VEC3 = CONSTANT1*VEC1 + CONSTANT2*VEC2.  All vectors have length SIZE.  */
-
-static inline void
-lambda_vector_add_mc (lambda_vector vec1, int const1,
-                     lambda_vector vec2, int const2,
-                     lambda_vector vec3, int size)
-{
-  int i;
-  for (i = 0; i < size; i++)
-    vec3[i] = const1 * vec1[i] + const2 * vec2[i];
-}
-
-/* Copy the elements of vector VEC1 with length SIZE to VEC2.  */
-
-static inline void
-lambda_vector_copy (lambda_vector vec1, lambda_vector vec2,
-                   int size)
-{
-  memcpy (vec2, vec1, size * sizeof (*vec1));
-}
-
-/* Return true if vector VEC1 of length SIZE is the zero vector.  */
-
-static inline bool
-lambda_vector_zerop (lambda_vector vec1, int size)
-{
-  int i;
-  for (i = 0; i < size; i++)
-    if (vec1[i] != 0)
-      return false;
-  return true;
-}
-
-/* Clear out vector VEC1 of length SIZE.  */
-
-static inline void
-lambda_vector_clear (lambda_vector vec1, int size)
-{
-  memset (vec1, 0, size * sizeof (*vec1));
-}
-
-/* Return true if two vectors are equal.  */
-
-static inline bool
-lambda_vector_equal (lambda_vector vec1, lambda_vector vec2, int size)
-{
-  int i;
-  for (i = 0; i < size; i++)
-    if (vec1[i] != vec2[i])
-      return false;
-  return true;
-}
-
-/* Return the minimum nonzero element in vector VEC1 between START and N.
-   We must have START <= N.  */
-
-static inline int
-lambda_vector_min_nz (lambda_vector vec1, int n, int start)
-{
-  int j;
-  int min = -1;
-
-  gcc_assert (start <= n);
-  for (j = start; j < n; j++)
-    {
-      if (vec1[j])
-       if (min < 0 || vec1[j] < vec1[min])
-         min = j;
-    }
-  gcc_assert (min >= 0);
-
-  return min;
-}
-
-/* Return the first nonzero element of vector VEC1 between START and N.
-   We must have START <= N.   Returns N if VEC1 is the zero vector.  */
-
-static inline int
-lambda_vector_first_nz (lambda_vector vec1, int n, int start)
-{
-  int j = start;
-  while (j < n && vec1[j] == 0)
-    j++;
-  return j;
-}
-
-
-/* Multiply a vector by a matrix.  */
-
-static inline void
-lambda_vector_matrix_mult (lambda_vector vect, int m, lambda_matrix mat,
-                          int n, lambda_vector dest)
-{
-  int i, j;
-  lambda_vector_clear (dest, n);
-  for (i = 0; i < n; i++)
-    for (j = 0; j < m; j++)
-      dest[i] += mat[j][i] * vect[j];
-}
-
-/* Compare two vectors returning an integer less than, equal to, or
-   greater than zero if the first argument is considered to be respectively
-   less than, equal to, or greater than the second.
-   We use the lexicographic order.  */
-
-static inline int
-lambda_vector_compare (lambda_vector vec1, int length1, lambda_vector vec2,
-                       int length2)
-{
-  int min_length;
-  int i;
-
-  if (length1 < length2)
-    min_length = length1;
-  else
-    min_length = length2;
-
-  for (i = 0; i < min_length; i++)
-    if (vec1[i] < vec2[i])
-      return -1;
-    else if (vec1[i] > vec2[i])
-      return 1;
-    else
-      continue;
-
-  return length1 - length2;
-}
-
-/* Print out a vector VEC of length N to OUTFILE.  */
-
-static inline void
-print_lambda_vector (FILE * outfile, lambda_vector vector, int n)
-{
-  int i;
-
-  for (i = 0; i < n; i++)
-    fprintf (outfile, "%3d ", vector[i]);
-  fprintf (outfile, "\n");
-}
-
-/* Compute the greatest common divisor of two numbers using
-   Euclid's algorithm.  */
-
-static inline int
-gcd (int a, int b)
-{
-  int x, y, z;
-
-  x = abs (a);
-  y = abs (b);
-
-  while (x > 0)
-    {
-      z = y % x;
-      y = x;
-      x = z;
-    }
-
-  return y;
-}
-
-/* Compute the greatest common divisor of a VECTOR of SIZE numbers.  */
-
-static inline int
-lambda_vector_gcd (lambda_vector vector, int size)
-{
-  int i;
-  int gcd1 = 0;
-
-  if (size > 0)
-    {
-      gcd1 = vector[0];
-      for (i = 1; i < size; i++)
-       gcd1 = gcd (gcd1, vector[i]);
-    }
-  return gcd1;
-}
-
-/* Returns true when the vector V is lexicographically positive, in
-   other words, when the first nonzero element is positive.  */
-
-static inline bool
-lambda_vector_lexico_pos (lambda_vector v,
-                         unsigned n)
-{
-  unsigned i;
-  for (i = 0; i < n; i++)
-    {
-      if (v[i] == 0)
-       continue;
-      if (v[i] < 0)
-       return false;
-      if (v[i] > 0)
-       return true;
-    }
-  return true;
-}
-
-/* Given a vector of induction variables IVS, and a vector of
-   coefficients COEFS, build a tree that is a linear combination of
-   the induction variables.  */
-
-static inline tree
-build_linear_expr (tree type, lambda_vector coefs, VEC (tree, heap) *ivs)
-{
-  unsigned i;
-  tree iv;
-  tree expr = build_zero_cst (type);
-
-  for (i = 0; VEC_iterate (tree, ivs, i, iv); i++)
-    {
-      int k = coefs[i];
-
-      if (k == 1)
-       expr = fold_build2 (PLUS_EXPR, type, expr, iv);
-
-      else if (k != 0)
-       expr = fold_build2 (PLUS_EXPR, type, expr,
-                           fold_build2 (MULT_EXPR, type, iv,
-                                        build_int_cst (type, k)));
-    }
-
-  return expr;
-}
-
-/* Returns the dependence level for a vector DIST of size LENGTH.
-   LEVEL = 0 means a lexicographic dependence, i.e. a dependence due
-   to the sequence of statements, not carried by any loop.  */
-
-
-static inline unsigned
-dependence_level (lambda_vector dist_vect, int length)
-{
-  int i;
-
-  for (i = 0; i < length; i++)
-    if (dist_vect[i] != 0)
-      return i + 1;
-
-  return 0;
-}
-
-#endif /* LAMBDA_H  */
index b331d5c..7573276 100644 (file)
@@ -25,7 +25,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree.h"
 #include "gimple.h"
 #include "ggc.h"
-#include "lambda.h"    /* gcd */
 #include "hashtab.h"
 #include "plugin-api.h"
 #include "lto-streamer.h"
index aee99e7..1717f8e 100644 (file)
@@ -181,24 +181,6 @@ omega_no_procedure (omega_pb pb ATTRIBUTE_UNUSED)
 
 void (*omega_when_reduced) (omega_pb) = omega_no_procedure;
 
-/* Compute the greatest common divisor of A and B.  */
-
-static inline int
-gcd (int b, int a)
-{
-  if (b == 1)
-    return 1;
-
-  while (b != 0)
-    {
-      int t = b;
-      b = a % b;
-      a = t;
-    }
-
-  return a;
-}
-
 /* Print to FILE from PB equation E with all its coefficients
    multiplied by C.  */
 
index d32bccf..90d61e3 100644 (file)
@@ -887,7 +887,6 @@ init_optimization_passes (void)
          NEXT_PASS (pass_record_bounds);
          NEXT_PASS (pass_check_data_deps);
          NEXT_PASS (pass_loop_distribution);
-         NEXT_PASS (pass_linear_transform);
          NEXT_PASS (pass_copy_prop);
          NEXT_PASS (pass_graphite);
            {
index 24fbc0b..3234f95 100644 (file)
@@ -1,3 +1,48 @@
+2011-01-25  Sebastian Pop  <sebastian.pop@amd.com>
+
+       * gfortran.dg/graphite/interchange-4.f: New.
+       * gfortran.dg/graphite/interchange-5.f: New.
+
+       * gcc.dg/tree-ssa/ltrans-1.c: Removed.
+       * gcc.dg/tree-ssa/ltrans-2.c: Removed.
+       * gcc.dg/tree-ssa/ltrans-3.c: Removed.
+       * gcc.dg/tree-ssa/ltrans-4.c: Removed.
+       * gcc.dg/tree-ssa/ltrans-5.c: Removed.
+       * gcc.dg/tree-ssa/ltrans-6.c: Removed.
+       * gcc.dg/tree-ssa/ltrans-8.c: Removed.
+       * gfortran.dg/ltrans-7.f90: Removed.
+       * gcc.dg/tree-ssa/data-dep-1.c: Removed.
+
+       * gcc.dg/pr18792.c: -> gcc.dg/graphite/pr18792.c
+       * gcc.dg/pr19910.c: -> gcc.dg/graphite/pr19910.c
+       * gcc.dg/tree-ssa/20041110-1.c: -> gcc.dg/graphite/pr20041110-1.c
+       * gcc.dg/tree-ssa/pr20256.c: -> gcc.dg/graphite/pr20256.c
+       * gcc.dg/pr23625.c: -> gcc.dg/graphite/pr23625.c
+       * gcc.dg/tree-ssa/pr23820.c: -> gcc.dg/graphite/pr23820.c
+       * gcc.dg/tree-ssa/pr24309.c: -> gcc.dg/graphite/pr24309.c
+       * gcc.dg/tree-ssa/pr26435.c: -> gcc.dg/graphite/pr26435.c
+       * gcc.dg/pr29330.c: -> gcc.dg/graphite/pr29330.c
+       * gcc.dg/pr29581-1.c: -> gcc.dg/graphite/pr29581-1.c
+       * gcc.dg/pr29581-2.c: -> gcc.dg/graphite/pr29581-2.c
+       * gcc.dg/pr29581-3.c: -> gcc.dg/graphite/pr29581-3.c
+       * gcc.dg/pr29581-4.c: -> gcc.dg/graphite/pr29581-4.c
+       * gcc.dg/tree-ssa/loop-27.c: -> gcc.dg/graphite/pr30565.c
+       * gcc.dg/tree-ssa/pr31183.c: -> gcc.dg/graphite/pr31183.c
+       * gcc.dg/tree-ssa/pr33576.c: -> gcc.dg/graphite/pr33576.c
+       * gcc.dg/tree-ssa/pr33766.c: -> gcc.dg/graphite/pr33766.c
+       * gcc.dg/pr34016.c: -> gcc.dg/graphite/pr34016.c
+       * gcc.dg/tree-ssa/pr34017.c: -> gcc.dg/graphite/pr34017.c
+       * gcc.dg/tree-ssa/pr34123.c: -> gcc.dg/graphite/pr34123.c
+       * gcc.dg/tree-ssa/pr36287.c: -> gcc.dg/graphite/pr36287.c
+       * gcc.dg/tree-ssa/pr37686.c: -> gcc.dg/graphite/pr37686.c
+       * gcc.dg/pr42917.c: -> gcc.dg/graphite/pr42917.c
+       * gcc.dg/tree-ssa/data-dep-1.c
+       * gfortran.dg/loop_nest_1.f90: -> gfortran.dg/graphite/pr29290.f90
+       * gfortran.dg/pr29581.f90: -> gfortran.dg/graphite/pr29581.f90
+       * gfortran.dg/pr36286.f90: -> gfortran.dg/graphite/pr36286.f90
+       * gfortran.dg/pr36922.f: -> gfortran.dg/graphite/pr36922.f
+       * gfortran.dg/pr39516.f: -> gfortran.dg/graphite/pr39516.f
+
 2011-01-25  Jakub Jelinek  <jakub@redhat.com>
 
        PR tree-optimization/47265
similarity index 63%
rename from gcc/testsuite/gcc.dg/tree-ssa/pr20256.c
rename to gcc/testsuite/gcc.dg/graphite/pr20256.c
index aa482ed..29c8ebd 100644 (file)
@@ -1,5 +1,5 @@
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
 /* { dg-require-effective-target size32plus } */
 
 int foo()
@@ -20,6 +20,3 @@ int foo()
 
   return s;
 }
-
-/* { dg-final { scan-tree-dump-times "converted loop nest to perfect loop nest" 0 "ltrans"} } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
similarity index 60%
rename from gcc/testsuite/gcc.dg/tree-ssa/pr26435.c
rename to gcc/testsuite/gcc.dg/graphite/pr26435.c
index 907c5d2..4e5e5f7 100644 (file)
@@ -1,5 +1,5 @@
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
 /* { dg-require-effective-target size32plus } */
 
 int foo(int *p, int n)
@@ -15,6 +15,3 @@ int foo(int *p, int n)
 
   return k;
 }
-
-/* { dg-final { scan-tree-dump-times "converted loop nest to perfect loop nest" 0 "ltrans"} } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gcc.dg/graphite/pr42917.c b/gcc/testsuite/gcc.dg/graphite/pr42917.c
new file mode 100644 (file)
index 0000000..eddff3b
--- /dev/null
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-loop-linear -fcompare-debug" } */
+
+extern int A[];
+
+void
+foo ()
+{
+  int i, j;
+  for (i = 0; i < 4; i++)
+    for (j = 255; j >= 0; j--)
+      A[j] = 0;
+}
diff --git a/gcc/testsuite/gcc.dg/pr42917.c b/gcc/testsuite/gcc.dg/pr42917.c
deleted file mode 100644 (file)
index d8db32e..0000000
+++ /dev/null
@@ -1,16 +0,0 @@
-/* { dg-do compile } */
-/* { dg-options "-O1 -ftree-loop-linear -fcompare-debug -fdump-tree-ltrans" } */
-
-extern int A[];
-
-void
-foo ()
-{
-  int i, j;
-  for (i = 0; i < 4; i++)
-    for (j = 255; j >= 0; j--)
-      A[j] = 0;
-}
-
-/* { dg-final { scan-tree-dump "Successfully transformed loop" "ltrans" } } */
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c b/gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c
deleted file mode 100644 (file)
index 12e42b7..0000000
+++ /dev/null
@@ -1,28 +0,0 @@
-/* { dg-do compile { target int32plus } } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-
-int foo (int n, int m)
-{
-  int a[10000][10000];
-  int i, j, k;
-
-  for(k = 0; k < 1234; k++)
-    for(j = 0; j < 5; j++)
-      for(i = 0; i < 67; i++)
-       {
-         a[j+i-(-m+n+3)][i-k+4] = a[k+j][i];
-       }
-
-  return a[0][0];
-}
-
-
-/* For the data dependence analysis of the outermost loop, the
-   evolution of "k+j" should be instantiated in the outermost loop "k"
-   and the evolution should be taken in the innermost loop "i".  The
-   pattern below ensures that the evolution is not computed in the
-   outermost "k" loop: the 4 comes from the instantiation of the
-   number of iterations of loop "j".  */
-
-/* { dg-final { scan-tree-dump-times "4, \\+, 1" 0 "ltrans" } } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c
deleted file mode 100644 (file)
index bff58f6..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all -march=i486" { target { i?86-*-* && ilp32} } } */
-/* { dg-require-effective-target size32plus } */
-
-double u[1782225];
-int foo(int N, int *res)
-{
-  int i, j;
-  double sum = 0.0;
-  /* This loop should be converted to a perfect nest and
-     interchanged. */
-  for (i = 0; i < N; i++)
-    {
-      for (j = 0; j < N; j++)
-       sum = sum + u[i + 1335 * j];
-      
-      u[1336 * i] *= 2;
-    }
-  *res = sum + N;
-}
-/* { dg-final { scan-tree-dump-times "converted loop nest to perfect loop nest" 1 "ltrans"} } */ 
-/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c
deleted file mode 100644 (file)
index 9548bf2..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-/* { dg-require-effective-target size32plus } */
-
-double u[1782225];
-int foo(int N, int *res)
-{
-  unsigned int i, j;
-  double sum = 0;
-  
-  /* This loop should be converted to a perfect nest and
-     interchanged.  */
-  for (i = 0; i < N; i++)
-    {
-      for (j = 0; j < N; j++)
-       {
-         sum = sum + u[i + 1335 * j];
-         if (j == N - 1)
-           u[1336 * i] *= 2;
-       }
-    }
-  *res = sum + N;
-}
-/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} {
-   xfail *-*-*} } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c
deleted file mode 100644 (file)
index d7dd211..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all -march=i486" { target { i?86-*-* && ilp32} } } */
-/* { dg-require-effective-target size32plus } */
-
-double u[1782225];
-int foo(int N, int *res)
-{
-  unsigned int i, j;
-  double sum = 0;
-      for (i = 0; i < N; i++)
-       {
-         for (j = 0; j < N; j++)
-           {
-             sum = sum + u[i + 1335 * j];
-           }
-       }
-      *res = sum + N;
-}
-
-/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans" } } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c
deleted file mode 100644 (file)
index 6682538..0000000
+++ /dev/null
@@ -1,21 +0,0 @@
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all -march=i486" { target { i?86-*-* && ilp32} } } */
-/* { dg-require-effective-target size32plus } */
-
-double u[1782225];
-int foo(int N, int *res)
-{
-  int i, j;
-  double sum = 0;
-  for (i = 0; i < N; i++)      
-    for (j = 0; j < N; j++)
-      sum = sum + u[i + 1335 * j];
-  
-  for (i = 0; i < N; i++)
-    u[1336 * i] *= 2;
-  *res = sum + N;
-}
-
-/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c
deleted file mode 100644 (file)
index 3540723..0000000
+++ /dev/null
@@ -1,18 +0,0 @@
-/* { dg-do compile { target { size32plus } } } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all -march=i486" { target { i?86-*-* && ilp32} } } */
-
-int foo ()
-{
-  int A[100][1111];
-  int i, j;
-
-  for( i = 0; i < 1111; i++)
-    for( j = 0; j < 100; j++)
-      A[j][i] = 5 * A[j][i];
-
-  return A[10][10];
-}
-
-/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c
deleted file mode 100644 (file)
index e6a290a..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all -march=i486" { target { i?86-*-* && ilp32} } } */
-/* { dg-require-effective-target size32plus } */
-
-
-
-int medium_loop_interchange(int A[100][200])
-{
-  int i,j;
-
-  /* This loop should be interchanged. */
-
-  for(j = 0; j < 200; j++)
-    for(i = 0; i < 100; i++)
-      A[i][j] = A[i][j] + A[i][j];
-
-  return A[1][1];
-}
-
-/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c
deleted file mode 100644 (file)
index 67569d8..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all -march=i486" { target { i?86-*-* && ilp32} } } */
-double foo(double *a)
-{
-       int i,j;
-       double r = 0.0;
-      for (i=0; i<100; ++i)
-               for (j=0; j<1000; ++j)
-                      r += a[j*100+i];
-       return r;
-}
-
-/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
-/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc/testsuite/gfortran.dg/graphite/interchange-4.f b/gcc/testsuite/gfortran.dg/graphite/interchange-4.f
new file mode 100644 (file)
index 0000000..3d42811
--- /dev/null
@@ -0,0 +1,29 @@
+      subroutine s231 (ntimes,ld,n,ctime,dtime,a,b,c,d,e,aa,bb,cc)
+c
+c     loop interchange
+c     loop with multiple dimension recursion
+c
+      integer ntimes, ld, n, i, nl, j
+      double precision a(n), b(n), c(n), d(n), e(n), aa(ld,n),
+     +                 bb(ld,n), cc(ld,n)
+      double precision chksum, cs2d
+      real t1, t2, second, ctime, dtime
+
+      call init(ld,n,a,b,c,d,e,aa,bb,cc,'s231 ')
+      t1 = second()
+      do 1 nl = 1,ntimes/n
+      do 10 i=1,n
+         do 20 j=2,n
+            aa(i,j) = aa(i,j-1) + bb(i,j)
+   20    continue
+   10 continue
+      call dummy(ld,n,a,b,c,d,e,aa,bb,cc,1.d0)
+   1  continue
+      t2 = second() - t1 - ctime - ( dtime * float(ntimes/n) )
+      chksum = cs2d(n,aa)
+      call check (chksum,(ntimes/n)*n*(n-1),n,t2,'s231 ')
+      return
+      end
+
+! { dg-final { scan-tree-dump-times "will be interchanged" 1 "graphite" { xfail *-*-* } } }
+! { dg-final { cleanup-tree-dump "graphite" } }
diff --git a/gcc/testsuite/gfortran.dg/graphite/interchange-5.f b/gcc/testsuite/gfortran.dg/graphite/interchange-5.f
new file mode 100644 (file)
index 0000000..658f10a
--- /dev/null
@@ -0,0 +1,30 @@
+      subroutine s235 (ntimes,ld,n,ctime,dtime,a,b,c,d,e,aa,bb,cc)
+c
+c     loop interchanging
+c     imperfectly nested loops
+c
+      integer ntimes, ld, n, i, nl, j
+      double precision a(n), b(n), c(n), d(n), e(n), aa(ld,n),
+     +                 bb(ld,n), cc(ld,n)
+      double precision chksum, cs1d, cs2d
+      real t1, t2, second, ctime, dtime
+
+      call init(ld,n,a,b,c,d,e,aa,bb,cc,'s235 ')
+      t1 = second()
+      do 1 nl = 1,ntimes/n
+      do 10 i = 1,n
+         a(i) =  a(i) + b(i) * c(i)
+         do 20 j = 2,n
+            aa(i,j) = aa(i,j-1) +  bb(i,j) * a(i)
+  20     continue
+  10  continue
+      call dummy(ld,n,a,b,c,d,e,aa,bb,cc,1.d0)
+  1   continue
+      t2 = second() - t1 - ctime - ( dtime * float(ntimes/n) )
+      chksum = cs2d(n,aa) + cs1d(n,a)
+      call check (chksum,(ntimes/n)*n*(n-1),n,t2,'s235 ')
+      return
+      end
+
+! { dg-final { scan-tree-dump-times "will be interchanged" 1 "graphite" { xfail *-*-* } } }
+! { dg-final { cleanup-tree-dump "graphite" } }
diff --git a/gcc/testsuite/gfortran.dg/ltrans-7.f90 b/gcc/testsuite/gfortran.dg/ltrans-7.f90
deleted file mode 100644 (file)
index 583edf2..0000000
+++ /dev/null
@@ -1,31 +0,0 @@
-! { dg-do compile }
-! { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" }
-! { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all -march=i486" { target { i?86-*-* && ilp32 } } }
-
-Program FOO
-  IMPLICIT INTEGER     (I-N)
-  IMPLICIT REAL*8      (A-H, O-Z)
-  PARAMETER (N1=1335, N2=1335)
-  COMMON U(N1,N2), V(N1,N2), P(N1,N2)
-
-  PC = 0.0D0
-  UC = 0.0D0
-  VC = 0.0D0
-
-  do I = 1, M
-     do J = 1, M
-        PC = PC + abs(P(I,J))
-        UC = UC + abs(U(I,J))
-        VC = VC + abs(V(I,J))
-     end do
-     U(I,I) = U(I,I) * ( mod (I, 100) /100.)
-  end do
-
-  write(6,366) PC, UC, VC
-366  format(/, ' PC = ',E12.4,/,' UC = ',E12.4,/,' VC = ',E12.4,/)
-
-end Program FOO
-
-! Please do not XFAIL.
-! { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans" } }
-! { dg-final { cleanup-tree-dump "ltrans" } }
index 5aecbff..9e5df7d 100644 (file)
@@ -340,6 +340,18 @@ print_dir_vectors (FILE *outf, VEC (lambda_vector, heap) *dir_vects,
     print_direction_vector (outf, v, length);
 }
 
+/* Print out a vector VEC of length N to OUTFILE.  */
+
+static inline void
+print_lambda_vector (FILE * outfile, lambda_vector vector, int n)
+{
+  int i;
+
+  for (i = 0; i < n; i++)
+    fprintf (outfile, "%3d ", vector[i]);
+  fprintf (outfile, "\n");
+}
+
 /* Print a vector of distance vectors.  */
 
 void
@@ -2064,6 +2076,168 @@ compute_overlap_steps_for_affine_1_2 (tree chrec_a, tree chrec_b,
   affine_fn_free (overlaps_b_xyz);
 }
 
+/* Copy the elements of vector VEC1 with length SIZE to VEC2.  */
+
+static void
+lambda_vector_copy (lambda_vector vec1, lambda_vector vec2,
+                   int size)
+{
+  memcpy (vec2, vec1, size * sizeof (*vec1));
+}
+
+/* Copy the elements of M x N matrix MAT1 to MAT2.  */
+
+static void
+lambda_matrix_copy (lambda_matrix mat1, lambda_matrix mat2,
+                   int m, int n)
+{
+  int i;
+
+  for (i = 0; i < m; i++)
+    lambda_vector_copy (mat1[i], mat2[i], n);
+}
+
+/* Store the N x N identity matrix in MAT.  */
+
+static void
+lambda_matrix_id (lambda_matrix mat, int size)
+{
+  int i, j;
+
+  for (i = 0; i < size; i++)
+    for (j = 0; j < size; j++)
+      mat[i][j] = (i == j) ? 1 : 0;
+}
+
+/* Return the first nonzero element of vector VEC1 between START and N.
+   We must have START <= N.   Returns N if VEC1 is the zero vector.  */
+
+static int
+lambda_vector_first_nz (lambda_vector vec1, int n, int start)
+{
+  int j = start;
+  while (j < n && vec1[j] == 0)
+    j++;
+  return j;
+}
+
+/* Add a multiple of row R1 of matrix MAT with N columns to row R2:
+   R2 = R2 + CONST1 * R1.  */
+
+static void
+lambda_matrix_row_add (lambda_matrix mat, int n, int r1, int r2, int const1)
+{
+  int i;
+
+  if (const1 == 0)
+    return;
+
+  for (i = 0; i < n; i++)
+    mat[r2][i] += const1 * mat[r1][i];
+}
+
+/* Swap rows R1 and R2 in matrix MAT.  */
+
+static void
+lambda_matrix_row_exchange (lambda_matrix mat, int r1, int r2)
+{
+  lambda_vector row;
+
+  row = mat[r1];
+  mat[r1] = mat[r2];
+  mat[r2] = row;
+}
+
+/* Multiply vector VEC1 of length SIZE by a constant CONST1,
+   and store the result in VEC2.  */
+
+static void
+lambda_vector_mult_const (lambda_vector vec1, lambda_vector vec2,
+                         int size, int const1)
+{
+  int i;
+
+  if (const1 == 0)
+    lambda_vector_clear (vec2, size);
+  else
+    for (i = 0; i < size; i++)
+      vec2[i] = const1 * vec1[i];
+}
+
+/* Negate vector VEC1 with length SIZE and store it in VEC2.  */
+
+static void
+lambda_vector_negate (lambda_vector vec1, lambda_vector vec2,
+                     int size)
+{
+  lambda_vector_mult_const (vec1, vec2, size, -1);
+}
+
+/* Negate row R1 of matrix MAT which has N columns.  */
+
+static void
+lambda_matrix_row_negate (lambda_matrix mat, int n, int r1)
+{
+  lambda_vector_negate (mat[r1], mat[r1], n);
+}
+
+/* Return true if two vectors are equal.  */
+
+static bool
+lambda_vector_equal (lambda_vector vec1, lambda_vector vec2, int size)
+{
+  int i;
+  for (i = 0; i < size; i++)
+    if (vec1[i] != vec2[i])
+      return false;
+  return true;
+}
+
+/* Given an M x N integer matrix A, this function determines an M x
+   M unimodular matrix U, and an M x N echelon matrix S such that
+   "U.A = S".  This decomposition is also known as "right Hermite".
+
+   Ref: Algorithm 2.1 page 33 in "Loop Transformations for
+   Restructuring Compilers" Utpal Banerjee.  */
+
+static void
+lambda_matrix_right_hermite (lambda_matrix A, int m, int n,
+                            lambda_matrix S, lambda_matrix U)
+{
+  int i, j, i0 = 0;
+
+  lambda_matrix_copy (A, S, m, n);
+  lambda_matrix_id (U, m);
+
+  for (j = 0; j < n; j++)
+    {
+      if (lambda_vector_first_nz (S[j], m, i0) < m)
+       {
+         ++i0;
+         for (i = m - 1; i >= i0; i--)
+           {
+             while (S[i][j] != 0)
+               {
+                 int sigma, factor, a, b;
+
+                 a = S[i-1][j];
+                 b = S[i][j];
+                 sigma = (a * b < 0) ? -1: 1;
+                 a = abs (a);
+                 b = abs (b);
+                 factor = sigma * (a / b);
+
+                 lambda_matrix_row_add (S, n, i, i-1, -factor);
+                 lambda_matrix_row_exchange (S, i, i-1);
+
+                 lambda_matrix_row_add (U, m, i, i-1, -factor);
+                 lambda_matrix_row_exchange (U, i, i-1);
+               }
+           }
+       }
+    }
+}
+
 /* Determines the overlapping elements due to accesses CHREC_A and
    CHREC_B, that are affine functions.  This function cannot handle
    symbolic evolution functions, ie. when initial conditions are
index 2e7e0e5..85c2386 100644 (file)
@@ -23,7 +23,6 @@ along with GCC; see the file COPYING3.  If not see
 #define GCC_TREE_DATA_REF_H
 
 #include "graphds.h"
-#include "lambda.h"
 #include "omega.h"
 #include "tree-chrec.h"
 
@@ -96,6 +95,19 @@ struct dr_alias
   bitmap vops;
 };
 
+/* An integer vector.  A vector formally consists of an element of a vector
+   space. A vector space is a set that is closed under vector addition
+   and scalar multiplication.  In this vector space, an element is a list of
+   integers.  */
+typedef int *lambda_vector;
+DEF_VEC_P(lambda_vector);
+DEF_VEC_ALLOC_P(lambda_vector,heap);
+DEF_VEC_ALLOC_P(lambda_vector,gc);
+
+/* An integer matrix.  A matrix consists of m vectors of length n (IE
+   all vectors are the same length).  */
+typedef lambda_vector *lambda_matrix;
+
 /* Each vector of the access matrix represents a linear access
    function for a subscript.  First elements correspond to the
    leftmost indices, ie. for a[i][j] the first vector corresponds to
@@ -494,6 +506,22 @@ ddrs_have_anti_deps (VEC (ddr_p, heap) *dependence_relations)
   return false;
 }
 
+/* Returns the dependence level for a vector DIST of size LENGTH.
+   LEVEL = 0 means a lexicographic dependence, i.e. a dependence due
+   to the sequence of statements, not carried by any loop.  */
+
+static inline unsigned
+dependence_level (lambda_vector dist_vect, int length)
+{
+  int i;
+
+  for (i = 0; i < length; i++)
+    if (dist_vect[i] != 0)
+      return i + 1;
+
+  return 0;
+}
+
 /* Return the dependence level for the DDR relation.  */
 
 static inline unsigned
@@ -629,16 +657,6 @@ rdg_has_similar_memory_accesses (struct graph *rdg, int v1, int v2)
                                       RDG_STMT (rdg, v2));
 }
 
-/* In lambda-code.c  */
-bool lambda_transform_legal_p (lambda_trans_matrix, int,
-                              VEC (ddr_p, heap) *);
-void lambda_collect_parameters (VEC (data_reference_p, heap) *,
-                               VEC (tree, heap) **);
-bool lambda_compute_access_matrices (VEC (data_reference_p, heap) *,
-                                    VEC (tree, heap) *,
-                                    VEC (loop_p, heap) *,
-                                    struct obstack *);
-
 /* In tree-data-ref.c  */
 void split_constant_offset (tree , tree *, tree *);
 
@@ -656,4 +674,86 @@ DEF_VEC_ALLOC_P (rdgc, heap);
 DEF_VEC_P (bitmap);
 DEF_VEC_ALLOC_P (bitmap, heap);
 
+/* Compute the greatest common divisor of a VECTOR of SIZE numbers.  */
+
+static inline int
+lambda_vector_gcd (lambda_vector vector, int size)
+{
+  int i;
+  int gcd1 = 0;
+
+  if (size > 0)
+    {
+      gcd1 = vector[0];
+      for (i = 1; i < size; i++)
+       gcd1 = gcd (gcd1, vector[i]);
+    }
+  return gcd1;
+}
+
+/* Allocate a new vector of given SIZE.  */
+
+static inline lambda_vector
+lambda_vector_new (int size)
+{
+  return (lambda_vector) ggc_alloc_cleared_atomic (sizeof (int) * size);
+}
+
+/* Clear out vector VEC1 of length SIZE.  */
+
+static inline void
+lambda_vector_clear (lambda_vector vec1, int size)
+{
+  memset (vec1, 0, size * sizeof (*vec1));
+}
+
+/* Returns true when the vector V is lexicographically positive, in
+   other words, when the first nonzero element is positive.  */
+
+static inline bool
+lambda_vector_lexico_pos (lambda_vector v,
+                         unsigned n)
+{
+  unsigned i;
+  for (i = 0; i < n; i++)
+    {
+      if (v[i] == 0)
+       continue;
+      if (v[i] < 0)
+       return false;
+      if (v[i] > 0)
+       return true;
+    }
+  return true;
+}
+
+/* Return true if vector VEC1 of length SIZE is the zero vector.  */
+
+static inline bool
+lambda_vector_zerop (lambda_vector vec1, int size)
+{
+  int i;
+  for (i = 0; i < size; i++)
+    if (vec1[i] != 0)
+      return false;
+  return true;
+}
+
+/* Allocate a matrix of M rows x  N cols.  */
+
+static inline lambda_matrix
+lambda_matrix_new (int m, int n, struct obstack *lambda_obstack)
+{
+  lambda_matrix mat;
+  int i;
+
+  mat = (lambda_matrix) obstack_alloc (lambda_obstack,
+                                      sizeof (lambda_vector *) * m);
+
+  for (i = 0; i < m; i++)
+    mat[i] = lambda_vector_new (n);
+
+  return mat;
+}
+
 #endif  /* GCC_TREE_DATA_REF_H  */
index 682907c..1720859 100644 (file)
@@ -856,6 +856,4 @@ void warn_function_noreturn (tree);
 
 void swap_tree_operands (gimple, tree *, tree *);
 
-int least_common_multiple (int, int);
-
 #endif /* _TREE_FLOW_H  */
diff --git a/gcc/tree-loop-linear.c b/gcc/tree-loop-linear.c
deleted file mode 100644 (file)
index 5b19c17..0000000
+++ /dev/null
@@ -1,423 +0,0 @@
-/* Linear Loop transforms
-   Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
-   Free Software Foundation, Inc.
-   Contributed by Daniel Berlin <dberlin@dberlin.org>.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 3, or (at your option) any later
-version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3.  If not see
-<http://www.gnu.org/licenses/>.  */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tree-flow.h"
-#include "cfgloop.h"
-#include "tree-chrec.h"
-#include "tree-data-ref.h"
-#include "tree-scalar-evolution.h"
-#include "tree-pass.h"
-#include "lambda.h"
-
-/* Linear loop transforms include any composition of interchange,
-   scaling, skewing, and reversal.  They are used to change the
-   iteration order of loop nests in order to optimize data locality of
-   traversals, or remove dependences that prevent
-   parallelization/vectorization/etc.
-
-   TODO: Determine reuse vectors/matrix and use it to determine optimal
-   transform matrix for locality purposes.
-   TODO: Completion of partial transforms.  */
-
-/* Gather statistics for loop interchange.  LOOP is the loop being
-   considered. The first loop in the considered loop nest is
-   FIRST_LOOP, and consequently, the index of the considered loop is
-   obtained by LOOP->DEPTH - FIRST_LOOP->DEPTH
-
-   Initializes:
-   - DEPENDENCE_STEPS the sum of all the data dependence distances
-   carried by loop LOOP,
-
-   - NB_DEPS_NOT_CARRIED_BY_LOOP the number of dependence relations
-   for which the loop LOOP is not carrying any dependence,
-
-   - ACCESS_STRIDES the sum of all the strides in LOOP.
-
-   Example: for the following loop,
-
-   | loop_1 runs 1335 times
-   |   loop_2 runs 1335 times
-   |     A[{{0, +, 1}_1, +, 1335}_2]
-   |     B[{{0, +, 1}_1, +, 1335}_2]
-   |   endloop_2
-   |   A[{0, +, 1336}_1]
-   | endloop_1
-
-   gather_interchange_stats (in loop_1) will return
-   DEPENDENCE_STEPS = 3002
-   NB_DEPS_NOT_CARRIED_BY_LOOP = 5
-   ACCESS_STRIDES = 10694
-
-   gather_interchange_stats (in loop_2) will return
-   DEPENDENCE_STEPS = 3000
-   NB_DEPS_NOT_CARRIED_BY_LOOP = 7
-   ACCESS_STRIDES = 8010
-*/
-
-static void
-gather_interchange_stats (VEC (ddr_p, heap) *dependence_relations ATTRIBUTE_UNUSED,
-                         VEC (data_reference_p, heap) *datarefs ATTRIBUTE_UNUSED,
-                         struct loop *loop ATTRIBUTE_UNUSED,
-                         struct loop *first_loop ATTRIBUTE_UNUSED,
-                         unsigned int *dependence_steps ATTRIBUTE_UNUSED,
-                         unsigned int *nb_deps_not_carried_by_loop ATTRIBUTE_UNUSED,
-                         double_int *access_strides ATTRIBUTE_UNUSED)
-{
-  unsigned int i, j;
-  struct data_dependence_relation *ddr;
-  struct data_reference *dr;
-
-  *dependence_steps = 0;
-  *nb_deps_not_carried_by_loop = 0;
-  *access_strides = double_int_zero;
-
-  FOR_EACH_VEC_ELT (ddr_p, dependence_relations, i, ddr)
-    {
-      /* If we don't know anything about this dependence, or the distance
-        vector is NULL, or there is no dependence, then there is no reuse of
-        data.  */
-      if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know
-         || DDR_ARE_DEPENDENT (ddr) == chrec_known
-         || DDR_NUM_DIST_VECTS (ddr) == 0)
-       continue;
-
-      for (j = 0; j < DDR_NUM_DIST_VECTS (ddr); j++)
-       {
-         int dist = DDR_DIST_VECT (ddr, j)[loop_depth (loop) - loop_depth (first_loop)];
-
-         if (dist == 0)
-           (*nb_deps_not_carried_by_loop) += 1;
-
-         else if (dist < 0)
-           (*dependence_steps) += -dist;
-
-         else
-           (*dependence_steps) += dist;
-       }
-    }
-
-  /* Compute the access strides.  */
-  FOR_EACH_VEC_ELT (data_reference_p, datarefs, i, dr)
-    {
-      unsigned int it;
-      tree ref = DR_REF (dr);
-      gimple stmt = DR_STMT (dr);
-      struct loop *stmt_loop = loop_containing_stmt (stmt);
-      struct loop *inner_loop = first_loop->inner;
-
-      if (inner_loop != stmt_loop
-         && !flow_loop_nested_p (inner_loop, stmt_loop))
-       continue;
-
-      for (it = 0; it < DR_NUM_DIMENSIONS (dr);
-          it++, ref = TREE_OPERAND (ref, 0))
-       {
-         int num = am_vector_index_for_loop (DR_ACCESS_MATRIX (dr), loop->num);
-         int istride = AM_GET_ACCESS_MATRIX_ELEMENT (DR_ACCESS_MATRIX (dr), it, num);
-         tree array_size = TYPE_SIZE (TREE_TYPE (ref));
-         double_int dstride;
-
-         if (array_size == NULL_TREE
-             || TREE_CODE (array_size) != INTEGER_CST)
-           continue;
-
-         dstride = double_int_mul (tree_to_double_int (array_size),
-                                   shwi_to_double_int (istride));
-         (*access_strides) = double_int_add (*access_strides, dstride);
-       }
-    }
-}
-
-/* Attempt to apply interchange transformations to TRANS to maximize the
-   spatial and temporal locality of the loop.
-   Returns the new transform matrix.  The smaller the reuse vector
-   distances in the inner loops, the fewer the cache misses.
-   FIRST_LOOP is the loop->num of the first loop in the analyzed loop
-   nest.  */
-
-
-static lambda_trans_matrix
-try_interchange_loops (lambda_trans_matrix trans,
-                      unsigned int depth,
-                      VEC (ddr_p, heap) *dependence_relations,
-                      VEC (data_reference_p, heap) *datarefs,
-                      struct loop *first_loop)
-{
-  bool res;
-  struct loop *loop_i;
-  struct loop *loop_j;
-  unsigned int dependence_steps_i, dependence_steps_j;
-  double_int access_strides_i, access_strides_j;
-  double_int small, large, nb_iter;
-  double_int l1_cache_size, l2_cache_size;
-  int cmp;
-  unsigned int nb_deps_not_carried_by_i, nb_deps_not_carried_by_j;
-  struct data_dependence_relation *ddr;
-
-  if (VEC_length (ddr_p, dependence_relations) == 0)
-    return trans;
-
-  /* When there is an unknown relation in the dependence_relations, we
-     know that it is no worth looking at this loop nest: give up.  */
-  ddr = VEC_index (ddr_p, dependence_relations, 0);
-  if (ddr == NULL || DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
-    return trans;
-
-  l1_cache_size = uhwi_to_double_int (L1_CACHE_SIZE * 1024);
-  l2_cache_size = uhwi_to_double_int (L2_CACHE_SIZE * 1024);
-
-  /* LOOP_I is always the outer loop.  */
-  for (loop_j = first_loop->inner;
-       loop_j;
-       loop_j = loop_j->inner)
-    for (loop_i = first_loop;
-        loop_depth (loop_i) < loop_depth (loop_j);
-        loop_i = loop_i->inner)
-      {
-       gather_interchange_stats (dependence_relations, datarefs,
-                                 loop_i, first_loop,
-                                 &dependence_steps_i,
-                                 &nb_deps_not_carried_by_i,
-                                 &access_strides_i);
-       gather_interchange_stats (dependence_relations, datarefs,
-                                 loop_j, first_loop,
-                                 &dependence_steps_j,
-                                 &nb_deps_not_carried_by_j,
-                                 &access_strides_j);
-
-       /* Heuristics for loop interchange profitability:
-
-          0. Don't transform if the smallest stride is larger than
-             the L2 cache, or if the largest stride multiplied by the
-             number of iterations is smaller than the L1 cache.
-
-          1. (spatial locality) Inner loops should have smallest
-              dependence steps.
-
-          2. (spatial locality) Inner loops should contain more
-          dependence relations not carried by the loop.
-
-          3. (temporal locality) Inner loops should have smallest
-             array access strides.
-       */
-
-       cmp = double_int_ucmp (access_strides_i, access_strides_j);
-       small = cmp < 0 ? access_strides_i : access_strides_j;
-       large = cmp < 0 ? access_strides_j : access_strides_i;
-
-       if (double_int_ucmp (small, l2_cache_size) > 0)
-         continue;
-
-       res = cmp < 0 ?
-         estimated_loop_iterations (loop_j, false, &nb_iter):
-         estimated_loop_iterations (loop_i, false, &nb_iter);
-
-       if (res
-           && double_int_ucmp (double_int_mul (large, nb_iter),
-                               l1_cache_size) < 0)
-         continue;
-
-       if (dependence_steps_i < dependence_steps_j
-           || nb_deps_not_carried_by_i > nb_deps_not_carried_by_j
-           || cmp < 0)
-         {
-           lambda_matrix_row_exchange (LTM_MATRIX (trans),
-                                       loop_depth (loop_i) - loop_depth (first_loop),
-                                       loop_depth (loop_j) - loop_depth (first_loop));
-           /* Validate the resulting matrix.  When the transformation
-              is not valid, reverse to the previous transformation.  */
-           if (!lambda_transform_legal_p (trans, depth, dependence_relations))
-             lambda_matrix_row_exchange (LTM_MATRIX (trans),
-                                         loop_depth (loop_i) - loop_depth (first_loop),
-                                         loop_depth (loop_j) - loop_depth (first_loop));
-         }
-      }
-
-  return trans;
-}
-
-/* Return the number of nested loops in LOOP_NEST, or 0 if the loops
-   are not perfectly nested.  */
-
-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
-linear_transform_loops (void)
-{
-  bool modified = false;
-  loop_iterator li;
-  VEC(tree,heap) *oldivs = NULL;
-  VEC(tree,heap) *invariants = NULL;
-  VEC(tree,heap) *lambda_parameters = NULL;
-  VEC(gimple,heap) *remove_ivs = VEC_alloc (gimple, heap, 3);
-  struct loop *loop_nest;
-  gimple oldiv_stmt;
-  unsigned i;
-
-  FOR_EACH_LOOP (li, loop_nest, 0)
-    {
-      unsigned int depth = 0;
-      VEC (ddr_p, heap) *dependence_relations;
-      VEC (data_reference_p, heap) *datarefs;
-
-      lambda_loopnest before, after;
-      lambda_trans_matrix trans;
-      struct obstack lambda_obstack;
-      struct loop *loop;
-      VEC (loop_p, heap) *nest;
-      VEC (loop_p, heap) *ln;
-
-      depth = perfect_loop_nest_depth (loop_nest);
-      if (depth == 0)
-       continue;
-
-      nest = VEC_alloc (loop_p, heap, 3);
-      for (loop = loop_nest; loop; loop = loop->inner)
-       VEC_safe_push (loop_p, heap, nest, loop);
-
-      gcc_obstack_init (&lambda_obstack);
-      VEC_truncate (tree, oldivs, 0);
-      VEC_truncate (tree, invariants, 0);
-      VEC_truncate (tree, lambda_parameters, 0);
-
-      datarefs = VEC_alloc (data_reference_p, heap, 10);
-      dependence_relations = VEC_alloc (ddr_p, heap, 10 * 10);
-      ln = VEC_alloc (loop_p, heap, 3);
-      if (!compute_data_dependences_for_loop (loop_nest, true, &ln, &datarefs,
-                                             &dependence_relations))
-       goto free_and_continue;
-
-      lambda_collect_parameters (datarefs, &lambda_parameters);
-      if (!lambda_compute_access_matrices (datarefs, lambda_parameters,
-                                          nest, &lambda_obstack))
-       goto free_and_continue;
-
-      if (dump_file && (dump_flags & TDF_DETAILS))
-       dump_ddrs (dump_file, dependence_relations);
-
-      /* Build the transformation matrix.  */
-      trans = lambda_trans_matrix_new (depth, depth, &lambda_obstack);
-      lambda_matrix_id (LTM_MATRIX (trans), depth);
-      trans = try_interchange_loops (trans, depth, dependence_relations,
-                                    datarefs, loop_nest);
-
-      if (lambda_trans_matrix_id_p (trans))
-       {
-         if (dump_file)
-          fprintf (dump_file, "Won't transform loop. Optimal transform is the identity transform\n");
-         goto free_and_continue;
-       }
-
-      /* Check whether the transformation is legal.  */
-      if (!lambda_transform_legal_p (trans, depth, dependence_relations))
-       {
-         if (dump_file)
-           fprintf (dump_file, "Can't transform loop, transform is illegal:\n");
-         goto free_and_continue;
-       }
-
-      before = gcc_loopnest_to_lambda_loopnest (loop_nest, &oldivs,
-                                                &invariants, &lambda_obstack);
-
-      if (!before)
-       goto free_and_continue;
-
-      if (dump_file)
-       {
-         fprintf (dump_file, "Before:\n");
-         print_lambda_loopnest (dump_file, before, 'i');
-       }
-
-      after = lambda_loopnest_transform (before, trans, &lambda_obstack);
-
-      if (dump_file)
-       {
-         fprintf (dump_file, "After:\n");
-         print_lambda_loopnest (dump_file, after, 'u');
-       }
-
-      lambda_loopnest_to_gcc_loopnest (loop_nest, oldivs, invariants,
-                                      &remove_ivs,
-                                       after, trans, &lambda_obstack);
-      modified = true;
-
-      if (dump_file)
-       fprintf (dump_file, "Successfully transformed loop.\n");
-
-    free_and_continue:
-      obstack_free (&lambda_obstack, NULL);
-      free_dependence_relations (dependence_relations);
-      free_data_refs (datarefs);
-      VEC_free (loop_p, heap, nest);
-      VEC_free (loop_p, heap, ln);
-    }
-
-  FOR_EACH_VEC_ELT (gimple, remove_ivs, i, oldiv_stmt)
-    remove_iv (oldiv_stmt);
-
-  VEC_free (tree, heap, oldivs);
-  VEC_free (tree, heap, invariants);
-  VEC_free (gimple, heap, remove_ivs);
-  scev_reset ();
-
-  if (modified)
-    rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa_full_phi);
-}
index 96759cb..9a11f80 100644 (file)
@@ -240,6 +240,125 @@ name_to_copy_elt_hash (const void *aa)
   return (hashval_t) a->version;
 }
 
+/* A transformation matrix, which is a self-contained ROWSIZE x COLSIZE
+   matrix.  Rather than use floats, we simply keep a single DENOMINATOR that
+   represents the denominator for every element in the matrix.  */
+typedef struct lambda_trans_matrix_s
+{
+  lambda_matrix matrix;
+  int rowsize;
+  int colsize;
+  int denominator;
+} *lambda_trans_matrix;
+#define LTM_MATRIX(T) ((T)->matrix)
+#define LTM_ROWSIZE(T) ((T)->rowsize)
+#define LTM_COLSIZE(T) ((T)->colsize)
+#define LTM_DENOMINATOR(T) ((T)->denominator)
+
+/* Allocate a new transformation matrix.  */
+
+static lambda_trans_matrix
+lambda_trans_matrix_new (int colsize, int rowsize,
+                        struct obstack * lambda_obstack)
+{
+  lambda_trans_matrix ret;
+
+  ret = (lambda_trans_matrix)
+    obstack_alloc (lambda_obstack, sizeof (struct lambda_trans_matrix_s));
+  LTM_MATRIX (ret) = lambda_matrix_new (rowsize, colsize, lambda_obstack);
+  LTM_ROWSIZE (ret) = rowsize;
+  LTM_COLSIZE (ret) = colsize;
+  LTM_DENOMINATOR (ret) = 1;
+  return ret;
+}
+
+/* Multiply a vector VEC by a matrix MAT.
+   MAT is an M*N matrix, and VEC is a vector with length N.  The result
+   is stored in DEST which must be a vector of length M.  */
+
+static void
+lambda_matrix_vector_mult (lambda_matrix matrix, int m, int n,
+                          lambda_vector vec, lambda_vector dest)
+{
+  int i, j;
+
+  lambda_vector_clear (dest, m);
+  for (i = 0; i < m; i++)
+    for (j = 0; j < n; j++)
+      dest[i] += matrix[i][j] * vec[j];
+}
+
+/* Return true if TRANS is a legal transformation matrix that respects
+   the dependence vectors in DISTS and DIRS.  The conservative answer
+   is false.
+
+   "Wolfe proves that a unimodular transformation represented by the
+   matrix T is legal when applied to a loop nest with a set of
+   lexicographically non-negative distance vectors RDG if and only if
+   for each vector d in RDG, (T.d >= 0) is lexicographically positive.
+   i.e.: if and only if it transforms the lexicographically positive
+   distance vectors to lexicographically positive vectors.  Note that
+   a unimodular matrix must transform the zero vector (and only it) to
+   the zero vector." S.Muchnick.  */
+
+static bool
+lambda_transform_legal_p (lambda_trans_matrix trans,
+                         int nb_loops,
+                         VEC (ddr_p, heap) *dependence_relations)
+{
+  unsigned int i, j;
+  lambda_vector distres;
+  struct data_dependence_relation *ddr;
+
+  gcc_assert (LTM_COLSIZE (trans) == nb_loops
+             && LTM_ROWSIZE (trans) == nb_loops);
+
+  /* When there are no dependences, the transformation is correct.  */
+  if (VEC_length (ddr_p, dependence_relations) == 0)
+    return true;
+
+  ddr = VEC_index (ddr_p, dependence_relations, 0);
+  if (ddr == NULL)
+    return true;
+
+  /* When there is an unknown relation in the dependence_relations, we
+     know that it is no worth looking at this loop nest: give up.  */
+  if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
+    return false;
+
+  distres = lambda_vector_new (nb_loops);
+
+  /* For each distance vector in the dependence graph.  */
+  FOR_EACH_VEC_ELT (ddr_p, dependence_relations, i, ddr)
+    {
+      /* Don't care about relations for which we know that there is no
+        dependence, nor about read-read (aka. output-dependences):
+        these data accesses can happen in any order.  */
+      if (DDR_ARE_DEPENDENT (ddr) == chrec_known
+         || (DR_IS_READ (DDR_A (ddr)) && DR_IS_READ (DDR_B (ddr))))
+       continue;
+
+      /* Conservatively answer: "this transformation is not valid".  */
+      if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
+       return false;
+
+      /* If the dependence could not be captured by a distance vector,
+        conservatively answer that the transform is not valid.  */
+      if (DDR_NUM_DIST_VECTS (ddr) == 0)
+       return false;
+
+      /* Compute trans.dist_vect */
+      for (j = 0; j < DDR_NUM_DIST_VECTS (ddr); j++)
+       {
+         lambda_matrix_vector_mult (LTM_MATRIX (trans), nb_loops, nb_loops,
+                                    DDR_DIST_VECT (ddr, j), distres);
+
+         if (!lambda_vector_lexico_pos (distres, nb_loops))
+           return false;
+       }
+    }
+  return true;
+}
 
 /* Data dependency analysis. Returns true if the iterations of LOOP
    are independent on each other (that is, if we can execute them
index dd82288..6c551ae 100644 (file)
@@ -274,7 +274,7 @@ struct dump_file_info
 /* Insert PHI nodes everywhere they are needed.  No pruning of the
    IDF is done.  This is used by passes that need the PHI nodes for
    O_j even if it means that some arguments will come from the default
-   definition of O_j's symbol (e.g., pass_linear_transform).
+   definition of O_j's symbol.
 
    WARNING: If you need to use this flag, chances are that your pass
    may be doing something wrong.  Inserting PHI nodes for an old name
@@ -431,7 +431,6 @@ extern struct gimple_opt_pass pass_rename_ssa_copies;
 extern struct gimple_opt_pass pass_rest_of_compilation;
 extern struct gimple_opt_pass pass_sink_code;
 extern struct gimple_opt_pass pass_fre;
-extern struct gimple_opt_pass pass_linear_transform;
 extern struct gimple_opt_pass pass_check_data_deps;
 extern struct gimple_opt_pass pass_copy_prop;
 extern struct gimple_opt_pass pass_vrp;
index 4b51f40..5534b6a 100644 (file)
@@ -246,45 +246,6 @@ struct gimple_opt_pass pass_vectorize =
  }
 };
 
-/* Loop nest optimizations.  */
-
-static unsigned int
-tree_linear_transform (void)
-{
-  if (number_of_loops () <= 1)
-    return 0;
-
-  linear_transform_loops ();
-  return 0;
-}
-
-static bool
-gate_tree_linear_transform (void)
-{
-  return flag_tree_loop_linear != 0;
-}
-
-struct gimple_opt_pass pass_linear_transform =
-{
- {
-  GIMPLE_PASS,
-  "ltrans",                            /* name */
-  gate_tree_linear_transform,          /* gate */
-  tree_linear_transform,                       /* execute */
-  NULL,                                        /* sub */
-  NULL,                                        /* next */
-  0,                                   /* static_pass_number */
-  TV_TREE_LINEAR_TRANSFORM,            /* tv_id */
-  PROP_cfg | PROP_ssa,                 /* properties_required */
-  0,                                   /* properties_provided */
-  0,                                   /* properties_destroyed */
-  0,                                   /* todo_flags_start */
-  TODO_dump_func
-    | TODO_update_ssa_only_virtuals
-    | TODO_ggc_collect                 /* todo_flags_finish */
- }
-};
-
 /* GRAPHITE optimizations.  */
 
 static unsigned int
@@ -305,12 +266,17 @@ gate_graphite_transforms (void)
      is turned on.  */
   if (flag_loop_block
       || flag_loop_interchange
+      || flag_tree_loop_linear
       || flag_loop_strip_mine
       || flag_graphite_identity
       || flag_loop_parallelize_all
       || flag_loop_flatten)
     flag_graphite = 1;
 
+  /* Make flag_tree_loop_linear an alias of flag_loop_interchange.  */
+  if (flag_tree_loop_linear)
+    flag_loop_interchange = flag_tree_loop_linear;
+
   return flag_graphite != 0;
 }