This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [PATCH 21/32] Remove the lambda framework and make -ftree-loop-linear an alias of -floop-interchange.
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;
> }
>
>
--
Richard Guenther <rguenther@suse.de>
Novell / SUSE Labs
SUSE LINUX Products GmbH - Nuernberg - AG Nuernberg - HRB 16746 - GF: Markus Rex