loop.texi: Document the Omega linear constraints solver.

	* doc/loop.texi: Document the Omega linear constraints solver.
	* doc/invoke.texi: Document -fcheck-data-deps, omega-max-vars,
	omega-max-geqs, omega-max-eqs, omega-max-wild-cards, 
	omega-hash-table-size, omega-max-keys, and 
	omega-eliminate-redundant-constraints.
	* tree-pass.h (pass_check_data_deps): Declared.
	* omega.c: New.
	* omega.h: New.
	* timevar.def (TV_CHECK_DATA_DEPS): Declared.
	* tree-ssa-loop.c (check_data_deps, gate_check_data_deps, 
	pass_check_data_deps): New.
	* tree-data-ref.c (init_data_ref): Remove declaration.
	(dump_data_dependence_relation): Dump DDR_INNER_LOOP.
	(analyze_array): Renamed init_array_ref, move up initializations.
	(init_data_ref): Renamed init_pointer_ref.  Moved before its call.
	Removed arguments that are set to NULL.
	(analyze_indirect_ref): Correct indentation, correct call to 
	init_pointer_ref.
	(object_analysis): Call init_array_ref instead of analyze_array.
	(initialize_data_dependence_relation): Initialize DDR_INNER_LOOP.
	(access_functions_are_affine_or_constant_p): Use DR_ACCESS_FNS instead
	of DR_ACCESS_FNS_ADDR.
	(init_omega_eq_with_af, omega_extract_distance_vectors, 
	omega_setup_subscript, init_omega_for_ddr_1, init_omega_for_ddr,
	ddr_consistent_p): New.
	(compute_affine_dependence): Check consistency of ddrs when 
	flag_check_data_deps is passed.
	(analyze_all_data_dependences): Uncomment.
	(tree_check_data_deps): New.
	* tree-data-ref.h: Include omega.h.
	(DR_ACCESS_FNS_ADDR): Removed.
	(data_dependence_relation): Add inner_loop.
	(DDR_INNER_LOOP): New.
	* common.opt (fcheck-data-deps): New.
	* tree-flow.h (tree_check_data_deps): Declare.
	* Makefile.in (TREE_DATA_REF_H): Depend on omega.h.
	(OBJS-common): Depend on omega.o.
	(omega.o): Define.
	* passes.c (pass_check_data_deps): Scheduled.
	* params.def (PARAM_OMEGA_MAX_VARS, PARAM_OMEGA_MAX_GEQS, 
	PARAM_OMEGA_MAX_EQS, PARAM_OMEGA_MAX_WILD_CARDS,
	PARAM_OMEGA_HASH_TABLE_SIZE, PARAM_OMEGA_MAX_KEYS,
	PARAM_VECT_MAX_VERSION_CHECKS,
	PARAM_OMEGA_ELIMINATE_REDUNDANT_CONSTRAINTS): New.

From-SVN: r122749

gcc/ChangeLog

+2007-03-09  Sebastian Pop  <sebastian.pop@inria.fr>
+
+	* doc/loop.texi: Document the Omega linear constraints solver.
+	* doc/invoke.texi: Document -fcheck-data-deps, omega-max-vars,
+	omega-max-geqs, omega-max-eqs, omega-max-wild-cards, 
+	omega-hash-table-size, omega-max-keys, and 
+	omega-eliminate-redundant-constraints.
+	* tree-pass.h (pass_check_data_deps): Declared.
+	* omega.c: New.
+	* omega.h: New.
+	* timevar.def (TV_CHECK_DATA_DEPS): Declared.
+	* tree-ssa-loop.c (check_data_deps, gate_check_data_deps, 
+	pass_check_data_deps): New.
+	* tree-data-ref.c (init_data_ref): Remove declaration.
+	(dump_data_dependence_relation): Dump DDR_INNER_LOOP.
+	(analyze_array): Renamed init_array_ref, move up initializations.
+	(init_data_ref): Renamed init_pointer_ref.  Moved before its call.
+	Removed arguments that are set to NULL.
+	(analyze_indirect_ref): Correct indentation, correct call to 
+	init_pointer_ref.
+	(object_analysis): Call init_array_ref instead of analyze_array.
+	(initialize_data_dependence_relation): Initialize DDR_INNER_LOOP.
+	(access_functions_are_affine_or_constant_p): Use DR_ACCESS_FNS instead
+	of DR_ACCESS_FNS_ADDR.
+	(init_omega_eq_with_af, omega_extract_distance_vectors, 
+	omega_setup_subscript, init_omega_for_ddr_1, init_omega_for_ddr,
+	ddr_consistent_p): New.
+	(compute_affine_dependence): Check consistency of ddrs when 
+	flag_check_data_deps is passed.
+	(analyze_all_data_dependences): Uncomment.
+	(tree_check_data_deps): New.
+	* tree-data-ref.h: Include omega.h.
+	(DR_ACCESS_FNS_ADDR): Removed.
+	(data_dependence_relation): Add inner_loop.
+	(DDR_INNER_LOOP): New.
+	* common.opt (fcheck-data-deps): New.
+	* tree-flow.h (tree_check_data_deps): Declare.
+	* Makefile.in (TREE_DATA_REF_H): Depend on omega.h.
+	(OBJS-common): Depend on omega.o.
+	(omega.o): Define.
+	* passes.c (pass_check_data_deps): Scheduled.
+	* params.def (PARAM_OMEGA_MAX_VARS, PARAM_OMEGA_MAX_GEQS, 
+	PARAM_OMEGA_MAX_EQS, PARAM_OMEGA_MAX_WILD_CARDS,
+	PARAM_OMEGA_HASH_TABLE_SIZE, PARAM_OMEGA_MAX_KEYS,
+	PARAM_VECT_MAX_VERSION_CHECKS,
+	PARAM_OMEGA_ELIMINATE_REDUNDANT_CONSTRAINTS): New.
+
 2007-03-09  Richard Guenther  <rguenther@suse.de>
 
 	PR tree-optimization/30904

gcc/Makefile.in

@@ -785,7 +785,7 @@ DIAGNOSTIC_H = diagnostic.h diagnostic.def $(PRETTY_PRINT_H) options.h
 C_PRETTY_PRINT_H = 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)
+TREE_DATA_REF_H = tree-data-ref.h $(LAMBDA_H) omega.h
 VARRAY_H = varray.h $(MACHMODE_H) $(SYSTEM_H) coretypes.h $(TM_H)
 TREE_INLINE_H = tree-inline.h $(VARRAY_H) $(SPLAY_TREE_H)
 REAL_H = real.h $(MACHMODE_H)
@@ -1028,6 +1028,7 @@ OBJS-common = \
 	lower-subreg.o \
 	mode-switching.o \
 	modulo-sched.o \
+	omega.o \
 	omp-low.o \
 	optabs.o \
 	options.o \
@@ -2191,6 +2192,8 @@ omp-low.o : omp-low.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
 tree-browser.o : tree-browser.c tree-browser.def $(CONFIG_H) $(SYSTEM_H) \
    $(TREE_H) $(TREE_INLINE_H) $(DIAGNOSTIC_H) $(HASHTAB_H) \
    $(TM_H) coretypes.h
+omega.o : omega.c omega.h $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
+   errors.h $(GGC_H) $(TREE_H) diagnostic.h varray.h tree-pass.h 
 tree-chrec.o: tree-chrec.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
    $(GGC_H) $(TREE_H) $(REAL_H) $(SCEV_H) tree-pass.h $(PARAMS_H) \
    $(DIAGNOSTIC_H) $(CFGLOOP_H) $(TREE_FLOW_H)

gcc/common.opt

@@ -352,6 +352,10 @@ fcaller-saves
 Common Report Var(flag_caller_saves) Optimization
 Save registers around function calls
 
+fcheck-data-deps
+Common Report Var(flag_check_data_deps)
+Compare the results of several data dependence analyzers.
+
 fcommon
 Common Report Var(flag_no_common,0) Optimization
 Do not put uninitialized globals in the common section

gcc/doc/invoke.texi

@@ -350,6 +350,7 @@ Objective-C and Objective-C++ Dialects}.
 -fvariable-expansion-in-unroller @gol
 -ftree-pre  -ftree-ccp  -ftree-dce -ftree-loop-optimize @gol
 -ftree-loop-linear -ftree-loop-im -ftree-loop-ivcanon -fivopts @gol
+-fcheck-data-deps @gol
 -ftree-dominator-opts -ftree-dse -ftree-copyrename -ftree-sink @gol
 -ftree-ch -ftree-sra -ftree-ter -ftree-fre -ftree-vectorize @gol
 -ftree-vect-loop-version -ftree-salias -fipa-pta -fweb @gol
@@ -5447,6 +5448,10 @@ at @option{-O} and higher.
 Perform linear loop transformations on tree.  This flag can improve cache
 performance and allow further loop optimizations to take place.
 
+@item -fcheck-data-deps
+Compare the results of several data dependence analyzers.  This option
+is used for debugging the data dependence analyzers.
+
 @item -ftree-loop-im
 Perform loop invariant motion on trees.  This pass moves only invariants that
 would be hard to handle at RTL level (function calls, operations that expand to
@@ -6450,6 +6455,34 @@ optimization when a new iv is added to the set.
 Bound on size of expressions used in the scalar evolutions analyzer.
 Large expressions slow the analyzer.
 
+@item omega-max-vars
+The maximum number of variables in an Omega constraint system.
+The default value is 128.
+
+@item omega-max-geqs
+The maximum number of inequalities in an Omega constraint system.
+The default value is 256.
+
+@item omega-max-eqs
+The maximum number of equalities in an Omega constraint system.
+The default value is 128.
+
+@item omega-max-wild-cards
+The maximum number of wildcard variables that the Omega solver will
+be able to insert.  The default value is 18.
+
+@item omega-hash-table-size
+The size of the hash table in the Omega solver.  The default value is
+550.
+
+@item omega-max-keys
+The maximal number of keys used by the Omega solver.  The default
+value is 500.
+
+@item omega-eliminate-redundant-constraints
+When set to 1, use expensive methods to eliminate all redundant
+constraints.  The default value is 0.
+
 @item vect-max-version-checks
 The maximum number of runtime checks that can be performed when doing
 loop versioning in the vectorizer.  See option ftree-vect-loop-version

gcc/doc/loop.texi

@@ -26,6 +26,7 @@ variable analysis and number of iterations analysis).
 * Number of iterations::	Number of iterations analysis.
 * Dependency analysis::		Data dependency analysis.
 * Lambda::			Linear loop transformations framework.
+* Omega::			A solver for linear programming problems.
 @end menu
 
 @node Loop representation
@@ -623,3 +624,32 @@ Given a transformed loopnest, conversion back into gcc IR is done by
 @code{lambda_loopnest_to_gcc_loopnest}.  This function will modify the
 loops so that they match the transformed loopnest.
 
+
+@node Omega
+@section Omega a solver for linear programming problems
+@cindex Omega a solver for linear programming problems
+
+The data dependence analysis contains several solvers triggered
+sequentially from the less complex ones to the more sophisticated.
+For ensuring the consistency of the results of these solvers, a data
+dependence check pass has been implemented based on two different
+solvers.  The second method that has been integrated to GCC is based
+on the Omega dependence solver, written in the 1990's by William Pugh
+and David Wonnacott.  Data dependence tests can be formulated using a
+subset of the Presburger arithmetics that can be translated to linear
+constraint systems.  These linear constraint systems can then be
+solved using the Omega solver.
+
+The Omega solver is using Fourier-Motzkin's algorithm for variable
+elimination: a linear constraint system containing @code{n} variables
+is reduced to a linear constraint system with @code{n-1} variables.
+The Omega solver can also be used for solving other problems that can
+be expressed under the form of a system of linear equalities and
+inequalities.  The Omega solver is known to have an exponential worst
+case, also known under the name of ``omega nightmare'' in the
+literature, but in practice, the omega test is known to be efficient
+for the common data dependence tests.
+
+The interface used by the Omega solver for describing the linear
+programming problems is described in @file{omega.h}, and the solver is
+@code{omega_solve_problem}.  

gcc/omega.h

+/* Source code for an implementation of the Omega test, a integer 
+   programming algorithm for dependence analysis, by William Pugh, 
+   appeared in Supercomputing '91 and CACM Aug 92.
+
+   This code has no license restrictions, and is considered public
+   domain.
+
+   Changes copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+   Contributed by Sebastian Pop <sebastian.pop@inria.fr>
+
+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 2, 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 COPYING.  If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.  */
+
+#include "config.h"
+#include "params.h"
+
+#ifndef GCC_OMEGA_H
+#define GCC_OMEGA_H
+
+#define OMEGA_MAX_VARS PARAM_VALUE (PARAM_OMEGA_MAX_VARS)
+#define OMEGA_MAX_GEQS PARAM_VALUE (PARAM_OMEGA_MAX_GEQS)
+#define OMEGA_MAX_EQS PARAM_VALUE (PARAM_OMEGA_MAX_EQS)
+
+#define pos_infinity (0x7ffffff)
+#define neg_infinity (-0x7ffffff)
+
+/* Results of the Omega solver.  */
+enum omega_result {
+  omega_false = 0,
+  omega_true = 1,
+
+  /* Value returned when the solver is unable to determine an
+     answer.  */
+  omega_unknown = 2,
+
+  /* Value used for asking the solver to simplify the system.  */
+  omega_simplify = 3
+};
+
+/* Values used for labeling equations.  Private (not used outside the
+   solver).  */
+enum omega_eqn_color { 
+  omega_black = 0,
+  omega_red = 1
+};
+
+/* Structure for equations.  */
+typedef struct eqn
+{
+  int key;
+  int touched;
+  enum omega_eqn_color color;
+
+  /* Array of coefficients for the equation.  The layout of the data
+     is as follows: coef[0] is the constant, coef[i] for 1 <= i <=
+     OMEGA_MAX_VARS, are the coefficients for each dimension.  Examples:
+     the equation 0 = 9 + x + 0y + 5z is encoded as [9 1 0 5], the
+     inequality 0 <= -8 + x + 2y + 3z is encoded as [-8 1 2 3].  */
+  int *coef;
+} *eqn;
+
+typedef struct omega_pb
+{
+  /* The number of variables in the system of equations.  */
+  int num_vars;
+  
+  /* Safe variables are not eliminated during the Fourier-Motzkin
+     simplification of the system.  Safe variables are all those
+     variables that are placed at the beginning of the array of
+     variables: PB->var[1, ..., SAFE_VARS].  PB->var[0] is not used,
+     as PB->eqs[x]->coef[0] represents the constant of the equation.  */
+  int safe_vars;
+
+  /* Number of elements in eqs[].  */
+  int num_eqs;
+  /* Number of elements in geqs[].  */
+  int num_geqs;
+  /* Number of elements in subs[].  */
+  int num_subs;
+
+  int hash_version;
+  bool variables_initialized;
+  bool variables_freed;
+
+  /* Index or name of variables.  Negative integers are reserved for
+     wildcard variables.  Maps the index of variables in the original
+     problem to the new index of the variable.  The index for a
+     variable in the coef array of an equation can change as some
+     variables are eliminated.  */
+  int *var;
+
+  int *forwarding_address;
+
+  /* Inequalities in the system of constraints.  */
+  eqn geqs;
+
+  /* Equations in the system of constraints.  */
+  eqn eqs;
+
+  /* A map of substituted variables.  */
+  eqn subs;
+} *omega_pb;
+
+extern void omega_initialize (void);
+extern omega_pb omega_alloc_problem (int, int);
+extern enum omega_result omega_solve_problem (omega_pb, enum omega_result);
+extern enum omega_result omega_simplify_problem (omega_pb);
+extern enum omega_result omega_simplify_approximate (omega_pb);
+extern enum omega_result omega_constrain_variable_sign (omega_pb,
+							enum omega_eqn_color,
+							int, int);
+extern void debug_omega_problem (omega_pb);
+extern void omega_print_problem (FILE *, omega_pb);
+extern void omega_print_red_equations (FILE *, omega_pb);
+extern int omega_count_red_equations (omega_pb);
+extern void omega_pretty_print_problem (FILE *, omega_pb);
+extern void omega_unprotect_variable (omega_pb, int var);
+extern void omega_negate_geq (omega_pb, int);
+extern void omega_convert_eq_to_geqs (omega_pb, int eq);
+extern void omega_print_eqn (FILE *, omega_pb, eqn, bool, int);
+extern bool omega_problem_has_red_equations (omega_pb);
+extern enum omega_result omega_eliminate_redundant (omega_pb, bool);
+extern void omega_eliminate_red (omega_pb, bool);
+extern void omega_constrain_variable_value (omega_pb, enum omega_eqn_color,
+					    int, int);
+extern bool omega_query_variable (omega_pb, int, int *, int *);
+extern int omega_query_variable_signs (omega_pb, int, int, int, int,
+				       int, int, bool *, int *);
+extern bool omega_query_variable_bounds (omega_pb, int, int *, int *);
+extern void (*omega_when_reduced) (omega_pb);
+extern void omega_no_procedure (omega_pb);
+
+/* Return true when variable I in problem PB is a wildcard.  */
+
+static inline bool
+omega_wildcard_p (omega_pb pb, int i)
+{
+  return (pb->var[i] < 0);
+}
+
+/* Return true when variable I in problem PB is a safe variable.  */
+
+static inline bool
+omega_safe_var_p (omega_pb pb, int i)
+{
+  /* The constant of an equation is not a variable.  */
+  gcc_assert (0 < i);
+  return (i <= pb->safe_vars);
+}
+
+/* Print to FILE equality E from PB.  */
+
+static inline void
+omega_print_eq (FILE *file, omega_pb pb, eqn e)
+{
+  omega_print_eqn (file, pb, e, false, 0);
+}
+
+/* Print to FILE inequality E from PB.  */
+
+static inline void
+omega_print_geq (FILE *file, omega_pb pb, eqn e)
+{
+  omega_print_eqn (file, pb, e, true, 0);
+}
+
+/* Print to FILE inequality E from PB.  */
+
+static inline void
+omega_print_geq_extra (FILE *file, omega_pb pb, eqn e)
+{
+  omega_print_eqn (file, pb, e, true, 1);
+}
+
+/* E1 = E2, make a copy of E2 into E1.  Equations contain S variables.  */
+
+static inline void
+omega_copy_eqn (eqn e1, eqn e2, int s)
+{
+  e1->key = e2->key;
+  e1->touched = e2->touched;
+  e1->color = e2->color;
+
+  memcpy (e1->coef, e2->coef, (s + 1) * sizeof (int));
+}
+
+/* Intialize E = 0.  Equation E contains S variables.  */
+
+static inline void
+omega_init_eqn_zero (eqn e, int s)
+{
+  e->key = 0;
+  e->touched = 0;
+  e->color = omega_black;
+
+  memset (e->coef, 0, (s + 1) * sizeof (int));
+}
+
+/* Allocate N equations with S variables.  */
+
+static inline eqn
+omega_alloc_eqns (int s, int n)
+{
+  int i;
+  eqn res = (eqn) (xcalloc (n, sizeof (struct eqn)));
+
+  for (i = n - 1; i >= 0; i--)
+    {
+      res[i].coef = (int *) (xcalloc (OMEGA_MAX_VARS + 1, sizeof (int)));
+      omega_init_eqn_zero (&res[i], s);
+    }
+
+  return res;
+}
+
+/* Free N equations from array EQ.  */
+
+static inline void
+omega_free_eqns (eqn eq, int n)
+{
+  int i;
+
+  for (i = n - 1; i >= 0; i--)
+    free (eq[i].coef);
+
+  free (eq);
+}
+
+/* Returns true when E is an inequality with a single variable.  */
+
+static inline bool
+single_var_geq (eqn e, int nv ATTRIBUTE_UNUSED)
+{
+  return (e->key != 0
+	  && -OMEGA_MAX_VARS <= e->key && e->key <= OMEGA_MAX_VARS);
+}
+
+/* Allocate a new equality with all coefficients 0, and tagged with
+   COLOR.  Return the index of this equality in problem PB.  */
+
+static inline int
+omega_add_zero_eq (omega_pb pb, enum omega_eqn_color color)
+{
+  int idx = pb->num_eqs++;
+
+  gcc_assert (pb->num_eqs <= OMEGA_MAX_EQS);
+  omega_init_eqn_zero (&pb->eqs[idx], pb->num_vars);
+  pb->eqs[idx].color = color;
+  return idx;
+}
+
+/* Allocate a new inequality with all coefficients 0, and tagged with
+   COLOR.  Return the index of this inequality in problem PB.  */
+
+static inline int
+omega_add_zero_geq (omega_pb pb, enum omega_eqn_color color)
+{
+  int idx = pb->num_geqs;
+
+  pb->num_geqs++;
+  gcc_assert (pb->num_geqs <= OMEGA_MAX_GEQS);
+  omega_init_eqn_zero (&pb->geqs[idx], pb->num_vars);
+  pb->geqs[idx].touched = 1;
+  pb->geqs[idx].color = color;
+  return idx;
+}
+
+/* Initialize variables for problem PB.  */
+
+static inline void
+omega_initialize_variables (omega_pb pb)
+{
+  int i;
+
+  for (i = pb->num_vars; i >= 0; i--)
+    pb->forwarding_address[i] = pb->var[i] = i;
+
+  pb->variables_initialized = true;
+}
+
+/* Free problem PB.  */
+
+static inline void
+omega_free_problem (omega_pb pb)
+{
+  free (pb->var);
+  free (pb->forwarding_address);
+  omega_free_eqns (pb->geqs, OMEGA_MAX_GEQS);
+  omega_free_eqns (pb->eqs, OMEGA_MAX_EQS);
+  omega_free_eqns (pb->subs, OMEGA_MAX_VARS + 1);
+  free (pb);
+}
+
+/* Copy omega problems: P1 = P2.  */
+
+static inline void
+omega_copy_problem (omega_pb p1, omega_pb p2)
+{
+  int e, i;
+
+  p1->num_vars = p2->num_vars;
+  p1->hash_version = p2->hash_version;
+  p1->variables_initialized = p2->variables_initialized;
+  p1->variables_freed = p2->variables_freed;
+  p1->safe_vars = p2->safe_vars;
+  p1->num_eqs = p2->num_eqs;
+  p1->num_subs = p2->num_subs;
+  p1->num_geqs = p2->num_geqs;
+
+  for (e = p2->num_eqs - 1; e >= 0; e--)
+    omega_copy_eqn (&(p1->eqs[e]), &(p2->eqs[e]), p2->num_vars);
+
+  for (e = p2->num_geqs - 1; e >= 0; e--)
+    omega_copy_eqn (&(p1->geqs[e]), &(p2->geqs[e]), p2->num_vars);
+
+  for (e = p2->num_subs - 1; e >= 0; e--)
+    omega_copy_eqn (&(p1->subs[e]), &(p2->subs[e]), p2->num_vars);
+
+  for (i = p2->num_vars; i >= 0; i--)
+    p1->var[i] = p2->var[i];
+
+  for (i = OMEGA_MAX_VARS; i >= 0; i--)
+    p1->forwarding_address[i] = p2->forwarding_address[i];
+}
+
+#endif /* GCC_OMEGA_H */

gcc/params.def

 /* params.def - Run-time parameters.
-   Copyright (C) 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 
+   Free Software Foundation, Inc.
    Written by Mark Mitchell <mark@codesourcery.com>.
 
 This file is part of GCC.
@@ -452,6 +453,41 @@ DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE,
 	 "Bound on size of expressions used in the scalar evolutions analyzer",
 	 20, 0, 0)
 
+DEFPARAM(PARAM_OMEGA_MAX_VARS,
+ 	 "omega-max-vars",
+	 "Bound on the number of variables in Omega constraint systems",
+	 128, 0, 0)
+
+DEFPARAM(PARAM_OMEGA_MAX_GEQS,
+ 	 "omega-max-geqs",
+	 "Bound on the number of inequalities in Omega constraint systems",
+	 256, 0, 0)
+
+DEFPARAM(PARAM_OMEGA_MAX_EQS,
+ 	 "omega-max-eqs",
+	 "Bound on the number of equalities in Omega constraint systems",
+	 128, 0, 0)
+
+DEFPARAM(PARAM_OMEGA_MAX_WILD_CARDS,
+ 	 "omega-max-wild-cards",
+	 "Bound on the number of wild cards in Omega constraint systems",
+	 18, 0, 0)
+
+DEFPARAM(PARAM_OMEGA_HASH_TABLE_SIZE,
+ 	 "omega-hash-table-size",
+	 "Bound on the size of the hash table in Omega constraint systems",
+	 550, 0, 0)
+
+DEFPARAM(PARAM_OMEGA_MAX_KEYS,
+ 	 "omega-max-keys",
+	 "Bound on the number of keys in Omega constraint systems",
+	 500, 0, 0)
+
+DEFPARAM(PARAM_OMEGA_ELIMINATE_REDUNDANT_CONSTRAINTS,
+ 	 "omega-eliminate-redundant-constraints",
+	 "When set to 1, use expensive methods to eliminate all redundant constraints",
+	 0, 0, 1)
+
 DEFPARAM(PARAM_VECT_MAX_VERSION_CHECKS,
          "vect-max-version-checks",
          "Bound on number of runtime checks inserted by the vectorizer's loop versioning",

gcc/passes.c

@@ -590,6 +590,7 @@ init_optimization_passes (void)
 	  NEXT_PASS (pass_scev_cprop);
 	  NEXT_PASS (pass_empty_loop);
 	  NEXT_PASS (pass_record_bounds);
+	  NEXT_PASS (pass_check_data_deps);
 	  NEXT_PASS (pass_linear_transform);
 	  NEXT_PASS (pass_iv_canon);
 	  NEXT_PASS (pass_if_conversion);

gcc/timevar.def

@@ -109,6 +109,7 @@ DEFTIMEVAR (TV_TREE_LOOP_UNSWITCH    , "tree loop unswitching")
 DEFTIMEVAR (TV_COMPLETE_UNROLL       , "complete unrolling")
 DEFTIMEVAR (TV_TREE_VECTORIZATION    , "tree vectorization")
 DEFTIMEVAR (TV_TREE_LINEAR_TRANSFORM , "tree loop linear")
+DEFTIMEVAR (TV_CHECK_DATA_DEPS       , "tree check data dependences")
 DEFTIMEVAR (TV_TREE_PREFETCH	     , "tree prefetching")
 DEFTIMEVAR (TV_TREE_LOOP_IVOPTS	     , "tree iv optimization")
 DEFTIMEVAR (TV_TREE_LOOP_INIT	     , "tree loop init")

gcc/tree-data-ref.h

 /* Data references and dependences detectors. 
-   Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
    Contributed by Sebastian Pop <pop@cri.ensmp.fr>
 
 This file is part of GCC.
@@ -23,6 +23,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #define GCC_TREE_DATA_REF_H
 
 #include "lambda.h"
+#include "omega.h"
 
 /*
   The first location accessed by data-ref in the loop is the address of data-ref's 
@@ -160,10 +161,6 @@ DEF_VEC_ALLOC_P (data_reference_p, heap);
 #define DR_OFFSET_MISALIGNMENT(DR) (DR)->misalignment
 #define DR_PTR_INFO(DR)            (DR)->ptr_info
 #define DR_SUBVARS(DR)             (DR)->subvars
-
-#define DR_ACCESS_FNS_ADDR(DR)       \
-  (DR_TYPE(DR) == ARRAY_REF_TYPE ?   \
-   &((DR)->object_info.access_fns) : &((DR)->first_location.access_fns))
 #define DR_SET_ACCESS_FNS(DR, ACC_FNS)         \
 {                                              \
   if (DR_TYPE(DR) == ARRAY_REF_TYPE)           \
@@ -281,6 +278,10 @@ struct data_dependence_relation
   /* The analyzed loop nest.  */
   VEC (loop_p, heap) *loop_nest;
 
+  /* An index in loop_nest for the innermost loop that varies for
+     this data dependence relation.  */
+  unsigned inner_loop;
+
   /* The classic direction vector.  */
   VEC (lambda_vector, heap) *dir_vects;
 
@@ -304,6 +305,7 @@ DEF_VEC_ALLOC_P(ddr_p,heap);
 /* The size of the direction/distance vectors: the number of loops in
    the loop nest.  */
 #define DDR_NB_LOOPS(DDR) (VEC_length (loop_p, DDR_LOOP_NEST (DDR)))
+#define DDR_INNER_LOOP(DDR) DDR->inner_loop
 
 #define DDR_DIST_VECTS(DDR) ((DDR)->dist_vects)
 #define DDR_DIR_VECTS(DDR) ((DDR)->dir_vects)

gcc/tree-flow.h

 /* Data and Control Flow Analysis for Trees.
-   Copyright (C) 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007
+   Free Software Foundation, Inc.
    Contributed by Diego Novillo <dnovillo@redhat.com>
 
 This file is part of GCC.
@@ -993,6 +994,9 @@ bool sra_type_can_be_decomposed_p (tree);
 /* In tree-loop-linear.c  */
 extern void linear_transform_loops (void);
 
+/* In tree-data-ref.c  */
+extern void tree_check_data_deps (void);
+
 /* In tree-ssa-loop-ivopts.c  */
 bool expr_invariant_in_loop_p (struct loop *, tree);
 bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode);

gcc/tree-pass.h

@@ -298,6 +298,7 @@ extern struct tree_opt_pass pass_rest_of_compilation;
 extern struct tree_opt_pass pass_sink_code;
 extern struct tree_opt_pass pass_fre;
 extern struct tree_opt_pass pass_linear_transform;
+extern struct tree_opt_pass pass_check_data_deps;
 extern struct tree_opt_pass pass_copy_prop;
 extern struct tree_opt_pass pass_store_ccp;
 extern struct tree_opt_pass pass_store_copy_prop;

gcc/tree-ssa-loop.c

 /* Loop optimizations over tree-ssa.
-   Copyright (C) 2003, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2005, 2006, 2007 Free Software Foundation, Inc.
    
 This file is part of GCC.
    
@@ -241,6 +241,41 @@ struct tree_opt_pass pass_linear_transform =
   0				        /* letter */	
 };
 
+/* Check the correctness of the data dependence analyzers.  */
+
+static unsigned int
+check_data_deps (void)
+{
+  if (!current_loops)
+    return 0;
+
+  tree_check_data_deps ();
+  return 0;
+}
+
+static bool
+gate_check_data_deps (void)
+{
+  return flag_check_data_deps != 0;
+}
+
+struct tree_opt_pass pass_check_data_deps =
+{
+  "ckdd",				/* name */
+  gate_check_data_deps,	        	/* gate */
+  check_data_deps,       		/* execute */
+  NULL,					/* sub */
+  NULL,					/* next */
+  0,					/* static_pass_number */
+  TV_CHECK_DATA_DEPS,  	        	/* tv_id */
+  PROP_cfg | PROP_ssa,			/* properties_required */
+  0,					/* properties_provided */
+  0,					/* properties_destroyed */
+  0,					/* todo_flags_start */
+  TODO_dump_func,                	/* todo_flags_finish */
+  0				        /* letter */	
+};
+
 /* Canonical induction variable creation pass.  */
 
 static unsigned int