Patchwork [21/32] Remove the lambda framework and make -ftree-loop-linear an alias of -floop-interchange.

login
register
mail settings
Submitter Sebastian Pop
Date Jan. 21, 2011, 7:18 p.m.
Message ID <1295637503-13246-1-git-send-email-sebpop@gmail.com>
Download mbox | patch
Permalink /patch/79884/
State New
Headers show

Comments

Sebastian Pop - Jan. 21, 2011, 7:18 p.m.
From: spop <spop@138bc75d-0d04-0410-961f-82ee72b054a4>

Hi Richi,

Could you please review this patch?  This is the only part of the
merge from graphite branch to trunk that touches the middle-end bits.

Thanks,
Sebastian

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/branches/graphite@168957 138bc75d-0d04-0410-961f-82ee72b054a4
---
 ChangeLog.graphite                                 |    4 +
 MAINTAINERS                                        |    1 -
 gcc/ChangeLog.graphite                             |  107 +
 gcc/Makefile.in                                    |   21 +-
 gcc/hwint.h                                        |   29 +
 gcc/lambda-code.c                                  | 2855 --------------------
 gcc/lambda-mat.c                                   |  607 -----
 gcc/lambda-trans.c                                 |   80 -
 gcc/lambda.h                                       |  524 ----
 gcc/lto-symtab.c                                   |    1 -
 gcc/omega.c                                        |   18 -
 gcc/passes.c                                       |    1 -
 gcc/testsuite/gcc.dg/graphite/pr18792.c            |   16 +
 gcc/testsuite/gcc.dg/graphite/pr19910.c            |   16 +
 gcc/testsuite/gcc.dg/graphite/pr20041110-1.c       |   26 +
 gcc/testsuite/gcc.dg/graphite/pr20256.c            |   23 +
 gcc/testsuite/gcc.dg/graphite/pr23625.c            |   27 +
 gcc/testsuite/gcc.dg/graphite/pr23820.c            |   26 +
 gcc/testsuite/gcc.dg/graphite/pr24309.c            |   18 +
 gcc/testsuite/gcc.dg/graphite/pr26435.c            |   17 +
 gcc/testsuite/gcc.dg/graphite/pr29330.c            |   15 +
 gcc/testsuite/gcc.dg/graphite/pr29581-1.c          |   44 +
 gcc/testsuite/gcc.dg/graphite/pr29581-2.c          |   46 +
 gcc/testsuite/gcc.dg/graphite/pr29581-3.c          |   48 +
 gcc/testsuite/gcc.dg/graphite/pr29581-4.c          |   48 +
 gcc/testsuite/gcc.dg/graphite/pr30565.c            |   14 +
 gcc/testsuite/gcc.dg/graphite/pr31183.c            |   14 +
 gcc/testsuite/gcc.dg/graphite/pr33576.c            |   20 +
 gcc/testsuite/gcc.dg/graphite/pr33766.c            |   19 +
 gcc/testsuite/gcc.dg/graphite/pr34016.c            |   19 +
 gcc/testsuite/gcc.dg/graphite/pr34017.c            |   26 +
 gcc/testsuite/gcc.dg/graphite/pr34123.c            |   18 +
 gcc/testsuite/gcc.dg/graphite/pr36287.c            |   22 +
 gcc/testsuite/gcc.dg/graphite/pr37686.c            |   48 +
 gcc/testsuite/gcc.dg/graphite/pr42917.c            |   13 +
 gcc/testsuite/gcc.dg/pr18792.c                     |   16 -
 gcc/testsuite/gcc.dg/pr19910.c                     |   16 -
 gcc/testsuite/gcc.dg/pr23625.c                     |   27 -
 gcc/testsuite/gcc.dg/pr29330.c                     |   15 -
 gcc/testsuite/gcc.dg/pr29581-1.c                   |   44 -
 gcc/testsuite/gcc.dg/pr29581-2.c                   |   46 -
 gcc/testsuite/gcc.dg/pr29581-3.c                   |   48 -
 gcc/testsuite/gcc.dg/pr29581-4.c                   |   48 -
 gcc/testsuite/gcc.dg/pr34016.c                     |   19 -
 gcc/testsuite/gcc.dg/pr42917.c                     |   16 -
 gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c         |   26 -
 gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c         |   28 -
 gcc/testsuite/gcc.dg/tree-ssa/loop-27.c            |   14 -
 gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c           |   24 -
 gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c           |   26 -
 gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c           |   22 -
 gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c           |   21 -
 gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c           |   18 -
 gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c           |   22 -
 gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c           |   15 -
 gcc/testsuite/gcc.dg/tree-ssa/pr20256.c            |   25 -
 gcc/testsuite/gcc.dg/tree-ssa/pr23820.c            |   26 -
 gcc/testsuite/gcc.dg/tree-ssa/pr24309.c            |   18 -
 gcc/testsuite/gcc.dg/tree-ssa/pr26435.c            |   20 -
 gcc/testsuite/gcc.dg/tree-ssa/pr31183.c            |   14 -
 gcc/testsuite/gcc.dg/tree-ssa/pr33576.c            |   20 -
 gcc/testsuite/gcc.dg/tree-ssa/pr33766.c            |   19 -
 gcc/testsuite/gcc.dg/tree-ssa/pr34017.c            |   26 -
 gcc/testsuite/gcc.dg/tree-ssa/pr34123.c            |   18 -
 gcc/testsuite/gcc.dg/tree-ssa/pr36287.c            |   22 -
 gcc/testsuite/gcc.dg/tree-ssa/pr37686.c            |   48 -
 gcc/testsuite/gfortran.dg/graphite/interchange-4.f |   29 +
 gcc/testsuite/gfortran.dg/graphite/interchange-5.f |   30 +
 gcc/testsuite/gfortran.dg/graphite/pr29290.f90     |    9 +
 gcc/testsuite/gfortran.dg/graphite/pr29581.f90     |   27 +
 gcc/testsuite/gfortran.dg/graphite/pr36286.f90     |   14 +
 gcc/testsuite/gfortran.dg/graphite/pr36922.f       |   16 +
 gcc/testsuite/gfortran.dg/graphite/pr39516.f       |   20 +
 gcc/testsuite/gfortran.dg/loop_nest_1.f90          |    9 -
 gcc/testsuite/gfortran.dg/ltrans-7.f90             |   31 -
 gcc/testsuite/gfortran.dg/pr29581.f90              |   27 -
 gcc/testsuite/gfortran.dg/pr36286.f90              |   14 -
 gcc/testsuite/gfortran.dg/pr36922.f                |   16 -
 gcc/testsuite/gfortran.dg/pr39516.f                |   20 -
 gcc/tree-data-ref.c                                |  174 ++
 gcc/tree-data-ref.h                                |  122 +-
 gcc/tree-flow.h                                    |    2 -
 gcc/tree-loop-linear.c                             |  423 ---
 gcc/tree-parloops.c                                |  119 +
 gcc/tree-pass.h                                    |    3 +-
 gcc/tree-ssa-loop.c                                |   44 +-
 86 files changed, 1282 insertions(+), 5465 deletions(-)
 delete mode 100644 gcc/lambda-code.c
 delete mode 100644 gcc/lambda-mat.c
 delete mode 100644 gcc/lambda-trans.c
 delete mode 100644 gcc/lambda.h
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr18792.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr19910.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr20041110-1.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr20256.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr23625.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr23820.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr24309.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr26435.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29330.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29581-1.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29581-2.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29581-3.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29581-4.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr30565.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr31183.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr33576.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr33766.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr34016.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr34017.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr34123.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr36287.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr37686.c
 create mode 100644 gcc/testsuite/gcc.dg/graphite/pr42917.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr18792.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr19910.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr23625.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr29330.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr29581-1.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr29581-2.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr29581-3.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr29581-4.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr34016.c
 delete mode 100644 gcc/testsuite/gcc.dg/pr42917.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-27.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr20256.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr23820.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr24309.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr26435.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr31183.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr33576.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr33766.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr34017.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr34123.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr36287.c
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr37686.c
 create mode 100644 gcc/testsuite/gfortran.dg/graphite/interchange-4.f
 create mode 100644 gcc/testsuite/gfortran.dg/graphite/interchange-5.f
 create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr29290.f90
 create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr29581.f90
 create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr36286.f90
 create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr36922.f
 create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr39516.f
 delete mode 100644 gcc/testsuite/gfortran.dg/loop_nest_1.f90
 delete mode 100644 gcc/testsuite/gfortran.dg/ltrans-7.f90
 delete mode 100644 gcc/testsuite/gfortran.dg/pr29581.f90
 delete mode 100644 gcc/testsuite/gfortran.dg/pr36286.f90
 delete mode 100644 gcc/testsuite/gfortran.dg/pr36922.f
 delete mode 100644 gcc/testsuite/gfortran.dg/pr39516.f
 delete mode 100644 gcc/tree-loop-linear.c
Richard Guenther - Jan. 25, 2011, 11:45 a.m.
On Fri, 21 Jan 2011, Sebastian Pop wrote:

> From: spop <spop@138bc75d-0d04-0410-961f-82ee72b054a4>
> 
> Hi Richi,
> 
> Could you please review this patch?  This is the only part of the
> merge from graphite branch to trunk that touches the middle-end bits.

This is ok.  Are the graphite tests always run, that is, at least
build and run without -fgraphite if that is disabled?  If not,
can you make sure to move/duplicate all testcases that were dg-run
to gcc.dg/torture/?

Thanks,
Richard.

> Thanks,
> Sebastian
> 
> 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/branches/graphite@168957 138bc75d-0d04-0410-961f-82ee72b054a4
> ---
>  ChangeLog.graphite                                 |    4 +
>  MAINTAINERS                                        |    1 -
>  gcc/ChangeLog.graphite                             |  107 +
>  gcc/Makefile.in                                    |   21 +-
>  gcc/hwint.h                                        |   29 +
>  gcc/lambda-code.c                                  | 2855 --------------------
>  gcc/lambda-mat.c                                   |  607 -----
>  gcc/lambda-trans.c                                 |   80 -
>  gcc/lambda.h                                       |  524 ----
>  gcc/lto-symtab.c                                   |    1 -
>  gcc/omega.c                                        |   18 -
>  gcc/passes.c                                       |    1 -
>  gcc/testsuite/gcc.dg/graphite/pr18792.c            |   16 +
>  gcc/testsuite/gcc.dg/graphite/pr19910.c            |   16 +
>  gcc/testsuite/gcc.dg/graphite/pr20041110-1.c       |   26 +
>  gcc/testsuite/gcc.dg/graphite/pr20256.c            |   23 +
>  gcc/testsuite/gcc.dg/graphite/pr23625.c            |   27 +
>  gcc/testsuite/gcc.dg/graphite/pr23820.c            |   26 +
>  gcc/testsuite/gcc.dg/graphite/pr24309.c            |   18 +
>  gcc/testsuite/gcc.dg/graphite/pr26435.c            |   17 +
>  gcc/testsuite/gcc.dg/graphite/pr29330.c            |   15 +
>  gcc/testsuite/gcc.dg/graphite/pr29581-1.c          |   44 +
>  gcc/testsuite/gcc.dg/graphite/pr29581-2.c          |   46 +
>  gcc/testsuite/gcc.dg/graphite/pr29581-3.c          |   48 +
>  gcc/testsuite/gcc.dg/graphite/pr29581-4.c          |   48 +
>  gcc/testsuite/gcc.dg/graphite/pr30565.c            |   14 +
>  gcc/testsuite/gcc.dg/graphite/pr31183.c            |   14 +
>  gcc/testsuite/gcc.dg/graphite/pr33576.c            |   20 +
>  gcc/testsuite/gcc.dg/graphite/pr33766.c            |   19 +
>  gcc/testsuite/gcc.dg/graphite/pr34016.c            |   19 +
>  gcc/testsuite/gcc.dg/graphite/pr34017.c            |   26 +
>  gcc/testsuite/gcc.dg/graphite/pr34123.c            |   18 +
>  gcc/testsuite/gcc.dg/graphite/pr36287.c            |   22 +
>  gcc/testsuite/gcc.dg/graphite/pr37686.c            |   48 +
>  gcc/testsuite/gcc.dg/graphite/pr42917.c            |   13 +
>  gcc/testsuite/gcc.dg/pr18792.c                     |   16 -
>  gcc/testsuite/gcc.dg/pr19910.c                     |   16 -
>  gcc/testsuite/gcc.dg/pr23625.c                     |   27 -
>  gcc/testsuite/gcc.dg/pr29330.c                     |   15 -
>  gcc/testsuite/gcc.dg/pr29581-1.c                   |   44 -
>  gcc/testsuite/gcc.dg/pr29581-2.c                   |   46 -
>  gcc/testsuite/gcc.dg/pr29581-3.c                   |   48 -
>  gcc/testsuite/gcc.dg/pr29581-4.c                   |   48 -
>  gcc/testsuite/gcc.dg/pr34016.c                     |   19 -
>  gcc/testsuite/gcc.dg/pr42917.c                     |   16 -
>  gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c         |   26 -
>  gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c         |   28 -
>  gcc/testsuite/gcc.dg/tree-ssa/loop-27.c            |   14 -
>  gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c           |   24 -
>  gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c           |   26 -
>  gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c           |   22 -
>  gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c           |   21 -
>  gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c           |   18 -
>  gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c           |   22 -
>  gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c           |   15 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr20256.c            |   25 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr23820.c            |   26 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr24309.c            |   18 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr26435.c            |   20 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr31183.c            |   14 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr33576.c            |   20 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr33766.c            |   19 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr34017.c            |   26 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr34123.c            |   18 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr36287.c            |   22 -
>  gcc/testsuite/gcc.dg/tree-ssa/pr37686.c            |   48 -
>  gcc/testsuite/gfortran.dg/graphite/interchange-4.f |   29 +
>  gcc/testsuite/gfortran.dg/graphite/interchange-5.f |   30 +
>  gcc/testsuite/gfortran.dg/graphite/pr29290.f90     |    9 +
>  gcc/testsuite/gfortran.dg/graphite/pr29581.f90     |   27 +
>  gcc/testsuite/gfortran.dg/graphite/pr36286.f90     |   14 +
>  gcc/testsuite/gfortran.dg/graphite/pr36922.f       |   16 +
>  gcc/testsuite/gfortran.dg/graphite/pr39516.f       |   20 +
>  gcc/testsuite/gfortran.dg/loop_nest_1.f90          |    9 -
>  gcc/testsuite/gfortran.dg/ltrans-7.f90             |   31 -
>  gcc/testsuite/gfortran.dg/pr29581.f90              |   27 -
>  gcc/testsuite/gfortran.dg/pr36286.f90              |   14 -
>  gcc/testsuite/gfortran.dg/pr36922.f                |   16 -
>  gcc/testsuite/gfortran.dg/pr39516.f                |   20 -
>  gcc/tree-data-ref.c                                |  174 ++
>  gcc/tree-data-ref.h                                |  122 +-
>  gcc/tree-flow.h                                    |    2 -
>  gcc/tree-loop-linear.c                             |  423 ---
>  gcc/tree-parloops.c                                |  119 +
>  gcc/tree-pass.h                                    |    3 +-
>  gcc/tree-ssa-loop.c                                |   44 +-
>  86 files changed, 1282 insertions(+), 5465 deletions(-)
>  delete mode 100644 gcc/lambda-code.c
>  delete mode 100644 gcc/lambda-mat.c
>  delete mode 100644 gcc/lambda-trans.c
>  delete mode 100644 gcc/lambda.h
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr18792.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr19910.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr20041110-1.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr20256.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr23625.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr23820.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr24309.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr26435.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29330.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29581-1.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29581-2.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29581-3.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr29581-4.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr30565.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr31183.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr33576.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr33766.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr34016.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr34017.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr34123.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr36287.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr37686.c
>  create mode 100644 gcc/testsuite/gcc.dg/graphite/pr42917.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr18792.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr19910.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr23625.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr29330.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr29581-1.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr29581-2.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr29581-3.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr29581-4.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr34016.c
>  delete mode 100644 gcc/testsuite/gcc.dg/pr42917.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-27.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr20256.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr23820.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr24309.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr26435.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr31183.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr33576.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr33766.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr34017.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr34123.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr36287.c
>  delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr37686.c
>  create mode 100644 gcc/testsuite/gfortran.dg/graphite/interchange-4.f
>  create mode 100644 gcc/testsuite/gfortran.dg/graphite/interchange-5.f
>  create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr29290.f90
>  create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr29581.f90
>  create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr36286.f90
>  create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr36922.f
>  create mode 100644 gcc/testsuite/gfortran.dg/graphite/pr39516.f
>  delete mode 100644 gcc/testsuite/gfortran.dg/loop_nest_1.f90
>  delete mode 100644 gcc/testsuite/gfortran.dg/ltrans-7.f90
>  delete mode 100644 gcc/testsuite/gfortran.dg/pr29581.f90
>  delete mode 100644 gcc/testsuite/gfortran.dg/pr36286.f90
>  delete mode 100644 gcc/testsuite/gfortran.dg/pr36922.f
>  delete mode 100644 gcc/testsuite/gfortran.dg/pr39516.f
>  delete mode 100644 gcc/tree-loop-linear.c
> 
> diff --git a/ChangeLog.graphite b/ChangeLog.graphite
> index 987aefa..7b319b3 100644
> --- a/ChangeLog.graphite
> +++ b/ChangeLog.graphite
> @@ -1,3 +1,7 @@
> +2011-01-17  Sebastian Pop  <sebastian.pop@amd.com>
> +
> +	* MAINTAINERS (linear loop transforms): Removed.
> +
>  2011-01-15  Sebastian Pop  <sebastian.pop@amd.com>
>  
>  	* configure: Regenerated.
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 5295978..0e1013c 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -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
> diff --git a/gcc/ChangeLog.graphite b/gcc/ChangeLog.graphite
> index 6b25988..e20e034 100644
> --- a/gcc/ChangeLog.graphite
> +++ b/gcc/ChangeLog.graphite
> @@ -1,5 +1,112 @@
>  2011-01-17  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.
> +
> +	* 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-17  Sebastian Pop  <sebastian.pop@amd.com>
> +
>  	* graphite-sese-to-poly.c (close_phi_written_to_memory): Also allow
>  	VAR_DECL, PARM_DECL, and RESULT_DECL.
>  
> diff --git a/gcc/Makefile.in b/gcc/Makefile.in
> index cde1ef2..1d4b6a4 100644
> --- a/gcc/Makefile.in
> +++ b/gcc/Makefile.in
> @@ -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
> @@ -1281,9 +1280,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 \
> @@ -1382,7 +1378,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 \
> @@ -2334,7 +2329,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) \
> @@ -2726,7 +2721,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) \
> @@ -2741,7 +2736,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) \
> @@ -2757,8 +2752,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 \
> @@ -3473,12 +3466,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)
> diff --git a/gcc/hwint.h b/gcc/hwint.h
> index 8bd7c5e..1eadd45 100644
> --- a/gcc/hwint.h
> +++ b/gcc/hwint.h
> @@ -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
> index f462071..0000000
> --- a/gcc/lambda-code.c
> +++ /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
> index 33b33ef..0000000
> --- a/gcc/lambda-mat.c
> +++ /dev/null
> @@ -1,607 +0,0 @@
> -/* Integer matrix math routines
> -   Copyright (C) 2003, 2004, 2005, 2007, 2008 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
> index 22f30b0..0000000
> --- a/gcc/lambda-trans.c
> +++ /dev/null
> @@ -1,80 +0,0 @@
> -/* Lambda matrix transformations.
> -   Copyright (C) 2003, 2004, 2007, 2008 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
> index d54ed27..0000000
> --- a/gcc/lambda.h
> +++ /dev/null
> @@ -1,524 +0,0 @@
> -/* Lambda matrix and vector interface.
> -   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
> -   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  */
> diff --git a/gcc/lto-symtab.c b/gcc/lto-symtab.c
> index b331d5c..7573276 100644
> --- a/gcc/lto-symtab.c
> +++ b/gcc/lto-symtab.c
> @@ -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"
> diff --git a/gcc/omega.c b/gcc/omega.c
> index aee99e7..1717f8e 100644
> --- a/gcc/omega.c
> +++ b/gcc/omega.c
> @@ -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.  */
>  
> diff --git a/gcc/passes.c b/gcc/passes.c
> index 4be61a9..eaf65c4 100644
> --- a/gcc/passes.c
> +++ b/gcc/passes.c
> @@ -882,7 +882,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);
>  	    {
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr18792.c b/gcc/testsuite/gcc.dg/graphite/pr18792.c
> new file mode 100644
> index 0000000..4e93fe1
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr18792.c
> @@ -0,0 +1,16 @@
> +/* PR tree-optimization/18792 */
> +/* { dg-do compile } */
> +/* { dg-options "-O1 -ftree-loop-linear" } */
> +void put_atoms_in_triclinic_unitcell(float x[][3])
> +{
> +	int i=0,d;
> +
> +	while (x[i][3] < 0)
> +		for (d=0; d<=3; d++)
> +			x[i][d] = 0;
> +
> +	while (x[i][3] >= 0)
> +		for (d=0; d<=3; d++)
> +			x[i][d] = 0;
> +
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr19910.c b/gcc/testsuite/gcc.dg/graphite/pr19910.c
> new file mode 100644
> index 0000000..1ee0d21
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr19910.c
> @@ -0,0 +1,16 @@
> +/* Contributed by Volker Reichelt <reichelt@gcc.gnu.org>.  */
> +
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +int a[3];
> +
> +void foo()
> +{
> +  int i, j;
> +
> +  for (i = 1; i >= 0; --i)
> +    for (j = i; j >= 0; --j)
> +      a[i+j] = 0;
> +}
> +
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr20041110-1.c b/gcc/testsuite/gcc.dg/graphite/pr20041110-1.c
> new file mode 100644
> index 0000000..825b2b4
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr20041110-1.c
> @@ -0,0 +1,26 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +/* This testcase was causing an ICE in building distance vectors because
> +   we weren't ignoring the fact that one of the induction variables
> +   involved in the dependence was outside of the loop.  */
> +extern int foo (int, int);
> +int
> +main (void)
> +{
> +  int a[50];
> +  int b[50];
> +  int i, j, k;
> +  for (i = 4; i < 30; i++)
> +    {
> +      for (j = 3; j < 40; j++)
> +	{
> +	  for (k = 9; k < 50; k++)
> +	    {
> +	      b[j] = a[i];
> +	      a[k] = b[i];
> +	    }
> +	}
> +    }
> +  foo (a[i], b[i]);
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr20256.c b/gcc/testsuite/gcc.dg/graphite/pr20256.c
> new file mode 100644
> index 0000000..c181fcb
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr20256.c
> @@ -0,0 +1,23 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +/* { dg-require-effective-target size32plus } */
> +
> +int foo()
> +{
> +  int x[2][2], y[2];
> +  int i, n, s;
> +
> +  /* This is a reduction: there is a scalar dependence that cannot be
> +     removed by rewriting IVs.  This code cannot and should not be
> +     transformed into a perfect loop.  */
> +  for (n = 0; n < 2; n++)
> +    {
> +      s = 0;
> +      for (i = 0; i < 2; i++)
> +        s += x[n][i]*y[i];
> +      s += 1;
> +    }
> +
> +  return s;
> +}
> +
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr23625.c b/gcc/testsuite/gcc.dg/graphite/pr23625.c
> new file mode 100644
> index 0000000..aaeddb2
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr23625.c
> @@ -0,0 +1,27 @@
> +/* Test case for PR23625 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-vectorize -ftree-loop-linear" } */
> +
> +typedef long INT32;
> +void find_best_colors ()
> +{
> +int ic0, ic1, ic2;
> +INT32 * bptr;
> +INT32 dist1;
> +INT32 dist2;
> +INT32 xx1;
> +for (ic0 = (1<<(5 -3))-1;ic0 >= 0;ic0--)
> +{
> +  for (ic1 = (1<<(6 -3))-1;ic1 >= 0;ic1--)
> +  {
> +    dist2 = dist1;
> +     for (ic2 = (1<<(5 -3))-1;ic2 >= 0;ic2--)
> +     {
> +        *bptr = dist2;
> +        bptr++;
> +     }
> +     dist1 += xx1;
> +  }
> +}
> +}
> +
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr23820.c b/gcc/testsuite/gcc.dg/graphite/pr23820.c
> new file mode 100644
> index 0000000..ee855e1
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr23820.c
> @@ -0,0 +1,26 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +int t [2][4];
> +
> +void foo (void)
> +{
> +  int i, j, k, v;
> +  float e;
> +  for (;;)
> +    {
> +      v = 0;
> +      for (j = 0; j < 2; j ++)
> +        {
> +          for (k = 2; k < 4; k ++)
> +            {
> +              e = 0.0;
> +              for (i = 0; i < 4; i ++)
> +                e += t [j][i];
> +              if (e)
> +                v = j;
> +            }
> +        }
> +      t [v][0] = 0;
> +    }
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr24309.c b/gcc/testsuite/gcc.dg/graphite/pr24309.c
> new file mode 100644
> index 0000000..b50e7a8
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr24309.c
> @@ -0,0 +1,18 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +float weight[10];
> +void lsp_weight_quant(float *x, char *cdbk)
> +{
> +   int i,j;
> +   float dist;
> +   int best_id=0;
> +   for (i=0;i<16;i++)
> +   {
> +      for (j=0;j<10;j++)
> +         dist=dist+weight[j];
> +      if (dist<0)
> +         best_id=i;
> +   }
> +   x[j] = cdbk[best_id*10+j];
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr26435.c b/gcc/testsuite/gcc.dg/graphite/pr26435.c
> new file mode 100644
> index 0000000..4e5e5f7
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr26435.c
> @@ -0,0 +1,17 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +/* { dg-require-effective-target size32plus } */
> +
> +int foo(int *p, int n)
> +{
> +  int i, j, k = 0;
> +
> +  /* This is a reduction: there is a scalar dependence that cannot be
> +     removed by rewriting IVs.  This code cannot and should not be
> +     transformed into a perfect loop.  */
> +  for (i = 0; i < 2; ++i, p += n)
> +    for (j = 0; j < 2; ++j)
> +      k += p[j];
> +
> +  return k;
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr29330.c b/gcc/testsuite/gcc.dg/graphite/pr29330.c
> new file mode 100644
> index 0000000..dff4207
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr29330.c
> @@ -0,0 +1,15 @@
> +/* PR tree-optimization/29330 */
> +/* { dg-do compile } */
> +/* { dg-options "-O -ftree-loop-linear -std=gnu99" } */
> +
> +int buf[2][2][2][2];
> +
> +void
> +f (void)
> +{
> +  for (int a = 0; a < 2; ++a)
> +    for (int b = 0; b < 2; ++b)
> +      for (int c = 0; c < 2; ++c)
> +	for (int d = 0; d < 2; ++d)
> +	  buf[a][b][c][d] = 0;
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr29581-1.c b/gcc/testsuite/gcc.dg/graphite/pr29581-1.c
> new file mode 100644
> index 0000000..e540073
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr29581-1.c
> @@ -0,0 +1,44 @@
> +/* PR tree-optimization/29581 */
> +/* Origin: gcc.dg/vect/vect-85.c */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +extern void abort (void);
> +
> +#define N 16
> +
> +int main1 (int *a)
> +{
> +  int i, j, k;
> +  int b[N];
> +
> +  for (i = 0; i < N; i++)
> +    {
> +      for (j = 0; j < N; j++)
> +	{
> +	  k = i + N;
> +	  a[j] = k;
> +	}
> +      b[i] = k;
> +    }
> +
> +
> +  for (j = 0; j < N; j++)
> +    if (a[j] != i + N - 1)
> +      abort();	
> +
> +  for (j = 0; j < N; j++)
> +    if (b[j] != j + N)
> +      abort();	
> +
> +  return 0;
> +}
> +
> +int main (void)
> +{
> +  int a[N] __attribute__ ((__aligned__(16)));
> +
> +  main1 (a);
> +
> +  return 0;
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr29581-2.c b/gcc/testsuite/gcc.dg/graphite/pr29581-2.c
> new file mode 100644
> index 0000000..c99d78c
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr29581-2.c
> @@ -0,0 +1,46 @@
> +/* PR tree-optimization/29581 */
> +/* Origin: gcc.dg/vect/vect-86.c */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +extern void abort (void);
> +
> +#define N 16
> +
> +int main1 (int n)
> +{
> +  int i, j, k;
> +  int a[N], b[N];
> +
> +  for (i = 0; i < n; i++)
> +    {
> +      for (j = 0; j < n; j++)
> +	{
> +	  k = i + n;
> +	  a[j] = k;
> +	}
> +      b[i] = k;
> +    }
> +
> +
> +  for (j = 0; j < n; j++)
> +    if (a[j] != i + n - 1)
> +      abort();	
> +
> +  for (i = 0; i < n; i++)
> +    if (b[i] != i + n)
> +      abort();	
> +
> +  return 0;
> +}
> +
> +int main (void)
> +{
> +  main1 (N);
> +  main1 (0);
> +  main1 (1);
> +  main1 (2);
> +  main1 (N-1);
> +
> +  return 0;
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr29581-3.c b/gcc/testsuite/gcc.dg/graphite/pr29581-3.c
> new file mode 100644
> index 0000000..c9d72ce
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr29581-3.c
> @@ -0,0 +1,48 @@
> +/* PR tree-optimization/29581 */
> +/* Origin: gcc.dg/vect/vect-87.c */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +extern void abort (void);
> +
> +#define N 16
> +
> +int main1 (int n, int *a)
> +{
> +  int i, j, k;
> +  int b[N];
> +
> +  for (i = 0; i < n; i++)
> +    {
> +      for (j = 0; j < n; j++)
> +	{
> +	  k = i + n;
> +	  a[j] = k;
> +	}
> +      b[i] = k;
> +    }
> +
> +
> +  for (j = 0; j < n; j++)
> +    if (a[j] != i + n - 1)
> +      abort();	
> +
> +  for (j = 0; j < n; j++)
> +    if (b[j] != j + n)
> +      abort();	
> +
> +  return 0;
> +}
> +
> +int main (void)
> +{
> +  int a[N] __attribute__ ((__aligned__(16)));
> +
> +  main1 (N, a);
> +  main1 (0, a);
> +  main1 (1, a);
> +  main1 (2, a);
> +  main1 (N-1, a);
> +
> +  return 0;
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr29581-4.c b/gcc/testsuite/gcc.dg/graphite/pr29581-4.c
> new file mode 100644
> index 0000000..c2d894c
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr29581-4.c
> @@ -0,0 +1,48 @@
> +/* PR tree-optimization/29581 */
> +/* Origin: gcc.dg/vect/vect-88.c */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +extern void abort (void);
> +
> +#define N 16
> +
> +int main1 (int n, int *a)
> +{
> +  int i, j, k;
> +  int b[N];
> +
> +  for (i = 0; i < n; i++)
> +    {
> +      for (j = 0; j < n; j++)
> +	{
> +	  k = i + n;
> +	  a[j] = k;
> +	}
> +      b[i] = k;
> +    }
> +
> +
> +  for (j = 0; j < n; j++)
> +    if (a[j] != i + n - 1)
> +      abort();	
> +
> +  for (j = 0; j < n; j++)
> +    if (b[j] != j + n)
> +      abort();	
> +
> +  return 0;
> +}
> +
> +int main (void)
> +{
> +  int a[N+1] __attribute__ ((__aligned__(16)));
> +
> +  main1 (N, a+1);
> +  main1 (0, a+1);
> +  main1 (1, a+1);
> +  main1 (2, a+1);
> +  main1 (N-1, a+1);
> +
> +  return 0;
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr30565.c b/gcc/testsuite/gcc.dg/graphite/pr30565.c
> new file mode 100644
> index 0000000..802b7c2
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr30565.c
> @@ -0,0 +1,14 @@
> +/* PR tree-optimization/30565  */
> +
> +/* { dg-do compile } */
> +/* { dg-options "-O1 -ftree-pre -ftree-loop-linear" } */
> +
> +static double snrdef[32];
> +void psycho_n1(double ltmin[2][32], int stereo)
> +{
> +  int i, k;
> +
> +  for (k = 0; k < stereo; k++)
> +    for (i = 0; i < 32; i++)
> +      ltmin[k][i] = snrdef[i];
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr31183.c b/gcc/testsuite/gcc.dg/graphite/pr31183.c
> new file mode 100644
> index 0000000..000d7b5
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr31183.c
> @@ -0,0 +1,14 @@
> +/* { dg-do compile } */ 
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +int buf[256 * 9];
> +int f() 
> +{
> +  int i, j;
> +
> +  for (i = 0; i < 256; ++i)
> +    for (j = 0; j < 8; ++j)
> +      buf[j + 1] = buf[j] + 1;
> +
> +  return buf[10];
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr33576.c b/gcc/testsuite/gcc.dg/graphite/pr33576.c
> new file mode 100644
> index 0000000..2470762
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr33576.c
> @@ -0,0 +1,20 @@
> +/* { dg-do compile } */ 
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +int a1[6][4][4];
> +short b1[16];
> +
> +int c1;
> +void CalculateQuantParam(void)
> +{
> +  int i, j, k, temp;
> +
> +   for(k=0; k<6; k++)
> +      for(j=0; j<4; j++)
> +        for(i=0; i<4; i++)
> +        {
> +          temp = (i<<2)+j;
> +          a1[k][j][i]  = c1/b1[temp];
> +        }
> +}
> +
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr33766.c b/gcc/testsuite/gcc.dg/graphite/pr33766.c
> new file mode 100644
> index 0000000..f6bb506
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr33766.c
> @@ -0,0 +1,19 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +float
> +fxt1_quantize_ALPHA1()
> +{
> +        int j1;
> +        int i;
> +        float *tv;
> +        for (j1 = 1; j1; j1++) {
> +                float e;
> +                for (i = 1; i; i++)
> +                        e = tv[i];
> +                if (e)
> +                        i = j1;
> +        }
> +        return tv[i];
> +}
> +
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr34016.c b/gcc/testsuite/gcc.dg/graphite/pr34016.c
> new file mode 100644
> index 0000000..5ca84bb
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr34016.c
> @@ -0,0 +1,19 @@
> +/* PR tree-optimization/34016 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +extern void bar (double *);
> +
> +void foo (void)
> +{
> +  double gr[36];
> +  int i, j;
> +  for (i = 0; i <= 5; i++)
> +    {
> +      for (j = 0; j <= 5; j++)
> +        gr[i + j * 6] = 0.0;
> +      if (i <= 2)
> +        gr[i + i * 6] = 1.0;
> +    }
> +  bar (gr);
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr34017.c b/gcc/testsuite/gcc.dg/graphite/pr34017.c
> new file mode 100644
> index 0000000..ee279b7
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr34017.c
> @@ -0,0 +1,26 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +extern int s;
> +
> +void
> +foo (int *x, int y, int z)
> +{
> + int m, n;
> + int o;
> + int p = x[0];
> + o = s;
> + for (m = 0; m < s; m++)
> +   for (n = 0; n < s; n++)
> +     {
> +       if (x[n] != p)
> +         continue;
> +       if (m > z)
> +         z = m;
> +       if (n < o)
> +         o = n;
> +     }
> + for (m = y; m <= z; m++)
> +   {
> +   }
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr34123.c b/gcc/testsuite/gcc.dg/graphite/pr34123.c
> new file mode 100644
> index 0000000..81dbf3a
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr34123.c
> @@ -0,0 +1,18 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -ftree-loop-linear" } */
> +
> +/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
> +
> +static unsigned char sbox[256] = {
> +};
> +void MD2Transform (unsigned char state[16])
> +{
> +  unsigned char t = 0;
> +  int i, j;
> +  for (i = 0; i < 16; i++)
> +    {
> +      for (j = 0; j < 2; j++)
> +        t = (state[j] ^= sbox[t]);
> +      t += i;
> +    }
> +}
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr36287.c b/gcc/testsuite/gcc.dg/graphite/pr36287.c
> new file mode 100644
> index 0000000..51b77c7
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr36287.c
> @@ -0,0 +1,22 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O -ftree-loop-linear" } */
> +
> +int tab[2][2];
> +
> +int foo ()
> +{
> +  int i, j, k;
> +
> +  for (i = 0; i < 2; ++i)
> +    for (j = 0; j < 2; ++j)
> +      for (k = 0; k < 2; ++k) 
> +	{}
> +
> +  for (i = 0; i < 2; ++i)
> +    for (j = 0; j < 2; ++j)
> +      if (i == 0)
> +	tab[i][j] = 0;
> +
> +  return tab[0][1];
> +}
> +
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr37686.c b/gcc/testsuite/gcc.dg/graphite/pr37686.c
> new file mode 100644
> index 0000000..a5094bf
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr37686.c
> @@ -0,0 +1,48 @@
> +/* { dg-do compile { target powerpc*-*-* } } */
> +/* { dg-options "-O3 -ftree-loop-linear" } */
> +
> +unsigned char inUse[256];
> +unsigned char len[6][258];
> +int code[6][258];
> +unsigned int crc32Table[256] = { };
> +  unsigned int getGlobalCRC (void) { }
> +  int bsLive;
> +void bsW (int n, unsigned int v) {
> + while (bsLive >= 8) {}
> + }
> + void hbAssignCodes (int * code,         unsigned char * length, int minLen,
> +int maxLen, int alphaSize) {
> +   int n, vec, i;
> +   for (n = minLen;n <= maxLen;n++)
> +       for (i = 0; i < alphaSize;i++)
> +      code[i] = vec;
> +   }
> +  void sendMTFValues (void) {
> +   int v, t, i, j, gs, ge, totc, bt, bc, iter;
> +   int nSelectors, alphaSize, minLen, maxLen, selCtr;
> +   int nGroups, nBytes;
> + {
> +    while (1)
> +  {
> +  break;
> +  }
> +       hbAssignCodes (&code[t][0], &len[t][0], minLen, maxLen, alphaSize);
> +     unsigned char inUse16[16];
> +     for (i = 0;i < 16;i++)
> + if (inUse16[i])
> +  {
> +      for (j = 0;j < 16;j++)
> +   if (inUse[i * 16 + j])    { }
> +    }
> +   }
> +   for (i = 0; i < nSelectors;i++)     { }
> +   for (t = 0; t < nGroups;t++)
> + {
> +       int curr = len[t][0];
> +       for (i = 0; i < alphaSize;i++)
> +          while (curr < len[t][i])     { }
> +     }
> +   while (1)
> +       for (i = gs; i <= ge;i++)  { }
> + }
> +
> diff --git a/gcc/testsuite/gcc.dg/graphite/pr42917.c b/gcc/testsuite/gcc.dg/graphite/pr42917.c
> new file mode 100644
> index 0000000..eddff3b
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/graphite/pr42917.c
> @@ -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/pr18792.c b/gcc/testsuite/gcc.dg/pr18792.c
> deleted file mode 100644
> index 4e93fe1..0000000
> --- a/gcc/testsuite/gcc.dg/pr18792.c
> +++ /dev/null
> @@ -1,16 +0,0 @@
> -/* PR tree-optimization/18792 */
> -/* { dg-do compile } */
> -/* { dg-options "-O1 -ftree-loop-linear" } */
> -void put_atoms_in_triclinic_unitcell(float x[][3])
> -{
> -	int i=0,d;
> -
> -	while (x[i][3] < 0)
> -		for (d=0; d<=3; d++)
> -			x[i][d] = 0;
> -
> -	while (x[i][3] >= 0)
> -		for (d=0; d<=3; d++)
> -			x[i][d] = 0;
> -
> -}
> diff --git a/gcc/testsuite/gcc.dg/pr19910.c b/gcc/testsuite/gcc.dg/pr19910.c
> deleted file mode 100644
> index 1ee0d21..0000000
> --- a/gcc/testsuite/gcc.dg/pr19910.c
> +++ /dev/null
> @@ -1,16 +0,0 @@
> -/* Contributed by Volker Reichelt <reichelt@gcc.gnu.org>.  */
> -
> -/* { dg-do compile } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -int a[3];
> -
> -void foo()
> -{
> -  int i, j;
> -
> -  for (i = 1; i >= 0; --i)
> -    for (j = i; j >= 0; --j)
> -      a[i+j] = 0;
> -}
> -
> diff --git a/gcc/testsuite/gcc.dg/pr23625.c b/gcc/testsuite/gcc.dg/pr23625.c
> deleted file mode 100644
> index aaeddb2..0000000
> --- a/gcc/testsuite/gcc.dg/pr23625.c
> +++ /dev/null
> @@ -1,27 +0,0 @@
> -/* Test case for PR23625 */
> -/* { dg-do compile } */
> -/* { dg-options "-O2 -ftree-vectorize -ftree-loop-linear" } */
> -
> -typedef long INT32;
> -void find_best_colors ()
> -{
> -int ic0, ic1, ic2;
> -INT32 * bptr;
> -INT32 dist1;
> -INT32 dist2;
> -INT32 xx1;
> -for (ic0 = (1<<(5 -3))-1;ic0 >= 0;ic0--)
> -{
> -  for (ic1 = (1<<(6 -3))-1;ic1 >= 0;ic1--)
> -  {
> -    dist2 = dist1;
> -     for (ic2 = (1<<(5 -3))-1;ic2 >= 0;ic2--)
> -     {
> -        *bptr = dist2;
> -        bptr++;
> -     }
> -     dist1 += xx1;
> -  }
> -}
> -}
> -
> diff --git a/gcc/testsuite/gcc.dg/pr29330.c b/gcc/testsuite/gcc.dg/pr29330.c
> deleted file mode 100644
> index dff4207..0000000
> --- a/gcc/testsuite/gcc.dg/pr29330.c
> +++ /dev/null
> @@ -1,15 +0,0 @@
> -/* PR tree-optimization/29330 */
> -/* { dg-do compile } */
> -/* { dg-options "-O -ftree-loop-linear -std=gnu99" } */
> -
> -int buf[2][2][2][2];
> -
> -void
> -f (void)
> -{
> -  for (int a = 0; a < 2; ++a)
> -    for (int b = 0; b < 2; ++b)
> -      for (int c = 0; c < 2; ++c)
> -	for (int d = 0; d < 2; ++d)
> -	  buf[a][b][c][d] = 0;
> -}
> diff --git a/gcc/testsuite/gcc.dg/pr29581-1.c b/gcc/testsuite/gcc.dg/pr29581-1.c
> deleted file mode 100644
> index e540073..0000000
> --- a/gcc/testsuite/gcc.dg/pr29581-1.c
> +++ /dev/null
> @@ -1,44 +0,0 @@
> -/* PR tree-optimization/29581 */
> -/* Origin: gcc.dg/vect/vect-85.c */
> -/* { dg-do run } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -extern void abort (void);
> -
> -#define N 16
> -
> -int main1 (int *a)
> -{
> -  int i, j, k;
> -  int b[N];
> -
> -  for (i = 0; i < N; i++)
> -    {
> -      for (j = 0; j < N; j++)
> -	{
> -	  k = i + N;
> -	  a[j] = k;
> -	}
> -      b[i] = k;
> -    }
> -
> -
> -  for (j = 0; j < N; j++)
> -    if (a[j] != i + N - 1)
> -      abort();	
> -
> -  for (j = 0; j < N; j++)
> -    if (b[j] != j + N)
> -      abort();	
> -
> -  return 0;
> -}
> -
> -int main (void)
> -{
> -  int a[N] __attribute__ ((__aligned__(16)));
> -
> -  main1 (a);
> -
> -  return 0;
> -}
> diff --git a/gcc/testsuite/gcc.dg/pr29581-2.c b/gcc/testsuite/gcc.dg/pr29581-2.c
> deleted file mode 100644
> index c99d78c..0000000
> --- a/gcc/testsuite/gcc.dg/pr29581-2.c
> +++ /dev/null
> @@ -1,46 +0,0 @@
> -/* PR tree-optimization/29581 */
> -/* Origin: gcc.dg/vect/vect-86.c */
> -/* { dg-do run } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -extern void abort (void);
> -
> -#define N 16
> -
> -int main1 (int n)
> -{
> -  int i, j, k;
> -  int a[N], b[N];
> -
> -  for (i = 0; i < n; i++)
> -    {
> -      for (j = 0; j < n; j++)
> -	{
> -	  k = i + n;
> -	  a[j] = k;
> -	}
> -      b[i] = k;
> -    }
> -
> -
> -  for (j = 0; j < n; j++)
> -    if (a[j] != i + n - 1)
> -      abort();	
> -
> -  for (i = 0; i < n; i++)
> -    if (b[i] != i + n)
> -      abort();	
> -
> -  return 0;
> -}
> -
> -int main (void)
> -{
> -  main1 (N);
> -  main1 (0);
> -  main1 (1);
> -  main1 (2);
> -  main1 (N-1);
> -
> -  return 0;
> -}
> diff --git a/gcc/testsuite/gcc.dg/pr29581-3.c b/gcc/testsuite/gcc.dg/pr29581-3.c
> deleted file mode 100644
> index c9d72ce..0000000
> --- a/gcc/testsuite/gcc.dg/pr29581-3.c
> +++ /dev/null
> @@ -1,48 +0,0 @@
> -/* PR tree-optimization/29581 */
> -/* Origin: gcc.dg/vect/vect-87.c */
> -/* { dg-do run } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -extern void abort (void);
> -
> -#define N 16
> -
> -int main1 (int n, int *a)
> -{
> -  int i, j, k;
> -  int b[N];
> -
> -  for (i = 0; i < n; i++)
> -    {
> -      for (j = 0; j < n; j++)
> -	{
> -	  k = i + n;
> -	  a[j] = k;
> -	}
> -      b[i] = k;
> -    }
> -
> -
> -  for (j = 0; j < n; j++)
> -    if (a[j] != i + n - 1)
> -      abort();	
> -
> -  for (j = 0; j < n; j++)
> -    if (b[j] != j + n)
> -      abort();	
> -
> -  return 0;
> -}
> -
> -int main (void)
> -{
> -  int a[N] __attribute__ ((__aligned__(16)));
> -
> -  main1 (N, a);
> -  main1 (0, a);
> -  main1 (1, a);
> -  main1 (2, a);
> -  main1 (N-1, a);
> -
> -  return 0;
> -}
> diff --git a/gcc/testsuite/gcc.dg/pr29581-4.c b/gcc/testsuite/gcc.dg/pr29581-4.c
> deleted file mode 100644
> index c2d894c..0000000
> --- a/gcc/testsuite/gcc.dg/pr29581-4.c
> +++ /dev/null
> @@ -1,48 +0,0 @@
> -/* PR tree-optimization/29581 */
> -/* Origin: gcc.dg/vect/vect-88.c */
> -/* { dg-do run } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -extern void abort (void);
> -
> -#define N 16
> -
> -int main1 (int n, int *a)
> -{
> -  int i, j, k;
> -  int b[N];
> -
> -  for (i = 0; i < n; i++)
> -    {
> -      for (j = 0; j < n; j++)
> -	{
> -	  k = i + n;
> -	  a[j] = k;
> -	}
> -      b[i] = k;
> -    }
> -
> -
> -  for (j = 0; j < n; j++)
> -    if (a[j] != i + n - 1)
> -      abort();	
> -
> -  for (j = 0; j < n; j++)
> -    if (b[j] != j + n)
> -      abort();	
> -
> -  return 0;
> -}
> -
> -int main (void)
> -{
> -  int a[N+1] __attribute__ ((__aligned__(16)));
> -
> -  main1 (N, a+1);
> -  main1 (0, a+1);
> -  main1 (1, a+1);
> -  main1 (2, a+1);
> -  main1 (N-1, a+1);
> -
> -  return 0;
> -}
> diff --git a/gcc/testsuite/gcc.dg/pr34016.c b/gcc/testsuite/gcc.dg/pr34016.c
> deleted file mode 100644
> index 5ca84bb..0000000
> --- a/gcc/testsuite/gcc.dg/pr34016.c
> +++ /dev/null
> @@ -1,19 +0,0 @@
> -/* PR tree-optimization/34016 */
> -/* { dg-do compile } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -extern void bar (double *);
> -
> -void foo (void)
> -{
> -  double gr[36];
> -  int i, j;
> -  for (i = 0; i <= 5; i++)
> -    {
> -      for (j = 0; j <= 5; j++)
> -        gr[i + j * 6] = 0.0;
> -      if (i <= 2)
> -        gr[i + i * 6] = 1.0;
> -    }
> -  bar (gr);
> -}
> diff --git a/gcc/testsuite/gcc.dg/pr42917.c b/gcc/testsuite/gcc.dg/pr42917.c
> deleted file mode 100644
> index d8db32e..0000000
> --- a/gcc/testsuite/gcc.dg/pr42917.c
> +++ /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/20041110-1.c b/gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c
> deleted file mode 100644
> index 825b2b4..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c
> +++ /dev/null
> @@ -1,26 +0,0 @@
> -/* { dg-do compile } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -/* This testcase was causing an ICE in building distance vectors because
> -   we weren't ignoring the fact that one of the induction variables
> -   involved in the dependence was outside of the loop.  */
> -extern int foo (int, int);
> -int
> -main (void)
> -{
> -  int a[50];
> -  int b[50];
> -  int i, j, k;
> -  for (i = 4; i < 30; i++)
> -    {
> -      for (j = 3; j < 40; j++)
> -	{
> -	  for (k = 9; k < 50; k++)
> -	    {
> -	      b[j] = a[i];
> -	      a[k] = b[i];
> -	    }
> -	}
> -    }
> -  foo (a[i], b[i]);
> -}
> 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
> index 12e42b7..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c
> +++ /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/loop-27.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-27.c
> deleted file mode 100644
> index 802b7c2..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/loop-27.c
> +++ /dev/null
> @@ -1,14 +0,0 @@
> -/* PR tree-optimization/30565  */
> -
> -/* { dg-do compile } */
> -/* { dg-options "-O1 -ftree-pre -ftree-loop-linear" } */
> -
> -static double snrdef[32];
> -void psycho_n1(double ltmin[2][32], int stereo)
> -{
> -  int i, k;
> -
> -  for (k = 0; k < stereo; k++)
> -    for (i = 0; i < 32; i++)
> -      ltmin[k][i] = snrdef[i];
> -}
> 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
> index bff58f6..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c
> +++ /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
> index 9548bf2..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c
> +++ /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
> index d7dd211..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c
> +++ /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
> index 6682538..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c
> +++ /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
> index 3540723..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c
> +++ /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
> index e6a290a..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c
> +++ /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
> index 67569d8..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c
> +++ /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/gcc.dg/tree-ssa/pr20256.c b/gcc/testsuite/gcc.dg/tree-ssa/pr20256.c
> deleted file mode 100644
> index aa482ed..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr20256.c
> +++ /dev/null
> @@ -1,25 +0,0 @@
> -/* { dg-do compile } */ 
> -/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
> -/* { dg-require-effective-target size32plus } */
> -
> -int foo()
> -{
> -  int x[2][2], y[2];
> -  int i, n, s;
> -
> -  /* This is a reduction: there is a scalar dependence that cannot be
> -     removed by rewriting IVs.  This code cannot and should not be
> -     transformed into a perfect loop.  */
> -  for (n = 0; n < 2; n++)
> -    {
> -      s = 0;
> -      for (i = 0; i < 2; i++)
> -        s += x[n][i]*y[i];
> -      s += 1;
> -    }
> -
> -  return s;
> -}
> -
> -/* { 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/tree-ssa/pr23820.c b/gcc/testsuite/gcc.dg/tree-ssa/pr23820.c
> deleted file mode 100644
> index ee855e1..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr23820.c
> +++ /dev/null
> @@ -1,26 +0,0 @@
> -/* { dg-do compile } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -int t [2][4];
> -
> -void foo (void)
> -{
> -  int i, j, k, v;
> -  float e;
> -  for (;;)
> -    {
> -      v = 0;
> -      for (j = 0; j < 2; j ++)
> -        {
> -          for (k = 2; k < 4; k ++)
> -            {
> -              e = 0.0;
> -              for (i = 0; i < 4; i ++)
> -                e += t [j][i];
> -              if (e)
> -                v = j;
> -            }
> -        }
> -      t [v][0] = 0;
> -    }
> -}
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c b/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c
> deleted file mode 100644
> index b50e7a8..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c
> +++ /dev/null
> @@ -1,18 +0,0 @@
> -/* { dg-do compile } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -float weight[10];
> -void lsp_weight_quant(float *x, char *cdbk)
> -{
> -   int i,j;
> -   float dist;
> -   int best_id=0;
> -   for (i=0;i<16;i++)
> -   {
> -      for (j=0;j<10;j++)
> -         dist=dist+weight[j];
> -      if (dist<0)
> -         best_id=i;
> -   }
> -   x[j] = cdbk[best_id*10+j];
> -}
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c b/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c
> deleted file mode 100644
> index 907c5d2..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -/* { dg-do compile } */ 
> -/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
> -/* { dg-require-effective-target size32plus } */
> -
> -int foo(int *p, int n)
> -{
> -  int i, j, k = 0;
> -
> -  /* This is a reduction: there is a scalar dependence that cannot be
> -     removed by rewriting IVs.  This code cannot and should not be
> -     transformed into a perfect loop.  */
> -  for (i = 0; i < 2; ++i, p += n)
> -    for (j = 0; j < 2; ++j)
> -      k += p[j];
> -
> -  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/tree-ssa/pr31183.c b/gcc/testsuite/gcc.dg/tree-ssa/pr31183.c
> deleted file mode 100644
> index 000d7b5..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr31183.c
> +++ /dev/null
> @@ -1,14 +0,0 @@
> -/* { dg-do compile } */ 
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -int buf[256 * 9];
> -int f() 
> -{
> -  int i, j;
> -
> -  for (i = 0; i < 256; ++i)
> -    for (j = 0; j < 8; ++j)
> -      buf[j + 1] = buf[j] + 1;
> -
> -  return buf[10];
> -}
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c b/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c
> deleted file mode 100644
> index 2470762..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -/* { dg-do compile } */ 
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -int a1[6][4][4];
> -short b1[16];
> -
> -int c1;
> -void CalculateQuantParam(void)
> -{
> -  int i, j, k, temp;
> -
> -   for(k=0; k<6; k++)
> -      for(j=0; j<4; j++)
> -        for(i=0; i<4; i++)
> -        {
> -          temp = (i<<2)+j;
> -          a1[k][j][i]  = c1/b1[temp];
> -        }
> -}
> -
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c b/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c
> deleted file mode 100644
> index f6bb506..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c
> +++ /dev/null
> @@ -1,19 +0,0 @@
> -/* { dg-do compile } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -float
> -fxt1_quantize_ALPHA1()
> -{
> -        int j1;
> -        int i;
> -        float *tv;
> -        for (j1 = 1; j1; j1++) {
> -                float e;
> -                for (i = 1; i; i++)
> -                        e = tv[i];
> -                if (e)
> -                        i = j1;
> -        }
> -        return tv[i];
> -}
> -
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c b/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c
> deleted file mode 100644
> index ee279b7..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c
> +++ /dev/null
> @@ -1,26 +0,0 @@
> -/* { dg-do compile } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -extern int s;
> -
> -void
> -foo (int *x, int y, int z)
> -{
> - int m, n;
> - int o;
> - int p = x[0];
> - o = s;
> - for (m = 0; m < s; m++)
> -   for (n = 0; n < s; n++)
> -     {
> -       if (x[n] != p)
> -         continue;
> -       if (m > z)
> -         z = m;
> -       if (n < o)
> -         o = n;
> -     }
> - for (m = y; m <= z; m++)
> -   {
> -   }
> -}
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c b/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c
> deleted file mode 100644
> index 81dbf3a..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c
> +++ /dev/null
> @@ -1,18 +0,0 @@
> -/* { dg-do compile } */
> -/* { dg-options "-O2 -ftree-loop-linear" } */
> -
> -/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
> -
> -static unsigned char sbox[256] = {
> -};
> -void MD2Transform (unsigned char state[16])
> -{
> -  unsigned char t = 0;
> -  int i, j;
> -  for (i = 0; i < 16; i++)
> -    {
> -      for (j = 0; j < 2; j++)
> -        t = (state[j] ^= sbox[t]);
> -      t += i;
> -    }
> -}
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c b/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c
> deleted file mode 100644
> index 51b77c7..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c
> +++ /dev/null
> @@ -1,22 +0,0 @@
> -/* { dg-do compile } */
> -/* { dg-options "-O -ftree-loop-linear" } */
> -
> -int tab[2][2];
> -
> -int foo ()
> -{
> -  int i, j, k;
> -
> -  for (i = 0; i < 2; ++i)
> -    for (j = 0; j < 2; ++j)
> -      for (k = 0; k < 2; ++k) 
> -	{}
> -
> -  for (i = 0; i < 2; ++i)
> -    for (j = 0; j < 2; ++j)
> -      if (i == 0)
> -	tab[i][j] = 0;
> -
> -  return tab[0][1];
> -}
> -
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c b/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c
> deleted file mode 100644
> index a5094bf..0000000
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c
> +++ /dev/null
> @@ -1,48 +0,0 @@
> -/* { dg-do compile { target powerpc*-*-* } } */
> -/* { dg-options "-O3 -ftree-loop-linear" } */
> -
> -unsigned char inUse[256];
> -unsigned char len[6][258];
> -int code[6][258];
> -unsigned int crc32Table[256] = { };
> -  unsigned int getGlobalCRC (void) { }
> -  int bsLive;
> -void bsW (int n, unsigned int v) {
> - while (bsLive >= 8) {}
> - }
> - void hbAssignCodes (int * code,         unsigned char * length, int minLen,
> -int maxLen, int alphaSize) {
> -   int n, vec, i;
> -   for (n = minLen;n <= maxLen;n++)
> -       for (i = 0; i < alphaSize;i++)
> -      code[i] = vec;
> -   }
> -  void sendMTFValues (void) {
> -   int v, t, i, j, gs, ge, totc, bt, bc, iter;
> -   int nSelectors, alphaSize, minLen, maxLen, selCtr;
> -   int nGroups, nBytes;
> - {
> -    while (1)
> -  {
> -  break;
> -  }
> -       hbAssignCodes (&code[t][0], &len[t][0], minLen, maxLen, alphaSize);
> -     unsigned char inUse16[16];
> -     for (i = 0;i < 16;i++)
> - if (inUse16[i])
> -  {
> -      for (j = 0;j < 16;j++)
> -   if (inUse[i * 16 + j])    { }
> -    }
> -   }
> -   for (i = 0; i < nSelectors;i++)     { }
> -   for (t = 0; t < nGroups;t++)
> - {
> -       int curr = len[t][0];
> -       for (i = 0; i < alphaSize;i++)
> -          while (curr < len[t][i])     { }
> -     }
> -   while (1)
> -       for (i = gs; i <= ge;i++)  { }
> - }
> -
> diff --git a/gcc/testsuite/gfortran.dg/graphite/interchange-4.f b/gcc/testsuite/gfortran.dg/graphite/interchange-4.f
> new file mode 100644
> index 0000000..3d42811
> --- /dev/null
> +++ b/gcc/testsuite/gfortran.dg/graphite/interchange-4.f
> @@ -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
> index 0000000..658f10a
> --- /dev/null
> +++ b/gcc/testsuite/gfortran.dg/graphite/interchange-5.f
> @@ -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/graphite/pr29290.f90 b/gcc/testsuite/gfortran.dg/graphite/pr29290.f90
> new file mode 100644
> index 0000000..8968d88
> --- /dev/null
> +++ b/gcc/testsuite/gfortran.dg/graphite/pr29290.f90
> @@ -0,0 +1,9 @@
> +! PR tree-optimization/29290
> +! { dg-do compile }
> +! { dg-options "-O3 -ftree-loop-linear" }
> +
> +subroutine pr29290 (a, b, c, d)
> +  integer c, d
> +  real*8 a(c,c), b(c,c)
> +  a(1:d,1:d) = b(1:d,1:d)
> +end
> diff --git a/gcc/testsuite/gfortran.dg/graphite/pr29581.f90 b/gcc/testsuite/gfortran.dg/graphite/pr29581.f90
> new file mode 100644
> index 0000000..3e4a39e
> --- /dev/null
> +++ b/gcc/testsuite/gfortran.dg/graphite/pr29581.f90
> @@ -0,0 +1,27 @@
> +! PR tree-optimization/29581
> +! { dg-do run }
> +! { dg-options "-O2 -ftree-loop-linear" }
> +
> +      SUBROUTINE FOO (K)
> +      INTEGER I, J, K, A(5,5), B
> +      COMMON A
> +      A(1,1) = 1
> + 10   B = 0
> +      DO 30 I = 1, K
> +        DO 20 J = 1, K
> +          B = B + A(I,J)
> + 20     CONTINUE
> +        A(I,I) = A(I,I) * 2
> + 30   CONTINUE
> +      IF (B.GE.3) RETURN
> +      GO TO 10
> +      END SUBROUTINE
> +
> +      PROGRAM BAR
> +        INTEGER A(5,5)
> +        COMMON A
> +        CALL FOO (2)
> +        IF (A(1,1).NE.8) CALL ABORT
> +        A(1,1) = 0
> +        IF (ANY(A.NE.0)) CALL ABORT
> +      END
> diff --git a/gcc/testsuite/gfortran.dg/graphite/pr36286.f90 b/gcc/testsuite/gfortran.dg/graphite/pr36286.f90
> new file mode 100644
> index 0000000..bcdef08
> --- /dev/null
> +++ b/gcc/testsuite/gfortran.dg/graphite/pr36286.f90
> @@ -0,0 +1,14 @@
> +! { dg-do compile }
> +! { dg-options "-O1 -ftree-loop-linear" }
> +! PR tree-optimization/36286
> +
> +program test_count
> +    integer, dimension(2,3) :: a, b
> +    a = reshape( (/ 1, 3, 5, 2, 4, 6 /), (/ 2, 3 /))
> +    b = reshape( (/ 0, 3, 5, 7, 4, 8 /), (/ 2, 3 /))
> +    print '(3l6)', a.ne.b
> +    print *, a(1,:).ne.b(1,:)
> +    print *, a(2,:).ne.b(2,:)
> +    print *, count(a.ne.b)
> +end program test_count
> +
> diff --git a/gcc/testsuite/gfortran.dg/graphite/pr36922.f b/gcc/testsuite/gfortran.dg/graphite/pr36922.f
> new file mode 100644
> index 0000000..6aa95be
> --- /dev/null
> +++ b/gcc/testsuite/gfortran.dg/graphite/pr36922.f
> @@ -0,0 +1,16 @@
> +C PR tree-optimization/36922
> +C { dg-do compile }
> +C { dg-options "-O2 -ftree-loop-linear" }
> +      SUBROUTINE PR36922(N,F,Z,C)
> +      IMPLICIT DOUBLE PRECISION(A-H,O-Z)
> +      DIMENSION C(23821),Z(0:2*N+1),F(0:2*N)
> +      I=0
> +      DO L=0,N
> +        DO M=0,L
> +          DO M2=M,L
> +            I=I+1
> +            C(I)=F(L+M)*F(L-M)*Z(L-M2)/(F(M2+M)*F(M2-M)*F(L-M2)*F(L-M2))
> +          ENDDO
> +        ENDDO
> +      ENDDO
> +      END
> diff --git a/gcc/testsuite/gfortran.dg/graphite/pr39516.f b/gcc/testsuite/gfortran.dg/graphite/pr39516.f
> new file mode 100644
> index 0000000..3d6104a
> --- /dev/null
> +++ b/gcc/testsuite/gfortran.dg/graphite/pr39516.f
> @@ -0,0 +1,20 @@
> +C PR tree-optimization/39516
> +C { dg-do compile }
> +C { dg-options "-O2 -ftree-loop-linear" }
> +      SUBROUTINE SUB(A, B, M)
> +      IMPLICIT NONE
> +      DOUBLE PRECISION A(20,20), B(20)
> +      INTEGER*8 I, J, K, M
> +      DO I=1,M
> +        DO J=1,M
> +          A(I,J)=A(I,J)+1
> +        END DO
> +      END DO
> +      DO K=1,20
> +        DO I=1,M
> +          DO J=1,M
> +            B(I)=B(I)+A(I,J)
> +          END DO
> +        END DO
> +      END DO
> +      END SUBROUTINE
> diff --git a/gcc/testsuite/gfortran.dg/loop_nest_1.f90 b/gcc/testsuite/gfortran.dg/loop_nest_1.f90
> deleted file mode 100644
> index 8968d88..0000000
> --- a/gcc/testsuite/gfortran.dg/loop_nest_1.f90
> +++ /dev/null
> @@ -1,9 +0,0 @@
> -! PR tree-optimization/29290
> -! { dg-do compile }
> -! { dg-options "-O3 -ftree-loop-linear" }
> -
> -subroutine pr29290 (a, b, c, d)
> -  integer c, d
> -  real*8 a(c,c), b(c,c)
> -  a(1:d,1:d) = b(1:d,1:d)
> -end
> diff --git a/gcc/testsuite/gfortran.dg/ltrans-7.f90 b/gcc/testsuite/gfortran.dg/ltrans-7.f90
> deleted file mode 100644
> index 583edf2..0000000
> --- a/gcc/testsuite/gfortran.dg/ltrans-7.f90
> +++ /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" } }
> diff --git a/gcc/testsuite/gfortran.dg/pr29581.f90 b/gcc/testsuite/gfortran.dg/pr29581.f90
> deleted file mode 100644
> index 3e4a39e..0000000
> --- a/gcc/testsuite/gfortran.dg/pr29581.f90
> +++ /dev/null
> @@ -1,27 +0,0 @@
> -! PR tree-optimization/29581
> -! { dg-do run }
> -! { dg-options "-O2 -ftree-loop-linear" }
> -
> -      SUBROUTINE FOO (K)
> -      INTEGER I, J, K, A(5,5), B
> -      COMMON A
> -      A(1,1) = 1
> - 10   B = 0
> -      DO 30 I = 1, K
> -        DO 20 J = 1, K
> -          B = B + A(I,J)
> - 20     CONTINUE
> -        A(I,I) = A(I,I) * 2
> - 30   CONTINUE
> -      IF (B.GE.3) RETURN
> -      GO TO 10
> -      END SUBROUTINE
> -
> -      PROGRAM BAR
> -        INTEGER A(5,5)
> -        COMMON A
> -        CALL FOO (2)
> -        IF (A(1,1).NE.8) CALL ABORT
> -        A(1,1) = 0
> -        IF (ANY(A.NE.0)) CALL ABORT
> -      END
> diff --git a/gcc/testsuite/gfortran.dg/pr36286.f90 b/gcc/testsuite/gfortran.dg/pr36286.f90
> deleted file mode 100644
> index bcdef08..0000000
> --- a/gcc/testsuite/gfortran.dg/pr36286.f90
> +++ /dev/null
> @@ -1,14 +0,0 @@
> -! { dg-do compile }
> -! { dg-options "-O1 -ftree-loop-linear" }
> -! PR tree-optimization/36286
> -
> -program test_count
> -    integer, dimension(2,3) :: a, b
> -    a = reshape( (/ 1, 3, 5, 2, 4, 6 /), (/ 2, 3 /))
> -    b = reshape( (/ 0, 3, 5, 7, 4, 8 /), (/ 2, 3 /))
> -    print '(3l6)', a.ne.b
> -    print *, a(1,:).ne.b(1,:)
> -    print *, a(2,:).ne.b(2,:)
> -    print *, count(a.ne.b)
> -end program test_count
> -
> diff --git a/gcc/testsuite/gfortran.dg/pr36922.f b/gcc/testsuite/gfortran.dg/pr36922.f
> deleted file mode 100644
> index 6aa95be..0000000
> --- a/gcc/testsuite/gfortran.dg/pr36922.f
> +++ /dev/null
> @@ -1,16 +0,0 @@
> -C PR tree-optimization/36922
> -C { dg-do compile }
> -C { dg-options "-O2 -ftree-loop-linear" }
> -      SUBROUTINE PR36922(N,F,Z,C)
> -      IMPLICIT DOUBLE PRECISION(A-H,O-Z)
> -      DIMENSION C(23821),Z(0:2*N+1),F(0:2*N)
> -      I=0
> -      DO L=0,N
> -        DO M=0,L
> -          DO M2=M,L
> -            I=I+1
> -            C(I)=F(L+M)*F(L-M)*Z(L-M2)/(F(M2+M)*F(M2-M)*F(L-M2)*F(L-M2))
> -          ENDDO
> -        ENDDO
> -      ENDDO
> -      END
> diff --git a/gcc/testsuite/gfortran.dg/pr39516.f b/gcc/testsuite/gfortran.dg/pr39516.f
> deleted file mode 100644
> index 3d6104a..0000000
> --- a/gcc/testsuite/gfortran.dg/pr39516.f
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -C PR tree-optimization/39516
> -C { dg-do compile }
> -C { dg-options "-O2 -ftree-loop-linear" }
> -      SUBROUTINE SUB(A, B, M)
> -      IMPLICIT NONE
> -      DOUBLE PRECISION A(20,20), B(20)
> -      INTEGER*8 I, J, K, M
> -      DO I=1,M
> -        DO J=1,M
> -          A(I,J)=A(I,J)+1
> -        END DO
> -      END DO
> -      DO K=1,20
> -        DO I=1,M
> -          DO J=1,M
> -            B(I)=B(I)+A(I,J)
> -          END DO
> -        END DO
> -      END DO
> -      END SUBROUTINE
> diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
> index ccc0091..7a5fe89 100644
> --- a/gcc/tree-data-ref.c
> +++ b/gcc/tree-data-ref.c
> @@ -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
> diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h
> index 7865576..2e85677 100644
> --- a/gcc/tree-data-ref.h
> +++ b/gcc/tree-data-ref.h
> @@ -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  */
> diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h
> index 682907c..1720859 100644
> --- a/gcc/tree-flow.h
> +++ b/gcc/tree-flow.h
> @@ -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
> index 5b19c17..0000000
> --- a/gcc/tree-loop-linear.c
> +++ /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);
> -}
> diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c
> index 9ece887..1feb028 100644
> --- a/gcc/tree-parloops.c
> +++ b/gcc/tree-parloops.c
> @@ -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
> diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
> index a87a770..c614861 100644
> --- a/gcc/tree-pass.h
> +++ b/gcc/tree-pass.h
> @@ -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
> @@ -428,7 +428,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;
> diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c
> index d1d7142..149358d 100644
> --- a/gcc/tree-ssa-loop.c
> +++ b/gcc/tree-ssa-loop.c
> @@ -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,6 +266,7 @@ 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
> @@ -312,6 +274,10 @@ gate_graphite_transforms (void)
>        || flag_graphite_opencl)
>      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;
>  }
>  
>
Sebastian Pop - Jan. 25, 2011, 3:09 p.m.
On Tue, Jan 25, 2011 at 05:45, Richard Guenther <rguenther@suse.de> wrote:
> This is ok.  Are the graphite tests always run, that is, at least
> build and run without -fgraphite if that is disabled?  If not,

The tests in g*.dg/graphite/ are not run if graphite is not enabled:
here is the check in graphite.exp

if ![check_effective_target_fgraphite] {
  return
}

> can you make sure to move/duplicate all testcases that were dg-run
> to gcc.dg/torture/?

Ok, I will do that.
Sebastian Pop - Jan. 25, 2011, 6:37 p.m.
On Tue, Jan 25, 2011 at 09:09, Sebastian Pop <sebpop@gmail.com> wrote:
>> can you make sure to move/duplicate all testcases that were dg-run
>> to gcc.dg/torture/?
>
> Ok, I will do that.
>

I see no "dg-do run" comments in all the lambda testsuite files
that I moved to the graphite testsuite.

Sebastian
Jakub Jelinek - Jan. 25, 2011, 6:52 p.m.
On Tue, Jan 25, 2011 at 12:37:09PM -0600, Sebastian Pop wrote:
> On Tue, Jan 25, 2011 at 09:09, Sebastian Pop <sebpop@gmail.com> wrote:
> >> can you make sure to move/duplicate all testcases that were dg-run
> >> to gcc.dg/torture/?
> >
> > Ok, I will do that.
> >
> 
> I see no "dg-do run" comments in all the lambda testsuite files
> that I moved to the graphite testsuite.

*pr29581*.{c,f90} are dg-do run tests for -ftree-loop-linear.
That said, one of the reasons why -ftree-loop-linear was so undertested
is probably because it didn't have other runtime testcases, so if possible
it would be nice if most of the linear tests were actually turned also into
additional dg-do run testcases too.

	Jakub
Sebastian Pop - Jan. 25, 2011, 7:04 p.m.
On Tue, Jan 25, 2011 at 12:52, Jakub Jelinek <jakub@redhat.com> wrote:
> *pr29581*.{c,f90} are dg-do run tests for -ftree-loop-linear.

Ok, I will have a look at these.

> That said, one of the reasons why -ftree-loop-linear was so undertested
> is probably because it didn't have other runtime testcases, so if possible
> it would be nice if most of the linear tests were actually turned also into
> additional dg-do run testcases too.

ltrans-*.c are now called interchange-*.c and each of the interchange-*.c
files has a runtime test.

Sebastian
Sebastian Pop - Jan. 25, 2011, 7:14 p.m.
On Tue, Jan 25, 2011 at 13:04, Sebastian Pop <sebpop@gmail.com> wrote:
> On Tue, Jan 25, 2011 at 12:52, Jakub Jelinek <jakub@redhat.com> wrote:
>> *pr29581*.{c,f90} are dg-do run tests for -ftree-loop-linear.
>
> Ok, I will have a look at these.

The *pr29581*.c files have a note saying:
/* Origin: gcc.dg/vect/vect-85.c */
/* Origin: gcc.dg/vect/vect-86.c */
/* Origin: gcc.dg/vect/vect-87.c */
/* Origin: gcc.dg/vect/vect-88.c */

So these are already run during vect.exp.
I do not think we have to duplicate these testcases in gcc.c-torture/execute/
Richard Guenther - Jan. 26, 2011, 10:23 a.m.
On Tue, 25 Jan 2011, Sebastian Pop wrote:

> On Tue, Jan 25, 2011 at 13:04, Sebastian Pop <sebpop@gmail.com> wrote:
> > On Tue, Jan 25, 2011 at 12:52, Jakub Jelinek <jakub@redhat.com> wrote:
> >> *pr29581*.{c,f90} are dg-do run tests for -ftree-loop-linear.
> >
> > Ok, I will have a look at these.
> 
> The *pr29581*.c files have a note saying:
> /* Origin: gcc.dg/vect/vect-85.c */
> /* Origin: gcc.dg/vect/vect-86.c */
> /* Origin: gcc.dg/vect/vect-87.c */
> /* Origin: gcc.dg/vect/vect-88.c */
> 
> So these are already run during vect.exp.
> I do not think we have to duplicate these testcases in gcc.c-torture/execute/

Sounds reasonable.

Richard.
Andreas Schwab - Jan. 26, 2011, 6:40 p.m.
Sebastian Pop <sebpop@gmail.com> writes:

> diff --git a/gcc/hwint.h b/gcc/hwint.h
> index 8bd7c5e..1eadd45 100644
> --- a/gcc/hwint.h
> +++ b/gcc/hwint.h
> @@ -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);

In file included from ../../gcc/system.h:254:0,
                 from ../../gcc/ada/targext.c:36:
../../gcc/hwint.h: In function 'gcd':
../../gcc/hwint.h:239:3: error: implicit declaration of function 'abs' [-Werror=implicit-function-declaration]
cc1: all warnings being treated as errors

make[3]: *** [ada/targext.o] Error 1

Andreas.

Patch

diff --git a/ChangeLog.graphite b/ChangeLog.graphite
index 987aefa..7b319b3 100644
--- a/ChangeLog.graphite
+++ b/ChangeLog.graphite
@@ -1,3 +1,7 @@ 
+2011-01-17  Sebastian Pop  <sebastian.pop@amd.com>
+
+	* MAINTAINERS (linear loop transforms): Removed.
+
 2011-01-15  Sebastian Pop  <sebastian.pop@amd.com>
 
 	* configure: Regenerated.
diff --git a/MAINTAINERS b/MAINTAINERS
index 5295978..0e1013c 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -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
diff --git a/gcc/ChangeLog.graphite b/gcc/ChangeLog.graphite
index 6b25988..e20e034 100644
--- a/gcc/ChangeLog.graphite
+++ b/gcc/ChangeLog.graphite
@@ -1,5 +1,112 @@ 
 2011-01-17  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.
+
+	* 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-17  Sebastian Pop  <sebastian.pop@amd.com>
+
 	* graphite-sese-to-poly.c (close_phi_written_to_memory): Also allow
 	VAR_DECL, PARM_DECL, and RESULT_DECL.
 
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index cde1ef2..1d4b6a4 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -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
@@ -1281,9 +1280,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 \
@@ -1382,7 +1378,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 \
@@ -2334,7 +2329,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) \
@@ -2726,7 +2721,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) \
@@ -2741,7 +2736,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) \
@@ -2757,8 +2752,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 \
@@ -3473,12 +3466,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)
diff --git a/gcc/hwint.h b/gcc/hwint.h
index 8bd7c5e..1eadd45 100644
--- a/gcc/hwint.h
+++ b/gcc/hwint.h
@@ -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
index f462071..0000000
--- a/gcc/lambda-code.c
+++ /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
index 33b33ef..0000000
--- a/gcc/lambda-mat.c
+++ /dev/null
@@ -1,607 +0,0 @@ 
-/* Integer matrix math routines
-   Copyright (C) 2003, 2004, 2005, 2007, 2008 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
index 22f30b0..0000000
--- a/gcc/lambda-trans.c
+++ /dev/null
@@ -1,80 +0,0 @@ 
-/* Lambda matrix transformations.
-   Copyright (C) 2003, 2004, 2007, 2008 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
index d54ed27..0000000
--- a/gcc/lambda.h
+++ /dev/null
@@ -1,524 +0,0 @@ 
-/* Lambda matrix and vector interface.
-   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
-   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  */
diff --git a/gcc/lto-symtab.c b/gcc/lto-symtab.c
index b331d5c..7573276 100644
--- a/gcc/lto-symtab.c
+++ b/gcc/lto-symtab.c
@@ -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"
diff --git a/gcc/omega.c b/gcc/omega.c
index aee99e7..1717f8e 100644
--- a/gcc/omega.c
+++ b/gcc/omega.c
@@ -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.  */
 
diff --git a/gcc/passes.c b/gcc/passes.c
index 4be61a9..eaf65c4 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -882,7 +882,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);
 	    {
diff --git a/gcc/testsuite/gcc.dg/graphite/pr18792.c b/gcc/testsuite/gcc.dg/graphite/pr18792.c
new file mode 100644
index 0000000..4e93fe1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr18792.c
@@ -0,0 +1,16 @@ 
+/* PR tree-optimization/18792 */
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-loop-linear" } */
+void put_atoms_in_triclinic_unitcell(float x[][3])
+{
+	int i=0,d;
+
+	while (x[i][3] < 0)
+		for (d=0; d<=3; d++)
+			x[i][d] = 0;
+
+	while (x[i][3] >= 0)
+		for (d=0; d<=3; d++)
+			x[i][d] = 0;
+
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr19910.c b/gcc/testsuite/gcc.dg/graphite/pr19910.c
new file mode 100644
index 0000000..1ee0d21
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr19910.c
@@ -0,0 +1,16 @@ 
+/* Contributed by Volker Reichelt <reichelt@gcc.gnu.org>.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+int a[3];
+
+void foo()
+{
+  int i, j;
+
+  for (i = 1; i >= 0; --i)
+    for (j = i; j >= 0; --j)
+      a[i+j] = 0;
+}
+
diff --git a/gcc/testsuite/gcc.dg/graphite/pr20041110-1.c b/gcc/testsuite/gcc.dg/graphite/pr20041110-1.c
new file mode 100644
index 0000000..825b2b4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr20041110-1.c
@@ -0,0 +1,26 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+/* This testcase was causing an ICE in building distance vectors because
+   we weren't ignoring the fact that one of the induction variables
+   involved in the dependence was outside of the loop.  */
+extern int foo (int, int);
+int
+main (void)
+{
+  int a[50];
+  int b[50];
+  int i, j, k;
+  for (i = 4; i < 30; i++)
+    {
+      for (j = 3; j < 40; j++)
+	{
+	  for (k = 9; k < 50; k++)
+	    {
+	      b[j] = a[i];
+	      a[k] = b[i];
+	    }
+	}
+    }
+  foo (a[i], b[i]);
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr20256.c b/gcc/testsuite/gcc.dg/graphite/pr20256.c
new file mode 100644
index 0000000..c181fcb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr20256.c
@@ -0,0 +1,23 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+/* { dg-require-effective-target size32plus } */
+
+int foo()
+{
+  int x[2][2], y[2];
+  int i, n, s;
+
+  /* This is a reduction: there is a scalar dependence that cannot be
+     removed by rewriting IVs.  This code cannot and should not be
+     transformed into a perfect loop.  */
+  for (n = 0; n < 2; n++)
+    {
+      s = 0;
+      for (i = 0; i < 2; i++)
+        s += x[n][i]*y[i];
+      s += 1;
+    }
+
+  return s;
+}
+
diff --git a/gcc/testsuite/gcc.dg/graphite/pr23625.c b/gcc/testsuite/gcc.dg/graphite/pr23625.c
new file mode 100644
index 0000000..aaeddb2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr23625.c
@@ -0,0 +1,27 @@ 
+/* Test case for PR23625 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-loop-linear" } */
+
+typedef long INT32;
+void find_best_colors ()
+{
+int ic0, ic1, ic2;
+INT32 * bptr;
+INT32 dist1;
+INT32 dist2;
+INT32 xx1;
+for (ic0 = (1<<(5 -3))-1;ic0 >= 0;ic0--)
+{
+  for (ic1 = (1<<(6 -3))-1;ic1 >= 0;ic1--)
+  {
+    dist2 = dist1;
+     for (ic2 = (1<<(5 -3))-1;ic2 >= 0;ic2--)
+     {
+        *bptr = dist2;
+        bptr++;
+     }
+     dist1 += xx1;
+  }
+}
+}
+
diff --git a/gcc/testsuite/gcc.dg/graphite/pr23820.c b/gcc/testsuite/gcc.dg/graphite/pr23820.c
new file mode 100644
index 0000000..ee855e1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr23820.c
@@ -0,0 +1,26 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+int t [2][4];
+
+void foo (void)
+{
+  int i, j, k, v;
+  float e;
+  for (;;)
+    {
+      v = 0;
+      for (j = 0; j < 2; j ++)
+        {
+          for (k = 2; k < 4; k ++)
+            {
+              e = 0.0;
+              for (i = 0; i < 4; i ++)
+                e += t [j][i];
+              if (e)
+                v = j;
+            }
+        }
+      t [v][0] = 0;
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr24309.c b/gcc/testsuite/gcc.dg/graphite/pr24309.c
new file mode 100644
index 0000000..b50e7a8
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr24309.c
@@ -0,0 +1,18 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+float weight[10];
+void lsp_weight_quant(float *x, char *cdbk)
+{
+   int i,j;
+   float dist;
+   int best_id=0;
+   for (i=0;i<16;i++)
+   {
+      for (j=0;j<10;j++)
+         dist=dist+weight[j];
+      if (dist<0)
+         best_id=i;
+   }
+   x[j] = cdbk[best_id*10+j];
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr26435.c b/gcc/testsuite/gcc.dg/graphite/pr26435.c
new file mode 100644
index 0000000..4e5e5f7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr26435.c
@@ -0,0 +1,17 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+/* { dg-require-effective-target size32plus } */
+
+int foo(int *p, int n)
+{
+  int i, j, k = 0;
+
+  /* This is a reduction: there is a scalar dependence that cannot be
+     removed by rewriting IVs.  This code cannot and should not be
+     transformed into a perfect loop.  */
+  for (i = 0; i < 2; ++i, p += n)
+    for (j = 0; j < 2; ++j)
+      k += p[j];
+
+  return k;
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr29330.c b/gcc/testsuite/gcc.dg/graphite/pr29330.c
new file mode 100644
index 0000000..dff4207
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr29330.c
@@ -0,0 +1,15 @@ 
+/* PR tree-optimization/29330 */
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-loop-linear -std=gnu99" } */
+
+int buf[2][2][2][2];
+
+void
+f (void)
+{
+  for (int a = 0; a < 2; ++a)
+    for (int b = 0; b < 2; ++b)
+      for (int c = 0; c < 2; ++c)
+	for (int d = 0; d < 2; ++d)
+	  buf[a][b][c][d] = 0;
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr29581-1.c b/gcc/testsuite/gcc.dg/graphite/pr29581-1.c
new file mode 100644
index 0000000..e540073
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr29581-1.c
@@ -0,0 +1,44 @@ 
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-85.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+	{
+	  k = i + N;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < N; j++)
+    if (a[j] != i + N - 1)
+      abort();	
+
+  for (j = 0; j < N; j++)
+    if (b[j] != j + N)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N] __attribute__ ((__aligned__(16)));
+
+  main1 (a);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr29581-2.c b/gcc/testsuite/gcc.dg/graphite/pr29581-2.c
new file mode 100644
index 0000000..c99d78c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr29581-2.c
@@ -0,0 +1,46 @@ 
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-86.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int n)
+{
+  int i, j, k;
+  int a[N], b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+	{
+	  k = i + n;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (i = 0; i < n; i++)
+    if (b[i] != i + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  main1 (N);
+  main1 (0);
+  main1 (1);
+  main1 (2);
+  main1 (N-1);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr29581-3.c b/gcc/testsuite/gcc.dg/graphite/pr29581-3.c
new file mode 100644
index 0000000..c9d72ce
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr29581-3.c
@@ -0,0 +1,48 @@ 
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-87.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int n, int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+	{
+	  k = i + n;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (j = 0; j < n; j++)
+    if (b[j] != j + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N] __attribute__ ((__aligned__(16)));
+
+  main1 (N, a);
+  main1 (0, a);
+  main1 (1, a);
+  main1 (2, a);
+  main1 (N-1, a);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr29581-4.c b/gcc/testsuite/gcc.dg/graphite/pr29581-4.c
new file mode 100644
index 0000000..c2d894c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr29581-4.c
@@ -0,0 +1,48 @@ 
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-88.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int n, int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+	{
+	  k = i + n;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (j = 0; j < n; j++)
+    if (b[j] != j + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N+1] __attribute__ ((__aligned__(16)));
+
+  main1 (N, a+1);
+  main1 (0, a+1);
+  main1 (1, a+1);
+  main1 (2, a+1);
+  main1 (N-1, a+1);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr30565.c b/gcc/testsuite/gcc.dg/graphite/pr30565.c
new file mode 100644
index 0000000..802b7c2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr30565.c
@@ -0,0 +1,14 @@ 
+/* PR tree-optimization/30565  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-pre -ftree-loop-linear" } */
+
+static double snrdef[32];
+void psycho_n1(double ltmin[2][32], int stereo)
+{
+  int i, k;
+
+  for (k = 0; k < stereo; k++)
+    for (i = 0; i < 32; i++)
+      ltmin[k][i] = snrdef[i];
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr31183.c b/gcc/testsuite/gcc.dg/graphite/pr31183.c
new file mode 100644
index 0000000..000d7b5
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr31183.c
@@ -0,0 +1,14 @@ 
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+int buf[256 * 9];
+int f() 
+{
+  int i, j;
+
+  for (i = 0; i < 256; ++i)
+    for (j = 0; j < 8; ++j)
+      buf[j + 1] = buf[j] + 1;
+
+  return buf[10];
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr33576.c b/gcc/testsuite/gcc.dg/graphite/pr33576.c
new file mode 100644
index 0000000..2470762
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr33576.c
@@ -0,0 +1,20 @@ 
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+int a1[6][4][4];
+short b1[16];
+
+int c1;
+void CalculateQuantParam(void)
+{
+  int i, j, k, temp;
+
+   for(k=0; k<6; k++)
+      for(j=0; j<4; j++)
+        for(i=0; i<4; i++)
+        {
+          temp = (i<<2)+j;
+          a1[k][j][i]  = c1/b1[temp];
+        }
+}
+
diff --git a/gcc/testsuite/gcc.dg/graphite/pr33766.c b/gcc/testsuite/gcc.dg/graphite/pr33766.c
new file mode 100644
index 0000000..f6bb506
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr33766.c
@@ -0,0 +1,19 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+float
+fxt1_quantize_ALPHA1()
+{
+        int j1;
+        int i;
+        float *tv;
+        for (j1 = 1; j1; j1++) {
+                float e;
+                for (i = 1; i; i++)
+                        e = tv[i];
+                if (e)
+                        i = j1;
+        }
+        return tv[i];
+}
+
diff --git a/gcc/testsuite/gcc.dg/graphite/pr34016.c b/gcc/testsuite/gcc.dg/graphite/pr34016.c
new file mode 100644
index 0000000..5ca84bb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr34016.c
@@ -0,0 +1,19 @@ 
+/* PR tree-optimization/34016 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void bar (double *);
+
+void foo (void)
+{
+  double gr[36];
+  int i, j;
+  for (i = 0; i <= 5; i++)
+    {
+      for (j = 0; j <= 5; j++)
+        gr[i + j * 6] = 0.0;
+      if (i <= 2)
+        gr[i + i * 6] = 1.0;
+    }
+  bar (gr);
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr34017.c b/gcc/testsuite/gcc.dg/graphite/pr34017.c
new file mode 100644
index 0000000..ee279b7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr34017.c
@@ -0,0 +1,26 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern int s;
+
+void
+foo (int *x, int y, int z)
+{
+ int m, n;
+ int o;
+ int p = x[0];
+ o = s;
+ for (m = 0; m < s; m++)
+   for (n = 0; n < s; n++)
+     {
+       if (x[n] != p)
+         continue;
+       if (m > z)
+         z = m;
+       if (n < o)
+         o = n;
+     }
+ for (m = y; m <= z; m++)
+   {
+   }
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr34123.c b/gcc/testsuite/gcc.dg/graphite/pr34123.c
new file mode 100644
index 0000000..81dbf3a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr34123.c
@@ -0,0 +1,18 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+
+static unsigned char sbox[256] = {
+};
+void MD2Transform (unsigned char state[16])
+{
+  unsigned char t = 0;
+  int i, j;
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < 2; j++)
+        t = (state[j] ^= sbox[t]);
+      t += i;
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr36287.c b/gcc/testsuite/gcc.dg/graphite/pr36287.c
new file mode 100644
index 0000000..51b77c7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr36287.c
@@ -0,0 +1,22 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-loop-linear" } */
+
+int tab[2][2];
+
+int foo ()
+{
+  int i, j, k;
+
+  for (i = 0; i < 2; ++i)
+    for (j = 0; j < 2; ++j)
+      for (k = 0; k < 2; ++k) 
+	{}
+
+  for (i = 0; i < 2; ++i)
+    for (j = 0; j < 2; ++j)
+      if (i == 0)
+	tab[i][j] = 0;
+
+  return tab[0][1];
+}
+
diff --git a/gcc/testsuite/gcc.dg/graphite/pr37686.c b/gcc/testsuite/gcc.dg/graphite/pr37686.c
new file mode 100644
index 0000000..a5094bf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr37686.c
@@ -0,0 +1,48 @@ 
+/* { dg-do compile { target powerpc*-*-* } } */
+/* { dg-options "-O3 -ftree-loop-linear" } */
+
+unsigned char inUse[256];
+unsigned char len[6][258];
+int code[6][258];
+unsigned int crc32Table[256] = { };
+  unsigned int getGlobalCRC (void) { }
+  int bsLive;
+void bsW (int n, unsigned int v) {
+ while (bsLive >= 8) {}
+ }
+ void hbAssignCodes (int * code,         unsigned char * length, int minLen,
+int maxLen, int alphaSize) {
+   int n, vec, i;
+   for (n = minLen;n <= maxLen;n++)
+       for (i = 0; i < alphaSize;i++)
+      code[i] = vec;
+   }
+  void sendMTFValues (void) {
+   int v, t, i, j, gs, ge, totc, bt, bc, iter;
+   int nSelectors, alphaSize, minLen, maxLen, selCtr;
+   int nGroups, nBytes;
+ {
+    while (1)
+  {
+  break;
+  }
+       hbAssignCodes (&code[t][0], &len[t][0], minLen, maxLen, alphaSize);
+     unsigned char inUse16[16];
+     for (i = 0;i < 16;i++)
+ if (inUse16[i])
+  {
+      for (j = 0;j < 16;j++)
+   if (inUse[i * 16 + j])    { }
+    }
+   }
+   for (i = 0; i < nSelectors;i++)     { }
+   for (t = 0; t < nGroups;t++)
+ {
+       int curr = len[t][0];
+       for (i = 0; i < alphaSize;i++)
+          while (curr < len[t][i])     { }
+     }
+   while (1)
+       for (i = gs; i <= ge;i++)  { }
+ }
+
diff --git a/gcc/testsuite/gcc.dg/graphite/pr42917.c b/gcc/testsuite/gcc.dg/graphite/pr42917.c
new file mode 100644
index 0000000..eddff3b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr42917.c
@@ -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/pr18792.c b/gcc/testsuite/gcc.dg/pr18792.c
deleted file mode 100644
index 4e93fe1..0000000
--- a/gcc/testsuite/gcc.dg/pr18792.c
+++ /dev/null
@@ -1,16 +0,0 @@ 
-/* PR tree-optimization/18792 */
-/* { dg-do compile } */
-/* { dg-options "-O1 -ftree-loop-linear" } */
-void put_atoms_in_triclinic_unitcell(float x[][3])
-{
-	int i=0,d;
-
-	while (x[i][3] < 0)
-		for (d=0; d<=3; d++)
-			x[i][d] = 0;
-
-	while (x[i][3] >= 0)
-		for (d=0; d<=3; d++)
-			x[i][d] = 0;
-
-}
diff --git a/gcc/testsuite/gcc.dg/pr19910.c b/gcc/testsuite/gcc.dg/pr19910.c
deleted file mode 100644
index 1ee0d21..0000000
--- a/gcc/testsuite/gcc.dg/pr19910.c
+++ /dev/null
@@ -1,16 +0,0 @@ 
-/* Contributed by Volker Reichelt <reichelt@gcc.gnu.org>.  */
-
-/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-int a[3];
-
-void foo()
-{
-  int i, j;
-
-  for (i = 1; i >= 0; --i)
-    for (j = i; j >= 0; --j)
-      a[i+j] = 0;
-}
-
diff --git a/gcc/testsuite/gcc.dg/pr23625.c b/gcc/testsuite/gcc.dg/pr23625.c
deleted file mode 100644
index aaeddb2..0000000
--- a/gcc/testsuite/gcc.dg/pr23625.c
+++ /dev/null
@@ -1,27 +0,0 @@ 
-/* Test case for PR23625 */
-/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-vectorize -ftree-loop-linear" } */
-
-typedef long INT32;
-void find_best_colors ()
-{
-int ic0, ic1, ic2;
-INT32 * bptr;
-INT32 dist1;
-INT32 dist2;
-INT32 xx1;
-for (ic0 = (1<<(5 -3))-1;ic0 >= 0;ic0--)
-{
-  for (ic1 = (1<<(6 -3))-1;ic1 >= 0;ic1--)
-  {
-    dist2 = dist1;
-     for (ic2 = (1<<(5 -3))-1;ic2 >= 0;ic2--)
-     {
-        *bptr = dist2;
-        bptr++;
-     }
-     dist1 += xx1;
-  }
-}
-}
-
diff --git a/gcc/testsuite/gcc.dg/pr29330.c b/gcc/testsuite/gcc.dg/pr29330.c
deleted file mode 100644
index dff4207..0000000
--- a/gcc/testsuite/gcc.dg/pr29330.c
+++ /dev/null
@@ -1,15 +0,0 @@ 
-/* PR tree-optimization/29330 */
-/* { dg-do compile } */
-/* { dg-options "-O -ftree-loop-linear -std=gnu99" } */
-
-int buf[2][2][2][2];
-
-void
-f (void)
-{
-  for (int a = 0; a < 2; ++a)
-    for (int b = 0; b < 2; ++b)
-      for (int c = 0; c < 2; ++c)
-	for (int d = 0; d < 2; ++d)
-	  buf[a][b][c][d] = 0;
-}
diff --git a/gcc/testsuite/gcc.dg/pr29581-1.c b/gcc/testsuite/gcc.dg/pr29581-1.c
deleted file mode 100644
index e540073..0000000
--- a/gcc/testsuite/gcc.dg/pr29581-1.c
+++ /dev/null
@@ -1,44 +0,0 @@ 
-/* PR tree-optimization/29581 */
-/* Origin: gcc.dg/vect/vect-85.c */
-/* { dg-do run } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-extern void abort (void);
-
-#define N 16
-
-int main1 (int *a)
-{
-  int i, j, k;
-  int b[N];
-
-  for (i = 0; i < N; i++)
-    {
-      for (j = 0; j < N; j++)
-	{
-	  k = i + N;
-	  a[j] = k;
-	}
-      b[i] = k;
-    }
-
-
-  for (j = 0; j < N; j++)
-    if (a[j] != i + N - 1)
-      abort();	
-
-  for (j = 0; j < N; j++)
-    if (b[j] != j + N)
-      abort();	
-
-  return 0;
-}
-
-int main (void)
-{
-  int a[N] __attribute__ ((__aligned__(16)));
-
-  main1 (a);
-
-  return 0;
-}
diff --git a/gcc/testsuite/gcc.dg/pr29581-2.c b/gcc/testsuite/gcc.dg/pr29581-2.c
deleted file mode 100644
index c99d78c..0000000
--- a/gcc/testsuite/gcc.dg/pr29581-2.c
+++ /dev/null
@@ -1,46 +0,0 @@ 
-/* PR tree-optimization/29581 */
-/* Origin: gcc.dg/vect/vect-86.c */
-/* { dg-do run } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-extern void abort (void);
-
-#define N 16
-
-int main1 (int n)
-{
-  int i, j, k;
-  int a[N], b[N];
-
-  for (i = 0; i < n; i++)
-    {
-      for (j = 0; j < n; j++)
-	{
-	  k = i + n;
-	  a[j] = k;
-	}
-      b[i] = k;
-    }
-
-
-  for (j = 0; j < n; j++)
-    if (a[j] != i + n - 1)
-      abort();	
-
-  for (i = 0; i < n; i++)
-    if (b[i] != i + n)
-      abort();	
-
-  return 0;
-}
-
-int main (void)
-{
-  main1 (N);
-  main1 (0);
-  main1 (1);
-  main1 (2);
-  main1 (N-1);
-
-  return 0;
-}
diff --git a/gcc/testsuite/gcc.dg/pr29581-3.c b/gcc/testsuite/gcc.dg/pr29581-3.c
deleted file mode 100644
index c9d72ce..0000000
--- a/gcc/testsuite/gcc.dg/pr29581-3.c
+++ /dev/null
@@ -1,48 +0,0 @@ 
-/* PR tree-optimization/29581 */
-/* Origin: gcc.dg/vect/vect-87.c */
-/* { dg-do run } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-extern void abort (void);
-
-#define N 16
-
-int main1 (int n, int *a)
-{
-  int i, j, k;
-  int b[N];
-
-  for (i = 0; i < n; i++)
-    {
-      for (j = 0; j < n; j++)
-	{
-	  k = i + n;
-	  a[j] = k;
-	}
-      b[i] = k;
-    }
-
-
-  for (j = 0; j < n; j++)
-    if (a[j] != i + n - 1)
-      abort();	
-
-  for (j = 0; j < n; j++)
-    if (b[j] != j + n)
-      abort();	
-
-  return 0;
-}
-
-int main (void)
-{
-  int a[N] __attribute__ ((__aligned__(16)));
-
-  main1 (N, a);
-  main1 (0, a);
-  main1 (1, a);
-  main1 (2, a);
-  main1 (N-1, a);
-
-  return 0;
-}
diff --git a/gcc/testsuite/gcc.dg/pr29581-4.c b/gcc/testsuite/gcc.dg/pr29581-4.c
deleted file mode 100644
index c2d894c..0000000
--- a/gcc/testsuite/gcc.dg/pr29581-4.c
+++ /dev/null
@@ -1,48 +0,0 @@ 
-/* PR tree-optimization/29581 */
-/* Origin: gcc.dg/vect/vect-88.c */
-/* { dg-do run } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-extern void abort (void);
-
-#define N 16
-
-int main1 (int n, int *a)
-{
-  int i, j, k;
-  int b[N];
-
-  for (i = 0; i < n; i++)
-    {
-      for (j = 0; j < n; j++)
-	{
-	  k = i + n;
-	  a[j] = k;
-	}
-      b[i] = k;
-    }
-
-
-  for (j = 0; j < n; j++)
-    if (a[j] != i + n - 1)
-      abort();	
-
-  for (j = 0; j < n; j++)
-    if (b[j] != j + n)
-      abort();	
-
-  return 0;
-}
-
-int main (void)
-{
-  int a[N+1] __attribute__ ((__aligned__(16)));
-
-  main1 (N, a+1);
-  main1 (0, a+1);
-  main1 (1, a+1);
-  main1 (2, a+1);
-  main1 (N-1, a+1);
-
-  return 0;
-}
diff --git a/gcc/testsuite/gcc.dg/pr34016.c b/gcc/testsuite/gcc.dg/pr34016.c
deleted file mode 100644
index 5ca84bb..0000000
--- a/gcc/testsuite/gcc.dg/pr34016.c
+++ /dev/null
@@ -1,19 +0,0 @@ 
-/* PR tree-optimization/34016 */
-/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-extern void bar (double *);
-
-void foo (void)
-{
-  double gr[36];
-  int i, j;
-  for (i = 0; i <= 5; i++)
-    {
-      for (j = 0; j <= 5; j++)
-        gr[i + j * 6] = 0.0;
-      if (i <= 2)
-        gr[i + i * 6] = 1.0;
-    }
-  bar (gr);
-}
diff --git a/gcc/testsuite/gcc.dg/pr42917.c b/gcc/testsuite/gcc.dg/pr42917.c
deleted file mode 100644
index d8db32e..0000000
--- a/gcc/testsuite/gcc.dg/pr42917.c
+++ /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/20041110-1.c b/gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c
deleted file mode 100644
index 825b2b4..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c
+++ /dev/null
@@ -1,26 +0,0 @@ 
-/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-/* This testcase was causing an ICE in building distance vectors because
-   we weren't ignoring the fact that one of the induction variables
-   involved in the dependence was outside of the loop.  */
-extern int foo (int, int);
-int
-main (void)
-{
-  int a[50];
-  int b[50];
-  int i, j, k;
-  for (i = 4; i < 30; i++)
-    {
-      for (j = 3; j < 40; j++)
-	{
-	  for (k = 9; k < 50; k++)
-	    {
-	      b[j] = a[i];
-	      a[k] = b[i];
-	    }
-	}
-    }
-  foo (a[i], b[i]);
-}
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
index 12e42b7..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c
+++ /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/loop-27.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-27.c
deleted file mode 100644
index 802b7c2..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/loop-27.c
+++ /dev/null
@@ -1,14 +0,0 @@ 
-/* PR tree-optimization/30565  */
-
-/* { dg-do compile } */
-/* { dg-options "-O1 -ftree-pre -ftree-loop-linear" } */
-
-static double snrdef[32];
-void psycho_n1(double ltmin[2][32], int stereo)
-{
-  int i, k;
-
-  for (k = 0; k < stereo; k++)
-    for (i = 0; i < 32; i++)
-      ltmin[k][i] = snrdef[i];
-}
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
index bff58f6..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c
+++ /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
index 9548bf2..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c
+++ /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
index d7dd211..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c
+++ /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
index 6682538..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c
+++ /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
index 3540723..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c
+++ /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
index e6a290a..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c
+++ /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
index 67569d8..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c
+++ /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/gcc.dg/tree-ssa/pr20256.c b/gcc/testsuite/gcc.dg/tree-ssa/pr20256.c
deleted file mode 100644
index aa482ed..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr20256.c
+++ /dev/null
@@ -1,25 +0,0 @@ 
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-/* { dg-require-effective-target size32plus } */
-
-int foo()
-{
-  int x[2][2], y[2];
-  int i, n, s;
-
-  /* This is a reduction: there is a scalar dependence that cannot be
-     removed by rewriting IVs.  This code cannot and should not be
-     transformed into a perfect loop.  */
-  for (n = 0; n < 2; n++)
-    {
-      s = 0;
-      for (i = 0; i < 2; i++)
-        s += x[n][i]*y[i];
-      s += 1;
-    }
-
-  return s;
-}
-
-/* { 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/tree-ssa/pr23820.c b/gcc/testsuite/gcc.dg/tree-ssa/pr23820.c
deleted file mode 100644
index ee855e1..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr23820.c
+++ /dev/null
@@ -1,26 +0,0 @@ 
-/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-int t [2][4];
-
-void foo (void)
-{
-  int i, j, k, v;
-  float e;
-  for (;;)
-    {
-      v = 0;
-      for (j = 0; j < 2; j ++)
-        {
-          for (k = 2; k < 4; k ++)
-            {
-              e = 0.0;
-              for (i = 0; i < 4; i ++)
-                e += t [j][i];
-              if (e)
-                v = j;
-            }
-        }
-      t [v][0] = 0;
-    }
-}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c b/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c
deleted file mode 100644
index b50e7a8..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c
+++ /dev/null
@@ -1,18 +0,0 @@ 
-/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-float weight[10];
-void lsp_weight_quant(float *x, char *cdbk)
-{
-   int i,j;
-   float dist;
-   int best_id=0;
-   for (i=0;i<16;i++)
-   {
-      for (j=0;j<10;j++)
-         dist=dist+weight[j];
-      if (dist<0)
-         best_id=i;
-   }
-   x[j] = cdbk[best_id*10+j];
-}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c b/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c
deleted file mode 100644
index 907c5d2..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c
+++ /dev/null
@@ -1,20 +0,0 @@ 
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
-/* { dg-require-effective-target size32plus } */
-
-int foo(int *p, int n)
-{
-  int i, j, k = 0;
-
-  /* This is a reduction: there is a scalar dependence that cannot be
-     removed by rewriting IVs.  This code cannot and should not be
-     transformed into a perfect loop.  */
-  for (i = 0; i < 2; ++i, p += n)
-    for (j = 0; j < 2; ++j)
-      k += p[j];
-
-  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/tree-ssa/pr31183.c b/gcc/testsuite/gcc.dg/tree-ssa/pr31183.c
deleted file mode 100644
index 000d7b5..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr31183.c
+++ /dev/null
@@ -1,14 +0,0 @@ 
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-int buf[256 * 9];
-int f() 
-{
-  int i, j;
-
-  for (i = 0; i < 256; ++i)
-    for (j = 0; j < 8; ++j)
-      buf[j + 1] = buf[j] + 1;
-
-  return buf[10];
-}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c b/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c
deleted file mode 100644
index 2470762..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c
+++ /dev/null
@@ -1,20 +0,0 @@ 
-/* { dg-do compile } */ 
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-int a1[6][4][4];
-short b1[16];
-
-int c1;
-void CalculateQuantParam(void)
-{
-  int i, j, k, temp;
-
-   for(k=0; k<6; k++)
-      for(j=0; j<4; j++)
-        for(i=0; i<4; i++)
-        {
-          temp = (i<<2)+j;
-          a1[k][j][i]  = c1/b1[temp];
-        }
-}
-
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c b/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c
deleted file mode 100644
index f6bb506..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c
+++ /dev/null
@@ -1,19 +0,0 @@ 
-/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-float
-fxt1_quantize_ALPHA1()
-{
-        int j1;
-        int i;
-        float *tv;
-        for (j1 = 1; j1; j1++) {
-                float e;
-                for (i = 1; i; i++)
-                        e = tv[i];
-                if (e)
-                        i = j1;
-        }
-        return tv[i];
-}
-
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c b/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c
deleted file mode 100644
index ee279b7..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c
+++ /dev/null
@@ -1,26 +0,0 @@ 
-/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-extern int s;
-
-void
-foo (int *x, int y, int z)
-{
- int m, n;
- int o;
- int p = x[0];
- o = s;
- for (m = 0; m < s; m++)
-   for (n = 0; n < s; n++)
-     {
-       if (x[n] != p)
-         continue;
-       if (m > z)
-         z = m;
-       if (n < o)
-         o = n;
-     }
- for (m = y; m <= z; m++)
-   {
-   }
-}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c b/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c
deleted file mode 100644
index 81dbf3a..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c
+++ /dev/null
@@ -1,18 +0,0 @@ 
-/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-loop-linear" } */
-
-/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
-
-static unsigned char sbox[256] = {
-};
-void MD2Transform (unsigned char state[16])
-{
-  unsigned char t = 0;
-  int i, j;
-  for (i = 0; i < 16; i++)
-    {
-      for (j = 0; j < 2; j++)
-        t = (state[j] ^= sbox[t]);
-      t += i;
-    }
-}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c b/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c
deleted file mode 100644
index 51b77c7..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c
+++ /dev/null
@@ -1,22 +0,0 @@ 
-/* { dg-do compile } */
-/* { dg-options "-O -ftree-loop-linear" } */
-
-int tab[2][2];
-
-int foo ()
-{
-  int i, j, k;
-
-  for (i = 0; i < 2; ++i)
-    for (j = 0; j < 2; ++j)
-      for (k = 0; k < 2; ++k) 
-	{}
-
-  for (i = 0; i < 2; ++i)
-    for (j = 0; j < 2; ++j)
-      if (i == 0)
-	tab[i][j] = 0;
-
-  return tab[0][1];
-}
-
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c b/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c
deleted file mode 100644
index a5094bf..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c
+++ /dev/null
@@ -1,48 +0,0 @@ 
-/* { dg-do compile { target powerpc*-*-* } } */
-/* { dg-options "-O3 -ftree-loop-linear" } */
-
-unsigned char inUse[256];
-unsigned char len[6][258];
-int code[6][258];
-unsigned int crc32Table[256] = { };
-  unsigned int getGlobalCRC (void) { }
-  int bsLive;
-void bsW (int n, unsigned int v) {
- while (bsLive >= 8) {}
- }
- void hbAssignCodes (int * code,         unsigned char * length, int minLen,
-int maxLen, int alphaSize) {
-   int n, vec, i;
-   for (n = minLen;n <= maxLen;n++)
-       for (i = 0; i < alphaSize;i++)
-      code[i] = vec;
-   }
-  void sendMTFValues (void) {
-   int v, t, i, j, gs, ge, totc, bt, bc, iter;
-   int nSelectors, alphaSize, minLen, maxLen, selCtr;
-   int nGroups, nBytes;
- {
-    while (1)
-  {
-  break;
-  }
-       hbAssignCodes (&code[t][0], &len[t][0], minLen, maxLen, alphaSize);
-     unsigned char inUse16[16];
-     for (i = 0;i < 16;i++)
- if (inUse16[i])
-  {
-      for (j = 0;j < 16;j++)
-   if (inUse[i * 16 + j])    { }
-    }
-   }
-   for (i = 0; i < nSelectors;i++)     { }
-   for (t = 0; t < nGroups;t++)
- {
-       int curr = len[t][0];
-       for (i = 0; i < alphaSize;i++)
-          while (curr < len[t][i])     { }
-     }
-   while (1)
-       for (i = gs; i <= ge;i++)  { }
- }
-
diff --git a/gcc/testsuite/gfortran.dg/graphite/interchange-4.f b/gcc/testsuite/gfortran.dg/graphite/interchange-4.f
new file mode 100644
index 0000000..3d42811
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/graphite/interchange-4.f
@@ -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
index 0000000..658f10a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/graphite/interchange-5.f
@@ -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/graphite/pr29290.f90 b/gcc/testsuite/gfortran.dg/graphite/pr29290.f90
new file mode 100644
index 0000000..8968d88
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/graphite/pr29290.f90
@@ -0,0 +1,9 @@ 
+! PR tree-optimization/29290
+! { dg-do compile }
+! { dg-options "-O3 -ftree-loop-linear" }
+
+subroutine pr29290 (a, b, c, d)
+  integer c, d
+  real*8 a(c,c), b(c,c)
+  a(1:d,1:d) = b(1:d,1:d)
+end
diff --git a/gcc/testsuite/gfortran.dg/graphite/pr29581.f90 b/gcc/testsuite/gfortran.dg/graphite/pr29581.f90
new file mode 100644
index 0000000..3e4a39e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/graphite/pr29581.f90
@@ -0,0 +1,27 @@ 
+! PR tree-optimization/29581
+! { dg-do run }
+! { dg-options "-O2 -ftree-loop-linear" }
+
+      SUBROUTINE FOO (K)
+      INTEGER I, J, K, A(5,5), B
+      COMMON A
+      A(1,1) = 1
+ 10   B = 0
+      DO 30 I = 1, K
+        DO 20 J = 1, K
+          B = B + A(I,J)
+ 20     CONTINUE
+        A(I,I) = A(I,I) * 2
+ 30   CONTINUE
+      IF (B.GE.3) RETURN
+      GO TO 10
+      END SUBROUTINE
+
+      PROGRAM BAR
+        INTEGER A(5,5)
+        COMMON A
+        CALL FOO (2)
+        IF (A(1,1).NE.8) CALL ABORT
+        A(1,1) = 0
+        IF (ANY(A.NE.0)) CALL ABORT
+      END
diff --git a/gcc/testsuite/gfortran.dg/graphite/pr36286.f90 b/gcc/testsuite/gfortran.dg/graphite/pr36286.f90
new file mode 100644
index 0000000..bcdef08
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/graphite/pr36286.f90
@@ -0,0 +1,14 @@ 
+! { dg-do compile }
+! { dg-options "-O1 -ftree-loop-linear" }
+! PR tree-optimization/36286
+
+program test_count
+    integer, dimension(2,3) :: a, b
+    a = reshape( (/ 1, 3, 5, 2, 4, 6 /), (/ 2, 3 /))
+    b = reshape( (/ 0, 3, 5, 7, 4, 8 /), (/ 2, 3 /))
+    print '(3l6)', a.ne.b
+    print *, a(1,:).ne.b(1,:)
+    print *, a(2,:).ne.b(2,:)
+    print *, count(a.ne.b)
+end program test_count
+
diff --git a/gcc/testsuite/gfortran.dg/graphite/pr36922.f b/gcc/testsuite/gfortran.dg/graphite/pr36922.f
new file mode 100644
index 0000000..6aa95be
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/graphite/pr36922.f
@@ -0,0 +1,16 @@ 
+C PR tree-optimization/36922
+C { dg-do compile }
+C { dg-options "-O2 -ftree-loop-linear" }
+      SUBROUTINE PR36922(N,F,Z,C)
+      IMPLICIT DOUBLE PRECISION(A-H,O-Z)
+      DIMENSION C(23821),Z(0:2*N+1),F(0:2*N)
+      I=0
+      DO L=0,N
+        DO M=0,L
+          DO M2=M,L
+            I=I+1
+            C(I)=F(L+M)*F(L-M)*Z(L-M2)/(F(M2+M)*F(M2-M)*F(L-M2)*F(L-M2))
+          ENDDO
+        ENDDO
+      ENDDO
+      END
diff --git a/gcc/testsuite/gfortran.dg/graphite/pr39516.f b/gcc/testsuite/gfortran.dg/graphite/pr39516.f
new file mode 100644
index 0000000..3d6104a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/graphite/pr39516.f
@@ -0,0 +1,20 @@ 
+C PR tree-optimization/39516
+C { dg-do compile }
+C { dg-options "-O2 -ftree-loop-linear" }
+      SUBROUTINE SUB(A, B, M)
+      IMPLICIT NONE
+      DOUBLE PRECISION A(20,20), B(20)
+      INTEGER*8 I, J, K, M
+      DO I=1,M
+        DO J=1,M
+          A(I,J)=A(I,J)+1
+        END DO
+      END DO
+      DO K=1,20
+        DO I=1,M
+          DO J=1,M
+            B(I)=B(I)+A(I,J)
+          END DO
+        END DO
+      END DO
+      END SUBROUTINE
diff --git a/gcc/testsuite/gfortran.dg/loop_nest_1.f90 b/gcc/testsuite/gfortran.dg/loop_nest_1.f90
deleted file mode 100644
index 8968d88..0000000
--- a/gcc/testsuite/gfortran.dg/loop_nest_1.f90
+++ /dev/null
@@ -1,9 +0,0 @@ 
-! PR tree-optimization/29290
-! { dg-do compile }
-! { dg-options "-O3 -ftree-loop-linear" }
-
-subroutine pr29290 (a, b, c, d)
-  integer c, d
-  real*8 a(c,c), b(c,c)
-  a(1:d,1:d) = b(1:d,1:d)
-end
diff --git a/gcc/testsuite/gfortran.dg/ltrans-7.f90 b/gcc/testsuite/gfortran.dg/ltrans-7.f90
deleted file mode 100644
index 583edf2..0000000
--- a/gcc/testsuite/gfortran.dg/ltrans-7.f90
+++ /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" } }
diff --git a/gcc/testsuite/gfortran.dg/pr29581.f90 b/gcc/testsuite/gfortran.dg/pr29581.f90
deleted file mode 100644
index 3e4a39e..0000000
--- a/gcc/testsuite/gfortran.dg/pr29581.f90
+++ /dev/null
@@ -1,27 +0,0 @@ 
-! PR tree-optimization/29581
-! { dg-do run }
-! { dg-options "-O2 -ftree-loop-linear" }
-
-      SUBROUTINE FOO (K)
-      INTEGER I, J, K, A(5,5), B
-      COMMON A
-      A(1,1) = 1
- 10   B = 0
-      DO 30 I = 1, K
-        DO 20 J = 1, K
-          B = B + A(I,J)
- 20     CONTINUE
-        A(I,I) = A(I,I) * 2
- 30   CONTINUE
-      IF (B.GE.3) RETURN
-      GO TO 10
-      END SUBROUTINE
-
-      PROGRAM BAR
-        INTEGER A(5,5)
-        COMMON A
-        CALL FOO (2)
-        IF (A(1,1).NE.8) CALL ABORT
-        A(1,1) = 0
-        IF (ANY(A.NE.0)) CALL ABORT
-      END
diff --git a/gcc/testsuite/gfortran.dg/pr36286.f90 b/gcc/testsuite/gfortran.dg/pr36286.f90
deleted file mode 100644
index bcdef08..0000000
--- a/gcc/testsuite/gfortran.dg/pr36286.f90
+++ /dev/null
@@ -1,14 +0,0 @@ 
-! { dg-do compile }
-! { dg-options "-O1 -ftree-loop-linear" }
-! PR tree-optimization/36286
-
-program test_count
-    integer, dimension(2,3) :: a, b
-    a = reshape( (/ 1, 3, 5, 2, 4, 6 /), (/ 2, 3 /))
-    b = reshape( (/ 0, 3, 5, 7, 4, 8 /), (/ 2, 3 /))
-    print '(3l6)', a.ne.b
-    print *, a(1,:).ne.b(1,:)
-    print *, a(2,:).ne.b(2,:)
-    print *, count(a.ne.b)
-end program test_count
-
diff --git a/gcc/testsuite/gfortran.dg/pr36922.f b/gcc/testsuite/gfortran.dg/pr36922.f
deleted file mode 100644
index 6aa95be..0000000
--- a/gcc/testsuite/gfortran.dg/pr36922.f
+++ /dev/null
@@ -1,16 +0,0 @@ 
-C PR tree-optimization/36922
-C { dg-do compile }
-C { dg-options "-O2 -ftree-loop-linear" }
-      SUBROUTINE PR36922(N,F,Z,C)
-      IMPLICIT DOUBLE PRECISION(A-H,O-Z)
-      DIMENSION C(23821),Z(0:2*N+1),F(0:2*N)
-      I=0
-      DO L=0,N
-        DO M=0,L
-          DO M2=M,L
-            I=I+1
-            C(I)=F(L+M)*F(L-M)*Z(L-M2)/(F(M2+M)*F(M2-M)*F(L-M2)*F(L-M2))
-          ENDDO
-        ENDDO
-      ENDDO
-      END
diff --git a/gcc/testsuite/gfortran.dg/pr39516.f b/gcc/testsuite/gfortran.dg/pr39516.f
deleted file mode 100644
index 3d6104a..0000000
--- a/gcc/testsuite/gfortran.dg/pr39516.f
+++ /dev/null
@@ -1,20 +0,0 @@ 
-C PR tree-optimization/39516
-C { dg-do compile }
-C { dg-options "-O2 -ftree-loop-linear" }
-      SUBROUTINE SUB(A, B, M)
-      IMPLICIT NONE
-      DOUBLE PRECISION A(20,20), B(20)
-      INTEGER*8 I, J, K, M
-      DO I=1,M
-        DO J=1,M
-          A(I,J)=A(I,J)+1
-        END DO
-      END DO
-      DO K=1,20
-        DO I=1,M
-          DO J=1,M
-            B(I)=B(I)+A(I,J)
-          END DO
-        END DO
-      END DO
-      END SUBROUTINE
diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index ccc0091..7a5fe89 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -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
diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h
index 7865576..2e85677 100644
--- a/gcc/tree-data-ref.h
+++ b/gcc/tree-data-ref.h
@@ -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  */
diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h
index 682907c..1720859 100644
--- a/gcc/tree-flow.h
+++ b/gcc/tree-flow.h
@@ -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
index 5b19c17..0000000
--- a/gcc/tree-loop-linear.c
+++ /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);
-}
diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c
index 9ece887..1feb028 100644
--- a/gcc/tree-parloops.c
+++ b/gcc/tree-parloops.c
@@ -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
diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
index a87a770..c614861 100644
--- a/gcc/tree-pass.h
+++ b/gcc/tree-pass.h
@@ -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
@@ -428,7 +428,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;
diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c
index d1d7142..149358d 100644
--- a/gcc/tree-ssa-loop.c
+++ b/gcc/tree-ssa-loop.c
@@ -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,6 +266,7 @@  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
@@ -312,6 +274,10 @@  gate_graphite_transforms (void)
       || flag_graphite_opencl)
     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;
 }