From: spop Date: Tue, 25 Jan 2011 21:24:23 +0000 (+0000) Subject: Remove the lambda framework and make -ftree-loop-linear an alias of -floop-interchange. X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=commitdiff_plain;h=e01f9f1fbea6bfad17002ec28168b9c4adb03846 Remove the lambda framework and make -ftree-loop-linear an alias of -floop-interchange. 2011-01-17 Sebastian Pop toplev/ * MAINTAINERS (linear loop transforms): Removed. toplev/gcc/ * Makefile.in (LAMBDA_H): Removed. (TREE_DATA_REF_H): Remove dependence on LAMBDA_H. (OBJS-common): Remove dependence on lambda-code.o, lambda-mat.o, lambda-trans.o, and tree-loop-linear.o. (lto-symtab.o): Remove dependence on LAMBDA_H. (tree-loop-linear.o): Remove rule. (lambda-mat.o): Same. (lambda-trans.o): Same. (lambda-code.o): Same. (tree-vect-loop.o): Add missing dependence on TREE_DATA_REF_H. (tree-vect-slp.o): Same. * hwint.h (gcd): Moved here. (least_common_multiple): Same. * lambda-code.c: Removed. * lambda-mat.c: Removed. * lambda-trans.c: Removed. * lambda.h: Removed. * tree-loop-linear.c: Removed. * lto-symtab.c: Do not include lambda.h. * omega.c (gcd): Removed. * passes.c (init_optimization_passes): Remove pass_linear_transform. * tree-data-ref.c (print_lambda_vector): Moved here. (lambda_vector_copy): Same. (lambda_matrix_copy): Same. (lambda_matrix_id): Same. (lambda_vector_first_nz): Same. (lambda_matrix_row_add): Same. (lambda_matrix_row_exchange): Same. (lambda_vector_mult_const): Same. (lambda_vector_negate): Same. (lambda_matrix_row_negate): Same. (lambda_vector_equal): Same. (lambda_matrix_right_hermite): Same. * tree-data-ref.h: Do not include lambda.h. (lambda_vector): Moved here. (lambda_matrix): Same. (dependence_level): Same. (lambda_transform_legal_p): Removed declaration. (lambda_collect_parameters): Same. (lambda_compute_access_matrices): Same. (lambda_vector_gcd): Same. (lambda_vector_new): Same. (lambda_vector_clear): Same. (lambda_vector_lexico_pos): Same. (lambda_vector_zerop): Same. (lambda_matrix_new): Same. * tree-flow.h (least_common_multiple): Removed declaration. * tree-parloops.c (lambda_trans_matrix): Moved here. (LTM_MATRIX): Same. (LTM_ROWSIZE): Same. (LTM_COLSIZE): Same. (LTM_DENOMINATOR): Same. (lambda_trans_matrix_new): Same. (lambda_matrix_vector_mult): Same. (lambda_transform_legal_p): Same. * tree-pass.h (pass_linear_transform): Removed declaration. * tree-ssa-loop.c (tree_linear_transform): Removed. (gate_tree_linear_transform): Removed. (pass_linear_transform): Removed. (gate_graphite_transforms): Make flag_tree_loop_linear an alias of flag_loop_interchange. toplev/gcc/testsuite/ * gfortran.dg/graphite/interchange-4.f: New. * gfortran.dg/graphite/interchange-5.f: New. * gcc.dg/tree-ssa/ltrans-1.c: Removed. * gcc.dg/tree-ssa/ltrans-2.c: Removed. * gcc.dg/tree-ssa/ltrans-3.c: Removed. * gcc.dg/tree-ssa/ltrans-4.c: Removed. * gcc.dg/tree-ssa/ltrans-5.c: Removed. * gcc.dg/tree-ssa/ltrans-6.c: Removed. * gcc.dg/tree-ssa/ltrans-8.c: Removed. * gfortran.dg/ltrans-7.f90: Removed. * gcc.dg/tree-ssa/data-dep-1.c: Removed. * gcc.dg/pr18792.c: -> gcc.dg/graphite/pr18792.c * gcc.dg/pr19910.c: -> gcc.dg/graphite/pr19910.c * gcc.dg/tree-ssa/20041110-1.c: -> gcc.dg/graphite/pr20041110-1.c * gcc.dg/tree-ssa/pr20256.c: -> gcc.dg/graphite/pr20256.c * gcc.dg/pr23625.c: -> gcc.dg/graphite/pr23625.c * gcc.dg/tree-ssa/pr23820.c: -> gcc.dg/graphite/pr23820.c * gcc.dg/tree-ssa/pr24309.c: -> gcc.dg/graphite/pr24309.c * gcc.dg/tree-ssa/pr26435.c: -> gcc.dg/graphite/pr26435.c * gcc.dg/pr29330.c: -> gcc.dg/graphite/pr29330.c * gcc.dg/pr29581-1.c: -> gcc.dg/graphite/pr29581-1.c * gcc.dg/pr29581-2.c: -> gcc.dg/graphite/pr29581-2.c * gcc.dg/pr29581-3.c: -> gcc.dg/graphite/pr29581-3.c * gcc.dg/pr29581-4.c: -> gcc.dg/graphite/pr29581-4.c * gcc.dg/tree-ssa/loop-27.c: -> gcc.dg/graphite/pr30565.c * gcc.dg/tree-ssa/pr31183.c: -> gcc.dg/graphite/pr31183.c * gcc.dg/tree-ssa/pr33576.c: -> gcc.dg/graphite/pr33576.c * gcc.dg/tree-ssa/pr33766.c: -> gcc.dg/graphite/pr33766.c * gcc.dg/pr34016.c: -> gcc.dg/graphite/pr34016.c * gcc.dg/tree-ssa/pr34017.c: -> gcc.dg/graphite/pr34017.c * gcc.dg/tree-ssa/pr34123.c: -> gcc.dg/graphite/pr34123.c * gcc.dg/tree-ssa/pr36287.c: -> gcc.dg/graphite/pr36287.c * gcc.dg/tree-ssa/pr37686.c: -> gcc.dg/graphite/pr37686.c * gcc.dg/pr42917.c: -> gcc.dg/graphite/pr42917.c * gfortran.dg/loop_nest_1.f90: -> gfortran.dg/graphite/pr29290.f90 * gfortran.dg/pr29581.f90: -> gfortran.dg/graphite/pr29581.f90 * gfortran.dg/pr36286.f90: -> gfortran.dg/graphite/pr36286.f90 * gfortran.dg/pr36922.f: -> gfortran.dg/graphite/pr36922.f * gfortran.dg/pr39516.f: -> gfortran.dg/graphite/pr39516.f git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@169251 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/ChangeLog b/ChangeLog index e4233e5efbf..ad8d8f936e1 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,7 @@ +2011-01-25 Sebastian Pop + + * MAINTAINERS (linear loop transforms): Removed. + 2011-01-25 Jakub Jelinek * config/cloog.m4 (CLOOG_REQUESTED): Use $2 if --without-cloog. diff --git a/MAINTAINERS b/MAINTAINERS index fb887a830f3..cffbdb0dd46 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 b/gcc/ChangeLog index 6e1c8f5cd80..514ab55f82f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,67 @@ +2011-01-25 Sebastian Pop + + * Makefile.in (LAMBDA_H): Removed. + (TREE_DATA_REF_H): Remove dependence on LAMBDA_H. + (OBJS-common): Remove dependence on lambda-code.o, lambda-mat.o, + lambda-trans.o, and tree-loop-linear.o. + (lto-symtab.o): Remove dependence on LAMBDA_H. + (tree-loop-linear.o): Remove rule. + (lambda-mat.o): Same. + (lambda-trans.o): Same. + (lambda-code.o): Same. + (tree-vect-loop.o): Add missing dependence on TREE_DATA_REF_H. + (tree-vect-slp.o): Same. + * hwint.h (gcd): Moved here. + (least_common_multiple): Same. + * lambda-code.c: Removed. + * lambda-mat.c: Removed. + * lambda-trans.c: Removed. + * lambda.h: Removed. + * tree-loop-linear.c: Removed. + * lto-symtab.c: Do not include lambda.h. + * omega.c (gcd): Removed. + * passes.c (init_optimization_passes): Remove pass_linear_transform. + * tree-data-ref.c (print_lambda_vector): Moved here. + (lambda_vector_copy): Same. + (lambda_matrix_copy): Same. + (lambda_matrix_id): Same. + (lambda_vector_first_nz): Same. + (lambda_matrix_row_add): Same. + (lambda_matrix_row_exchange): Same. + (lambda_vector_mult_const): Same. + (lambda_vector_negate): Same. + (lambda_matrix_row_negate): Same. + (lambda_vector_equal): Same. + (lambda_matrix_right_hermite): Same. + * tree-data-ref.h: Do not include lambda.h. + (lambda_vector): Moved here. + (lambda_matrix): Same. + (dependence_level): Same. + (lambda_transform_legal_p): Removed declaration. + (lambda_collect_parameters): Same. + (lambda_compute_access_matrices): Same. + (lambda_vector_gcd): Same. + (lambda_vector_new): Same. + (lambda_vector_clear): Same. + (lambda_vector_lexico_pos): Same. + (lambda_vector_zerop): Same. + (lambda_matrix_new): Same. + * tree-flow.h (least_common_multiple): Removed declaration. + * tree-parloops.c (lambda_trans_matrix): Moved here. + (LTM_MATRIX): Same. + (LTM_ROWSIZE): Same. + (LTM_COLSIZE): Same. + (LTM_DENOMINATOR): Same. + (lambda_trans_matrix_new): Same. + (lambda_matrix_vector_mult): Same. + (lambda_transform_legal_p): Same. + * tree-pass.h (pass_linear_transform): Removed declaration. + * tree-ssa-loop.c (tree_linear_transform): Removed. + (gate_tree_linear_transform): Removed. + (pass_linear_transform): Removed. + (gate_graphite_transforms): Make flag_tree_loop_linear an alias of + flag_loop_interchange. + 2011-01-25 Jakub Jelinek PR tree-optimization/47265 diff --git a/gcc/Makefile.in b/gcc/Makefile.in index eeb77e476ad..48b49e9fa51 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 @@ -1279,9 +1278,6 @@ OBJS-common = \ ira-emit.o \ ira-lives.o \ jump.o \ - lambda-code.o \ - lambda-mat.o \ - lambda-trans.o \ langhooks.o \ lcm.o \ lists.o \ @@ -1379,7 +1375,6 @@ OBJS-common = \ tree-into-ssa.o \ tree-iterator.o \ tree-loop-distribution.o \ - tree-loop-linear.o \ tree-nested.o \ tree-nrv.o \ tree-object-size.o \ @@ -2331,7 +2326,7 @@ lto-section-out.o : lto-section-out.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(CGRAPH_H) $(FUNCTION_H) $(GGC_H) $(EXCEPT_H) pointer-set.h \ $(BITMAP_H) langhooks.h $(LTO_STREAMER_H) lto-compress.h lto-symtab.o: lto-symtab.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ - $(TREE_H) $(GIMPLE_H) $(GGC_H) $(LAMBDA_H) $(HASHTAB_H) \ + $(TREE_H) $(GIMPLE_H) $(GGC_H) $(HASHTAB_H) \ $(LTO_STREAMER_H) $(LINKER_PLUGIN_API_H) gt-lto-symtab.h lto-opts.o: lto-opts.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \ $(HASHTAB_H) $(GGC_H) $(BITMAP_H) $(FLAGS_H) $(OPTS_H) $(OPTIONS_H) \ @@ -2711,7 +2706,7 @@ tree-vect-loop.o: tree-vect-loop.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(GGC_H) $(TREE_H) $(BASIC_BLOCK_H) $(DIAGNOSTIC_H) $(TREE_FLOW_H) \ $(TREE_DUMP_H) $(CFGLOOP_H) $(CFGLAYOUT_H) $(EXPR_H) $(RECOG_H) $(OPTABS_H) \ $(DIAGNOSTIC_CORE_H) $(SCEV_H) $(TREE_VECTORIZER_H) tree-pretty-print.h \ - gimple-pretty-print.h $(TARGET_H) + gimple-pretty-print.h $(TARGET_H) $(TREE_DATA_REF_H) tree-vect-loop-manip.o: tree-vect-loop-manip.c $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_H) $(GGC_H) $(TREE_H) $(BASIC_BLOCK_H) $(DIAGNOSTIC_H) \ $(TREE_FLOW_H) $(TREE_DUMP_H) $(CFGLOOP_H) $(CFGLAYOUT_H) $(EXPR_H) $(DIAGNOSTIC_CORE_H) \ @@ -2726,7 +2721,7 @@ tree-vect-slp.o: tree-vect-slp.c $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_H) $(GGC_H) $(TREE_H) $(TARGET_H) $(BASIC_BLOCK_H) \ $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) $(CFGLOOP_H) $(CFGLAYOUT_H) \ $(EXPR_H) $(RECOG_H) $(OPTABS_H) $(TREE_VECTORIZER_H) tree-pretty-print.h \ - gimple-pretty-print.h + gimple-pretty-print.h $(TREE_DATA_REF_H) tree-vect-stmts.o: tree-vect-stmts.c $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_H) $(GGC_H) $(TREE_H) $(TARGET_H) $(BASIC_BLOCK_H) \ $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) $(CFGLOOP_H) $(CFGLAYOUT_H) \ @@ -2742,8 +2737,6 @@ tree-vectorizer.o: tree-vectorizer.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(GGC_H) $(TREE_H) $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) \ $(CFGLOOP_H) $(TREE_PASS_H) $(TREE_VECTORIZER_H) $(TIMEVAR_H) \ tree-pretty-print.h -tree-loop-linear.o: tree-loop-linear.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ - $(TREE_FLOW_H) $(CFGLOOP_H) $(TREE_DATA_REF_H) $(TREE_PASS_H) $(LAMBDA_H) tree-loop-distribution.o: tree-loop-distribution.c $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TREE_FLOW_H) $(CFGLOOP_H) $(TREE_DATA_REF_H) $(TREE_PASS_H) tree-parloops.o: tree-parloops.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ @@ -3462,12 +3455,6 @@ ifcvt.o : ifcvt.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \ $(TARGET_H) $(BASIC_BLOCK_H) $(EXPR_H) output.h $(EXCEPT_H) $(TM_P_H) \ $(OPTABS_H) $(CFGLOOP_H) hard-reg-set.h $(TIMEVAR_H) \ $(TREE_PASS_H) $(DF_H) $(DBGCNT_H) -lambda-mat.o : lambda-mat.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_FLOW_H) \ - $(LAMBDA_H) -lambda-trans.o : lambda-trans.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ - $(TREE_FLOW_H) $(LAMBDA_H) -lambda-code.o : lambda-code.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ - $(TREE_FLOW_H) $(CFGLOOP_H) $(TREE_DATA_REF_H) $(LAMBDA_H) $(TREE_PASS_H) params.o : params.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(PARAMS_H) \ $(DIAGNOSTIC_CORE_H) pointer-set.o: pointer-set.c pointer-set.h $(CONFIG_H) $(SYSTEM_H) diff --git a/gcc/hwint.h b/gcc/hwint.h index 8bd7c5e7bdc..1eadd45da73 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 f46207145c8..00000000000 --- 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 - - 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 - . */ - -#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 . 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++) - { - - } - - } - - 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++) - { - - } - } - - FOR (i = 0; i < 50; i ++) - { - - } - - 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 c57fb58c99b..00000000000 --- a/gcc/lambda-mat.c +++ /dev/null @@ -1,608 +0,0 @@ -/* Integer matrix math routines - Copyright (C) 2003, 2004, 2005, 2007, 2008, 2010 - Free Software Foundation, Inc. - Contributed by Daniel Berlin . - -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 -. */ - -#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 ba1449977ea..00000000000 --- a/gcc/lambda-trans.c +++ /dev/null @@ -1,80 +0,0 @@ -/* Lambda matrix transformations. - Copyright (C) 2003, 2004, 2007, 2008, 2010 Free Software Foundation, Inc. - Contributed by Daniel Berlin . - -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 -. */ - -#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 382b71f7e0d..00000000000 --- a/gcc/lambda.h +++ /dev/null @@ -1,524 +0,0 @@ -/* Lambda matrix and vector interface. - Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 - Free Software Foundation, Inc. - Contributed by Daniel Berlin - -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 -. */ - -#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 b331d5cee61..75732768653 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 aee99e72a84..1717f8e4524 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 d32bccf23ec..90d61e346ec 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -887,7 +887,6 @@ init_optimization_passes (void) NEXT_PASS (pass_record_bounds); NEXT_PASS (pass_check_data_deps); NEXT_PASS (pass_loop_distribution); - NEXT_PASS (pass_linear_transform); NEXT_PASS (pass_copy_prop); NEXT_PASS (pass_graphite); { diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 24fbc0bba06..3234f95485d 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,48 @@ +2011-01-25 Sebastian Pop + + * gfortran.dg/graphite/interchange-4.f: New. + * gfortran.dg/graphite/interchange-5.f: New. + + * gcc.dg/tree-ssa/ltrans-1.c: Removed. + * gcc.dg/tree-ssa/ltrans-2.c: Removed. + * gcc.dg/tree-ssa/ltrans-3.c: Removed. + * gcc.dg/tree-ssa/ltrans-4.c: Removed. + * gcc.dg/tree-ssa/ltrans-5.c: Removed. + * gcc.dg/tree-ssa/ltrans-6.c: Removed. + * gcc.dg/tree-ssa/ltrans-8.c: Removed. + * gfortran.dg/ltrans-7.f90: Removed. + * gcc.dg/tree-ssa/data-dep-1.c: Removed. + + * gcc.dg/pr18792.c: -> gcc.dg/graphite/pr18792.c + * gcc.dg/pr19910.c: -> gcc.dg/graphite/pr19910.c + * gcc.dg/tree-ssa/20041110-1.c: -> gcc.dg/graphite/pr20041110-1.c + * gcc.dg/tree-ssa/pr20256.c: -> gcc.dg/graphite/pr20256.c + * gcc.dg/pr23625.c: -> gcc.dg/graphite/pr23625.c + * gcc.dg/tree-ssa/pr23820.c: -> gcc.dg/graphite/pr23820.c + * gcc.dg/tree-ssa/pr24309.c: -> gcc.dg/graphite/pr24309.c + * gcc.dg/tree-ssa/pr26435.c: -> gcc.dg/graphite/pr26435.c + * gcc.dg/pr29330.c: -> gcc.dg/graphite/pr29330.c + * gcc.dg/pr29581-1.c: -> gcc.dg/graphite/pr29581-1.c + * gcc.dg/pr29581-2.c: -> gcc.dg/graphite/pr29581-2.c + * gcc.dg/pr29581-3.c: -> gcc.dg/graphite/pr29581-3.c + * gcc.dg/pr29581-4.c: -> gcc.dg/graphite/pr29581-4.c + * gcc.dg/tree-ssa/loop-27.c: -> gcc.dg/graphite/pr30565.c + * gcc.dg/tree-ssa/pr31183.c: -> gcc.dg/graphite/pr31183.c + * gcc.dg/tree-ssa/pr33576.c: -> gcc.dg/graphite/pr33576.c + * gcc.dg/tree-ssa/pr33766.c: -> gcc.dg/graphite/pr33766.c + * gcc.dg/pr34016.c: -> gcc.dg/graphite/pr34016.c + * gcc.dg/tree-ssa/pr34017.c: -> gcc.dg/graphite/pr34017.c + * gcc.dg/tree-ssa/pr34123.c: -> gcc.dg/graphite/pr34123.c + * gcc.dg/tree-ssa/pr36287.c: -> gcc.dg/graphite/pr36287.c + * gcc.dg/tree-ssa/pr37686.c: -> gcc.dg/graphite/pr37686.c + * gcc.dg/pr42917.c: -> gcc.dg/graphite/pr42917.c + * gcc.dg/tree-ssa/data-dep-1.c + * gfortran.dg/loop_nest_1.f90: -> gfortran.dg/graphite/pr29290.f90 + * gfortran.dg/pr29581.f90: -> gfortran.dg/graphite/pr29581.f90 + * gfortran.dg/pr36286.f90: -> gfortran.dg/graphite/pr36286.f90 + * gfortran.dg/pr36922.f: -> gfortran.dg/graphite/pr36922.f + * gfortran.dg/pr39516.f: -> gfortran.dg/graphite/pr39516.f + 2011-01-25 Jakub Jelinek PR tree-optimization/47265 diff --git a/gcc/testsuite/gcc.dg/pr18792.c b/gcc/testsuite/gcc.dg/graphite/pr18792.c similarity index 100% rename from gcc/testsuite/gcc.dg/pr18792.c rename to gcc/testsuite/gcc.dg/graphite/pr18792.c diff --git a/gcc/testsuite/gcc.dg/pr19910.c b/gcc/testsuite/gcc.dg/graphite/pr19910.c similarity index 100% rename from gcc/testsuite/gcc.dg/pr19910.c rename to gcc/testsuite/gcc.dg/graphite/pr19910.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c b/gcc/testsuite/gcc.dg/graphite/pr20041110-1.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c rename to gcc/testsuite/gcc.dg/graphite/pr20041110-1.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr20256.c b/gcc/testsuite/gcc.dg/graphite/pr20256.c similarity index 63% rename from gcc/testsuite/gcc.dg/tree-ssa/pr20256.c rename to gcc/testsuite/gcc.dg/graphite/pr20256.c index aa482edab63..29c8ebd14e2 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr20256.c +++ b/gcc/testsuite/gcc.dg/graphite/pr20256.c @@ -1,5 +1,5 @@ -/* { dg-do compile } */ -/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-loop-linear" } */ /* { dg-require-effective-target size32plus } */ int foo() @@ -20,6 +20,3 @@ int foo() return s; } - -/* { dg-final { scan-tree-dump-times "converted loop nest to perfect loop nest" 0 "ltrans"} } */ -/* { dg-final { cleanup-tree-dump "ltrans" } } */ diff --git a/gcc/testsuite/gcc.dg/pr23625.c b/gcc/testsuite/gcc.dg/graphite/pr23625.c similarity index 100% rename from gcc/testsuite/gcc.dg/pr23625.c rename to gcc/testsuite/gcc.dg/graphite/pr23625.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr23820.c b/gcc/testsuite/gcc.dg/graphite/pr23820.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/pr23820.c rename to gcc/testsuite/gcc.dg/graphite/pr23820.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c b/gcc/testsuite/gcc.dg/graphite/pr24309.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/pr24309.c rename to gcc/testsuite/gcc.dg/graphite/pr24309.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c b/gcc/testsuite/gcc.dg/graphite/pr26435.c similarity index 60% rename from gcc/testsuite/gcc.dg/tree-ssa/pr26435.c rename to gcc/testsuite/gcc.dg/graphite/pr26435.c index 907c5d28dc4..4e5e5f74d7a 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c +++ b/gcc/testsuite/gcc.dg/graphite/pr26435.c @@ -1,5 +1,5 @@ -/* { dg-do compile } */ -/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-loop-linear" } */ /* { dg-require-effective-target size32plus } */ int foo(int *p, int n) @@ -15,6 +15,3 @@ int foo(int *p, int n) return k; } - -/* { dg-final { scan-tree-dump-times "converted loop nest to perfect loop nest" 0 "ltrans"} } */ -/* { dg-final { cleanup-tree-dump "ltrans" } } */ diff --git a/gcc/testsuite/gcc.dg/pr29330.c b/gcc/testsuite/gcc.dg/graphite/pr29330.c similarity index 100% rename from gcc/testsuite/gcc.dg/pr29330.c rename to gcc/testsuite/gcc.dg/graphite/pr29330.c diff --git a/gcc/testsuite/gcc.dg/pr29581-1.c b/gcc/testsuite/gcc.dg/graphite/pr29581-1.c similarity index 100% rename from gcc/testsuite/gcc.dg/pr29581-1.c rename to gcc/testsuite/gcc.dg/graphite/pr29581-1.c diff --git a/gcc/testsuite/gcc.dg/pr29581-2.c b/gcc/testsuite/gcc.dg/graphite/pr29581-2.c similarity index 100% rename from gcc/testsuite/gcc.dg/pr29581-2.c rename to gcc/testsuite/gcc.dg/graphite/pr29581-2.c diff --git a/gcc/testsuite/gcc.dg/pr29581-3.c b/gcc/testsuite/gcc.dg/graphite/pr29581-3.c similarity index 100% rename from gcc/testsuite/gcc.dg/pr29581-3.c rename to gcc/testsuite/gcc.dg/graphite/pr29581-3.c diff --git a/gcc/testsuite/gcc.dg/pr29581-4.c b/gcc/testsuite/gcc.dg/graphite/pr29581-4.c similarity index 100% rename from gcc/testsuite/gcc.dg/pr29581-4.c rename to gcc/testsuite/gcc.dg/graphite/pr29581-4.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-27.c b/gcc/testsuite/gcc.dg/graphite/pr30565.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/loop-27.c rename to gcc/testsuite/gcc.dg/graphite/pr30565.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr31183.c b/gcc/testsuite/gcc.dg/graphite/pr31183.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/pr31183.c rename to gcc/testsuite/gcc.dg/graphite/pr31183.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c b/gcc/testsuite/gcc.dg/graphite/pr33576.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/pr33576.c rename to gcc/testsuite/gcc.dg/graphite/pr33576.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c b/gcc/testsuite/gcc.dg/graphite/pr33766.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/pr33766.c rename to gcc/testsuite/gcc.dg/graphite/pr33766.c diff --git a/gcc/testsuite/gcc.dg/pr34016.c b/gcc/testsuite/gcc.dg/graphite/pr34016.c similarity index 100% rename from gcc/testsuite/gcc.dg/pr34016.c rename to gcc/testsuite/gcc.dg/graphite/pr34016.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c b/gcc/testsuite/gcc.dg/graphite/pr34017.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/pr34017.c rename to gcc/testsuite/gcc.dg/graphite/pr34017.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c b/gcc/testsuite/gcc.dg/graphite/pr34123.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/pr34123.c rename to gcc/testsuite/gcc.dg/graphite/pr34123.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c b/gcc/testsuite/gcc.dg/graphite/pr36287.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/pr36287.c rename to gcc/testsuite/gcc.dg/graphite/pr36287.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c b/gcc/testsuite/gcc.dg/graphite/pr37686.c similarity index 100% rename from gcc/testsuite/gcc.dg/tree-ssa/pr37686.c rename to gcc/testsuite/gcc.dg/graphite/pr37686.c diff --git a/gcc/testsuite/gcc.dg/graphite/pr42917.c b/gcc/testsuite/gcc.dg/graphite/pr42917.c new file mode 100644 index 00000000000..eddff3b5844 --- /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/pr42917.c b/gcc/testsuite/gcc.dg/pr42917.c deleted file mode 100644 index d8db32ea2da..00000000000 --- 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/data-dep-1.c b/gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c deleted file mode 100644 index 12e42b7491d..00000000000 --- 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/ltrans-1.c b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c deleted file mode 100644 index bff58f6a41d..00000000000 --- 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 9548bf21706..00000000000 --- 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 d7dd211e9bc..00000000000 --- 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 6682538a2ed..00000000000 --- 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 3540723dc56..00000000000 --- 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 e6a290a6a13..00000000000 --- 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 67569d8a316..00000000000 --- 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/gfortran.dg/graphite/interchange-4.f b/gcc/testsuite/gfortran.dg/graphite/interchange-4.f new file mode 100644 index 00000000000..3d42811bc56 --- /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 00000000000..658f10a74d7 --- /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/loop_nest_1.f90 b/gcc/testsuite/gfortran.dg/graphite/pr29290.f90 similarity index 100% rename from gcc/testsuite/gfortran.dg/loop_nest_1.f90 rename to gcc/testsuite/gfortran.dg/graphite/pr29290.f90 diff --git a/gcc/testsuite/gfortran.dg/pr29581.f90 b/gcc/testsuite/gfortran.dg/graphite/pr29581.f90 similarity index 100% rename from gcc/testsuite/gfortran.dg/pr29581.f90 rename to gcc/testsuite/gfortran.dg/graphite/pr29581.f90 diff --git a/gcc/testsuite/gfortran.dg/pr36286.f90 b/gcc/testsuite/gfortran.dg/graphite/pr36286.f90 similarity index 100% rename from gcc/testsuite/gfortran.dg/pr36286.f90 rename to gcc/testsuite/gfortran.dg/graphite/pr36286.f90 diff --git a/gcc/testsuite/gfortran.dg/pr36922.f b/gcc/testsuite/gfortran.dg/graphite/pr36922.f similarity index 100% rename from gcc/testsuite/gfortran.dg/pr36922.f rename to gcc/testsuite/gfortran.dg/graphite/pr36922.f diff --git a/gcc/testsuite/gfortran.dg/pr39516.f b/gcc/testsuite/gfortran.dg/graphite/pr39516.f similarity index 100% rename from gcc/testsuite/gfortran.dg/pr39516.f rename to gcc/testsuite/gfortran.dg/graphite/pr39516.f diff --git a/gcc/testsuite/gfortran.dg/ltrans-7.f90 b/gcc/testsuite/gfortran.dg/ltrans-7.f90 deleted file mode 100644 index 583edf216ba..00000000000 --- 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/tree-data-ref.c b/gcc/tree-data-ref.c index 5aecbff7fcb..9e5df7d2c75 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 2e7e0e52814..85c2386e7d6 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 682907c2f9d..17208590897 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 5b19c17622c..00000000000 --- 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 . - -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 -. */ - -#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 96759cbfe89..9a11f80d4b0 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 dd822887840..6c551ae7697 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 @@ -431,7 +431,6 @@ extern struct gimple_opt_pass pass_rename_ssa_copies; extern struct gimple_opt_pass pass_rest_of_compilation; extern struct gimple_opt_pass pass_sink_code; extern struct gimple_opt_pass pass_fre; -extern struct gimple_opt_pass pass_linear_transform; extern struct gimple_opt_pass pass_check_data_deps; extern struct gimple_opt_pass pass_copy_prop; extern struct gimple_opt_pass pass_vrp; diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c index 4b51f403c49..5534b6a515a 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,12 +266,17 @@ gate_graphite_transforms (void) is turned on. */ if (flag_loop_block || flag_loop_interchange + || flag_tree_loop_linear || flag_loop_strip_mine || flag_graphite_identity || flag_loop_parallelize_all || flag_loop_flatten) flag_graphite = 1; + /* Make flag_tree_loop_linear an alias of flag_loop_interchange. */ + if (flag_tree_loop_linear) + flag_loop_interchange = flag_tree_loop_linear; + return flag_graphite != 0; }