CbC/CbC_gcc: gcc/tree-data-ref.c comparison

comparison gcc/tree-data-ref.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 /* This pass walks a given loop structure searching for array
 references.  The information about the array accesses is recorded
 in DATA_REFERENCE structures.
 The basic test for determining the dependences is:
 given two access functions chrec1 and chrec2 to a same array, and
 x and y two vectors from the iteration domain, the same element of
 the array is accessed twice at iterations x and y if and only if:
 |             chrec1 (x) == chrec2 (y).
 The goals of this analysis are:
 - to determine the independence: the relation between two
 independent accesses is qualified with the chrec_known (this
 information allows a loop parallelization),
 - when two data references access the same data, to qualify the
 dependence relation with classic dependence representations:
 - distance vectors
 - direction vectors
 - loop carried level dependence
 - polyhedron dependence
 or with the chains of recurrences based representation,
 - to define a knowledge base for storing the data dependence
 information,
 - to define an interface to access this data.
 Definitions:
 - subscript: given two array accesses a subscript is the tuple
 composed of the access functions for a given dimension.  Example:
 Given A[f1][f2][f3] and B[g1][g2][g3], there are three subscripts:
 (f1, g1), (f2, g2), (f3, g3).
 - Diophantine equation: an equation whose coefficients and
 solutions are integer constants, for example the equation
 |   3*x + 2*y = 1
 has an integer solution x = 1 and y = -1.
 References:
 - "Advanced Compilation for High Performance Computing" by Randy
 Allen and Ken Kennedy.
 http://citeseer.ist.psu.edu/goff91practical.html
 - "Loop Transformations for Restructuring Compilers - The Foundations"
 by Utpal Banerjee.
 */
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 					   struct data_reference *,
 					   struct data_reference *,
 					   struct loop *);
 /* Returns true iff A divides B.  */
 static inline bool
 tree_fold_divides_p (const_tree a, const_tree b)
 {
 gcc_assert (TREE_CODE (a) == INTEGER_CST);
 gcc_assert (TREE_CODE (b) == INTEGER_CST);
 return integer_zerop (int_const_binop (TRUNC_MOD_EXPR, b, a, 0));
 }
 /* Returns true iff A divides B.  */
 static inline bool
 int_divides_p (int a, int b)
 {
 return ((b % a) == 0);
 }
 /* Dump into FILE all the data references from DATAREFS.  */
 void
 dump_data_references (FILE *file, VEC (data_reference_p, heap) *datarefs)
 {
 unsigned int i;
 struct data_reference *dr;
 for (i = 0; VEC_iterate (data_reference_p, datarefs, i, dr); i++)
 dump_data_reference (file, dr);
 }
-/* Dump to STDERR all the dependence relations from DDRS.  */
+/* Dump into STDERR all the data references from DATAREFS.  */
 void
+debug_data_references (VEC (data_reference_p, heap) *datarefs)
+{
+dump_data_references (stderr, datarefs);
+}
+/* Dump to STDERR all the dependence relations from DDRS.  */
+void
 debug_data_dependence_relations (VEC (ddr_p, heap) *ddrs)
 {
 dump_data_dependence_relations (stderr, ddrs);
 }
 /* Dump into FILE all the dependence relations from DDRS.  */
 void
 dump_data_dependence_relations (FILE *file,
 				VEC (ddr_p, heap) *ddrs)
 {
 unsigned int i;
 struct data_dependence_relation *ddr;
 for (i = 0; VEC_iterate (ddr_p, ddrs, i, ddr); i++)
 dump_data_dependence_relation (file, ddr);
 }
+/* Print to STDERR the data_reference DR.  */
+void
+debug_data_reference (struct data_reference *dr)
+{
+dump_data_reference (stderr, dr);
+}
 /* Dump function for a DATA_REFERENCE structure.  */
 void
 dump_data_reference (FILE *outf,
 		     struct data_reference *dr)
 {
 unsigned int i;
 fprintf (outf, "(Data Ref: \n  stmt: ");
 print_gimple_stmt (outf, DR_STMT (dr), 0, 0);
 fprintf (outf, "  ref: ");
 print_generic_stmt (outf, DR_REF (dr), 0);
 fprintf (outf, "  base_object: ");
 print_generic_stmt (outf, DR_BASE_OBJECT (dr), 0);
 for (i = 0; i < DR_NUM_DIMENSIONS (dr); i++)
 {
 fprintf (outf, "  Access function %d: ", i);
 print_generic_stmt (outf, DR_ACCESS_FN (dr, i), 0);
 }
 }
 }
 /* Dump function for a SUBSCRIPT structure.  */
 void
 dump_subscript (FILE *outf, struct subscript *subscript)
 {
 conflict_function *cf = SUB_CONFLICTS_IN_A (subscript);
 fprintf (outf, "\n (subscript \n");
 {
 tree last_iteration = SUB_LAST_CONFLICT (subscript);
 fprintf (outf, "  last_conflict: ");
 print_generic_stmt (outf, last_iteration, 0);
 }
 cf = SUB_CONFLICTS_IN_B (subscript);
 fprintf (outf, "  iterations_that_access_an_element_twice_in_B: ");
 dump_conflict_function (outf, cf);
 if (CF_NONTRIVIAL_P (cf))
 {
 {
 int eq;
 for (eq = 0; eq < length; eq++)
 {
-enum data_dependence_direction dir = dirv[eq];
+enum data_dependence_direction dir = ((enum data_dependence_direction)
+					    dirv[eq]);
 switch (dir)
 	{
 	case dir_positive:
 	  fprintf (outf, "    +");
 print_lambda_vector (outf, v, length);
 }
 /* Debug version.  */
 void
 debug_data_dependence_relation (struct data_dependence_relation *ddr)
 {
 dump_data_dependence_relation (stderr, ddr);
 }
 /* Dump function for a DATA_DEPENDENCE_RELATION structure.  */
 void
 dump_data_dependence_relation (FILE *outf,
 			       struct data_dependence_relation *ddr)
 {
 struct data_reference *dra, *drb;
 fprintf (outf, "(Data Dep: \n");
 dump_data_reference (outf, dra);
 dump_data_reference (outf, drb);
 if (DDR_ARE_DEPENDENT (ddr) == chrec_known)
 fprintf (outf, "    (no dependence)\n");
 else if (DDR_ARE_DEPENDENT (ddr) == NULL_TREE)
 {
 unsigned int i;
 struct loop *loopi;
 }
 /* Dump function for a DATA_DEPENDENCE_DIRECTION structure.  */
 void
 dump_data_dependence_direction (FILE *file,
 				enum data_dependence_direction dir)
 {
 switch (dir)
 {
 case dir_positive:
 fprintf (file, "+");
 break;
 case dir_negative:
 fprintf (file, "-");
 break;
 case dir_equal:
 fprintf (file, "=");
 break;
 case dir_positive_or_negative:
 fprintf (file, "+-");
 break;
 case dir_positive_or_equal:
 fprintf (file, "+=");
 break;
 case dir_negative_or_equal:
 fprintf (file, "-=");
 break;
 case dir_star:
 fprintf (file, "*");
 break;
 default:
 break;
 }
 }
 /* Dumps the distance and direction vectors in FILE.  DDRS contains
 the dependence relations, and VECT_SIZE is the size of the
 dependence vectors, or in other words the number of loops in the
 considered nest.  */
 void
 dump_dist_dir_vectors (FILE *file, VEC (ddr_p, heap) *ddrs)
 {
 unsigned int i, j;
 struct data_dependence_relation *ddr;
 lambda_vector v;
 fprintf (file, "\n\n");
 }
 /* Dumps the data dependence relations DDRS in FILE.  */
 void
 dump_ddrs (FILE *file, VEC (ddr_p, heap) *ddrs)
 {
 unsigned int i;
 struct data_dependence_relation *ddr;
 return addr;
 return build_fold_addr_expr (TREE_OPERAND (addr, 0));
 }
-/* Analyzes the behavior of the memory reference DR in the innermost loop that
+/* Analyzes the behavior of the memory reference DR in the innermost loop or
-contains it. Returns true if analysis succeed or false otherwise.  */
+basic block that contains it. Returns true if analysis succeed or false
+otherwise.  */
 bool
 dr_analyze_innermost (struct data_reference *dr)
 {
 gimple stmt = DR_STMT (dr);
 tree base, poffset;
 enum machine_mode pmode;
 int punsignedp, pvolatilep;
 affine_iv base_iv, offset_iv;
 tree init, dinit, step;
+bool in_loop = (loop && loop->num);
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, "analyze_innermost: ");
 base = get_inner_reference (ref, &pbitsize, &pbitpos, &poffset,
 	fprintf (dump_file, "failed: bit offset alignment.\n");
 return false;
 }
 base = build_fold_addr_expr (base);
-if (!simple_iv (loop, loop_containing_stmt (stmt), base, &base_iv, false))
+if (in_loop)
 {
-if (dump_file && (dump_flags & TDF_DETAILS))
+if (!simple_iv (loop, loop_containing_stmt (stmt), base, &base_iv,
-	fprintf (dump_file, "failed: evolution of base is not affine.\n");
+false))
-return false;
+{
-}
+if (dump_file && (dump_flags & TDF_DETAILS))
+	    fprintf (dump_file, "failed: evolution of base is not affine.\n");
+return false;
+}
+}
+else
+{
+base_iv.base = base;
+base_iv.step = ssize_int (0);
+base_iv.no_overflow = true;
+}
 if (!poffset)
 {
 offset_iv.base = ssize_int (0);
 offset_iv.step = ssize_int (0);
 }
-else if (!simple_iv (loop, loop_containing_stmt (stmt),
+else
-		       poffset, &offset_iv, false))
+{
-{
+if (!in_loop)
-if (dump_file && (dump_flags & TDF_DETAILS))
+{
-	fprintf (dump_file, "failed: evolution of offset is not affine.\n");
+offset_iv.base = poffset;
-return false;
+offset_iv.step = ssize_int (0);
+}
+else if (!simple_iv (loop, loop_containing_stmt (stmt),
+poffset, &offset_iv, false))
+{
+if (dump_file && (dump_flags & TDF_DETAILS))
+fprintf (dump_file, "failed: evolution of offset is not"
+" affine.\n");
+return false;
+}
 }
 init = ssize_int (pbitpos / BITS_PER_UNIT);
 split_constant_offset (base_iv.base, &base_iv.base, &dinit);
 init =  size_binop (PLUS_EXPR, init, dinit);
 {
 gimple stmt = DR_STMT (dr);
 struct loop *loop = loop_containing_stmt (stmt);
 VEC (tree, heap) *access_fns = NULL;
 tree ref = unshare_expr (DR_REF (dr)), aref = ref, op;
-tree base, off, access_fn;
+tree base, off, access_fn = NULL_TREE;
-basic_block before_loop = block_before_loop (nest);
+basic_block before_loop = NULL;
+if (nest)
+before_loop = block_before_loop (nest);
 while (handled_component_p (aref))
 {
 if (TREE_CODE (aref) == ARRAY_REF)
 	{
 	  op = TREE_OPERAND (aref, 1);
-	  access_fn = analyze_scalar_evolution (loop, op);
+	  if (nest)
-	  access_fn = instantiate_scev (before_loop, loop, access_fn);
+	    {
-	  VEC_safe_push (tree, heap, access_fns, access_fn);
+	      access_fn = analyze_scalar_evolution (loop, op);
+	      access_fn = instantiate_scev (before_loop, loop, access_fn);
+	      VEC_safe_push (tree, heap, access_fns, access_fn);
+	    }
 	  TREE_OPERAND (aref, 1) = build_int_cst (TREE_TYPE (op), 0);
 	}
 aref = TREE_OPERAND (aref, 0);
 }
-if (INDIRECT_REF_P (aref))
+if (nest && INDIRECT_REF_P (aref))
 {
 op = TREE_OPERAND (aref, 0);
 access_fn = analyze_scalar_evolution (loop, op);
 access_fn = instantiate_scev (before_loop, loop, access_fn);
 base = initial_condition (access_fn);
 /* Extracts the alias analysis information from the memory reference DR.  */
 static void
 dr_analyze_alias (struct data_reference *dr)
 {
-gimple stmt = DR_STMT (dr);
 tree ref = DR_REF (dr);
-tree base = get_base_address (ref), addr, smt = NULL_TREE;
+tree base = get_base_address (ref), addr;
-ssa_op_iter it;
-tree op;
+if (INDIRECT_REF_P (base))
-bitmap vops;
-if (DECL_P (base))
-smt = base;
-else if (INDIRECT_REF_P (base))
 {
 addr = TREE_OPERAND (base, 0);
 if (TREE_CODE (addr) == SSA_NAME)
-	{
+	DR_PTR_INFO (dr) = SSA_NAME_PTR_INFO (addr);
-	  smt = symbol_mem_tag (SSA_NAME_VAR (addr));
+}
-	  DR_PTR_INFO (dr) = SSA_NAME_PTR_INFO (addr);
-	}
-}
-DR_SYMBOL_TAG (dr) = smt;
-vops = BITMAP_ALLOC (NULL);
-FOR_EACH_SSA_TREE_OPERAND (op, stmt, it, SSA_OP_VIRTUAL_USES)
-{
-bitmap_set_bit (vops, DECL_UID (SSA_NAME_VAR (op)));
-}
-DR_VOPS (dr) = vops;
 }
 /* Returns true if the address of DR is invariant.  */
 static bool
 /* Frees data reference DR.  */
 void
 free_data_ref (data_reference_p dr)
 {
-BITMAP_FREE (DR_VOPS (dr));
 VEC_free (tree, heap, DR_ACCESS_FNS (dr));
 free (dr);
 }
 /* Analyzes memory reference MEMREF accessed in STMT.  The reference
 print_generic_expr (dump_file, DR_STEP (dr), TDF_SLIM);
 fprintf (dump_file, "\n\taligned to: ");
 print_generic_expr (dump_file, DR_ALIGNED_TO (dr), TDF_SLIM);
 fprintf (dump_file, "\n\tbase_object: ");
 print_generic_expr (dump_file, DR_BASE_OBJECT (dr), TDF_SLIM);
-fprintf (dump_file, "\n\tsymbol tag: ");
-print_generic_expr (dump_file, DR_SYMBOL_TAG (dr), TDF_SLIM);
 fprintf (dump_file, "\n");
 }
 return dr;
 }
 /* Returns true if FNA == FNB.  */
 static bool
 tree type = signed_type_for_types (TREE_TYPE (VEC_index (tree, fna, i)),
 					 TREE_TYPE (VEC_index (tree, fnb, i)));
 VEC_quick_push (tree, ret,
 		      fold_build2 (op, type,
 				   VEC_index (tree, fna, i),
 				   VEC_index (tree, fnb, i)));
 }
 for (; VEC_iterate (tree, fna, i, coef); i++)
 VEC_quick_push (tree, ret,
 affine_fn fn_a, fn_b, diff;
 if (DDR_ARE_DEPENDENT (ddr) == NULL_TREE)
 {
 unsigned int i;
 for (i = 0; i < DDR_NUM_SUBSCRIPTS (ddr); i++)
 	{
 	  struct subscript *subscript;
 	  subscript = DDR_SUBSCRIPT (ddr, i);
 	  cf_a = SUB_CONFLICTS_IN_A (subscript);
 	  cf_b = SUB_CONFLICTS_IN_B (subscript);
 	  fn_a = common_affine_function (cf_a);
 	    {
 	      SUB_DISTANCE (subscript) = chrec_dont_know;
 	      return;
 	    }
 	  diff = affine_fn_minus (fn_a, fn_b);
 	  if (affine_function_constant_p (diff))
 	    SUB_DISTANCE (subscript) = affine_function_base (diff);
 	  else
 	    SUB_DISTANCE (subscript) = chrec_dont_know;
 const_tree addr_a = DR_BASE_ADDRESS (a);
 const_tree addr_b = DR_BASE_ADDRESS (b);
 const_tree type_a, type_b;
 const_tree decl_a = NULL_TREE, decl_b = NULL_TREE;
-/* If the sets of virtual operands are disjoint, the memory references do not
-alias.  */
-if (!bitmap_intersect_p (DR_VOPS (a), DR_VOPS (b)))
-return false;
 /* If the accessed objects are disjoint, the memory references do not
 alias.  */
 if (disjoint_objects_p (DR_BASE_OBJECT (a), DR_BASE_OBJECT (b)))
 return false;
+/* Query the alias oracle.  */
+if (!DR_IS_READ (a) && !DR_IS_READ (b))
+{
+if (!refs_output_dependent_p (DR_REF (a), DR_REF (b)))
+	return false;
+}
+else if (DR_IS_READ (a) && !DR_IS_READ (b))
+{
+if (!refs_anti_dependent_p (DR_REF (a), DR_REF (b)))
+	return false;
+}
+else if (!refs_may_alias_p (DR_REF (a), DR_REF (b)))
+return false;
 if (!addr_a || !addr_b)
 return true;
-/* If the references are based on different static objects, they cannot alias
+/* If the references are based on different static objects, they cannot
-(PTA should be able to disambiguate such accesses, but often it fails to,
+alias (PTA should be able to disambiguate such accesses, but often
-since currently we cannot distinguish between pointer and offset in pointer
+it fails to).  */
-arithmetics).  */
 if (TREE_CODE (addr_a) == ADDR_EXPR
 && TREE_CODE (addr_b) == ADDR_EXPR)
 return TREE_OPERAND (addr_a, 0) == TREE_OPERAND (addr_b, 0);
 /* An instruction writing through a restricted pointer is "independent" of any
 instruction reading or writing through a different restricted pointer,
 in the same block/scope.  */
 type_a = TREE_TYPE (addr_a);
 type_b = TREE_TYPE (addr_b);
 gcc_assert (POINTER_TYPE_P (type_a) && POINTER_TYPE_P (type_b));
 if (TREE_CODE (addr_a) == SSA_NAME)
 decl_a = SSA_NAME_VAR (addr_a);
 if (TREE_CODE (addr_b) == SSA_NAME)
 decl_b = SSA_NAME_VAR (addr_b);
 if (TYPE_RESTRICT (type_a) && TYPE_RESTRICT (type_b)
 && (!DR_IS_READ (a) || !DR_IS_READ (b))
 && decl_a && DECL_P (decl_a)
 && decl_b && DECL_P (decl_b)
 && decl_a != decl_b
 && TREE_CODE (DECL_CONTEXT (decl_a)) == FUNCTION_DECL
 /* Initialize a data dependence relation between data accesses A and
 B.  NB_LOOPS is the number of loops surrounding the references: the
 size of the classic distance/direction vectors.  */
 static struct data_dependence_relation *
 initialize_data_dependence_relation (struct data_reference *a,
 				     struct data_reference *b,
 				     VEC (loop_p, heap) *loop_nest)
 {
 struct data_dependence_relation *res;
 unsigned int i;
 res = XNEW (struct data_dependence_relation);
 DDR_A (res) = a;
 DDR_B (res) = b;
 DDR_LOOP_NEST (res) = NULL;
 DDR_REVERSED_P (res) = false;
 DDR_DIR_VECTS (res) = NULL;
 DDR_DIST_VECTS (res) = NULL;
 if (a == NULL || b == NULL)
 {
 DDR_ARE_DEPENDENT (res) = chrec_dont_know;
 return res;
 }
 /* If the data references do not alias, then they are independent.  */
 if (!dr_may_alias_p (a, b))
 {
 DDR_ARE_DEPENDENT (res) = chrec_known;
 return res;
 }
 /* When the references are exactly the same, don't spend time doing
 the data dependence tests, just initialize the ddr and return.  */
 /* If the references do not access the same object, we do not know
 whether they alias or not.  */
 if (!operand_equal_p (DR_BASE_OBJECT (a), DR_BASE_OBJECT (b), 0))
 {
 DDR_ARE_DEPENDENT (res) = chrec_dont_know;
 return res;
 }
 /* If the base of the object is not invariant in the loop nest, we cannot
 analyze it.  TODO -- in fact, it would suffice to record that there may
 be arbitrary dependences in the loops where the base object varies.  */
-if (!object_address_invariant_in_loop_p (VEC_index (loop_p, loop_nest, 0),
+if (loop_nest
-					   DR_BASE_OBJECT (a)))
+&& !object_address_invariant_in_loop_p (VEC_index (loop_p, loop_nest, 0),
-{
+					      DR_BASE_OBJECT (a)))
-DDR_ARE_DEPENDENT (res) = chrec_dont_know;
+{
+DDR_ARE_DEPENDENT (res) = chrec_dont_know;
 return res;
 }
 gcc_assert (DR_NUM_DIMENSIONS (a) == DR_NUM_DIMENSIONS (b));
 DDR_SELF_REFERENCE (res) = false;
 for (i = 0; i < DR_NUM_DIMENSIONS (a); i++)
 {
 struct subscript *subscript;
 subscript = XNEW (struct subscript);
 SUB_CONFLICTS_IN_A (subscript) = conflict_fn_not_known ();
 SUB_CONFLICTS_IN_B (subscript) = conflict_fn_not_known ();
 SUB_LAST_CONFLICT (subscript) = chrec_dont_know;
 SUB_DISTANCE (subscript) = chrec_dont_know;
 /* Set DDR_ARE_DEPENDENT to CHREC and finalize the subscript overlap
 description.  */
 static inline void
 finalize_ddr_dependent (struct data_dependence_relation *ddr,
 			tree chrec)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "(dependence classified: ");
 print_generic_expr (dump_file, chrec, 0);
 fprintf (dump_file, ")\n");
 }
 DDR_ARE_DEPENDENT (ddr) = chrec;
 free_subscripts (DDR_SUBSCRIPTS (ddr));
 DDR_SUBSCRIPTS (ddr) = NULL;
 }
 /* The dependence relation DDR cannot be represented by a distance
 if ((evolution_function_is_constant_p (chrec_a)
 && evolution_function_is_univariate_p (chrec_b))
 || (evolution_function_is_constant_p (chrec_b)
 	  && evolution_function_is_univariate_p (chrec_a)))
 return true;
 if (evolution_function_is_univariate_p (chrec_a)
 && evolution_function_is_univariate_p (chrec_b))
 {
 switch (TREE_CODE (chrec_a))
 	{
 	  switch (TREE_CODE (chrec_b))
 	    {
 	    case POLYNOMIAL_CHREC:
 	      if (CHREC_VARIABLE (chrec_a) != CHREC_VARIABLE (chrec_b))
 		return false;
 	    default:
 	      return true;
 	    }
 	default:
 	  return true;
 	}
 }
 return false;
 }
 /* Creates a conflict function with N dimensions.  The affine functions
 in each dimension follow.  */
 conflict_function *ret = XCNEW (conflict_function);
 va_list ap;
 gcc_assert (0 < n && n <= MAX_DIM);
 va_start(ap, n);
 ret->n = n;
 for (i = 0; i < n; i++)
 ret->fns[i] = va_arg (ap, affine_fn);
 va_end(ap);
 relation between the elements accessed twice by CHREC_A and
 CHREC_B.  For k >= 0, the following property is verified:
 CHREC_A (*OVERLAPS_A (k)) = CHREC_B (*OVERLAPS_B (k)).  */
 static void
 analyze_ziv_subscript (tree chrec_a,
 		       tree chrec_b,
 		       conflict_function **overlaps_a,
 		       conflict_function **overlaps_b,
 		       tree *last_conflicts)
 {
 tree type, difference;
 dependence_stats.num_ziv++;
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, "(analyze_ziv_subscript \n");
 type = signed_type_for_types (TREE_TYPE (chrec_a), TREE_TYPE (chrec_b));
 chrec_a = chrec_convert (type, chrec_a, NULL);
 chrec_b = chrec_convert (type, chrec_b, NULL);
 difference = chrec_fold_minus (type, chrec_a, chrec_b);
 switch (TREE_CODE (difference))
 {
 case INTEGER_CST:
 if (integer_zerop (difference))
 	{
 	  *overlaps_b = conflict_fn_no_dependence ();
 	  *last_conflicts = integer_zero_node;
 	  dependence_stats.num_ziv_independent++;
 	}
 break;
 default:
 /* We're not sure whether the indexes overlap.  For the moment,
 	 conservatively answer "don't know".  */
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "ziv test failed: difference is non-integer.\n");
 *overlaps_a = conflict_fn_not_known ();
 *overlaps_b = conflict_fn_not_known ();
 *last_conflicts = chrec_dont_know;
 dependence_stats.num_ziv_unimplemented++;
 break;
 }
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, ")\n");
 }
 /* Sets NIT to the estimated number of executions of the statements in
 return -1;
 hwi_nit = double_int_to_shwi (nit);
 return hwi_nit < 0 ? -1 : hwi_nit;
 }
 /* Similar to estimated_loop_iterations, but returns the estimate as a tree,
 and only if it fits to the int type.  If this is not the case, or the
 estimate on the number of iterations of LOOP could not be derived, returns
 chrec_dont_know.  */
 CHREC_B.  For k >= 0, the following property is verified:
 CHREC_A (*OVERLAPS_A (k)) = CHREC_B (*OVERLAPS_B (k)).  */
 static void
 analyze_siv_subscript_cst_affine (tree chrec_a,
 				  tree chrec_b,
 				  conflict_function **overlaps_a,
 				  conflict_function **overlaps_b,
 				  tree *last_conflicts)
 {
 bool value0, value1, value2;
 tree type, difference, tmp;
 type = signed_type_for_types (TREE_TYPE (chrec_a), TREE_TYPE (chrec_b));
 chrec_a = chrec_convert (type, chrec_a, NULL);
 chrec_b = chrec_convert (type, chrec_b, NULL);
 difference = chrec_fold_minus (type, initial_condition (chrec_b), chrec_a);
 if (!chrec_is_positive (initial_condition (difference), &value0))
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "siv test failed: chrec is not positive.\n");
 dependence_stats.num_siv_unimplemented++;
 *overlaps_a = conflict_fn_not_known ();
 *overlaps_b = conflict_fn_not_known ();
 *last_conflicts = chrec_dont_know;
 	    {
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		fprintf (dump_file, "siv test failed: chrec not positive.\n");
 	      *overlaps_a = conflict_fn_not_known ();
 	      *overlaps_b = conflict_fn_not_known ();
 	      *last_conflicts = chrec_dont_know;
 	      dependence_stats.num_siv_unimplemented++;
 	      return;
 	    }
 	  else
 	    {
 	      if (value1 == true)
 		{
 		  /* Example:
 		     chrec_a = 12
 		     chrec_b = {10, +, 1}
 		  */
 		  if (tree_fold_divides_p (CHREC_RIGHT (chrec_b), difference))
 		    {
 		      HOST_WIDE_INT numiter;
 		      struct loop *loop = get_chrec_loop (chrec_b);
 		      tmp = fold_build2 (EXACT_DIV_EXPR, type,
 					 fold_build1 (ABS_EXPR, type, difference),
 					 CHREC_RIGHT (chrec_b));
 		      *overlaps_b = conflict_fn (1, affine_fn_cst (tmp));
 		      *last_conflicts = integer_one_node;
 		      /* Perform weak-zero siv test to see if overlap is
 			 outside the loop bounds.  */
 		      numiter = estimated_loop_iterations_int (loop, false);
 			  *overlaps_a = conflict_fn_no_dependence ();
 			  *overlaps_b = conflict_fn_no_dependence ();
 			  *last_conflicts = integer_zero_node;
 			  dependence_stats.num_siv_independent++;
 			  return;
 			}
 		      dependence_stats.num_siv_dependent++;
 		      return;
 		    }
 		  /* When the step does not divide the difference, there are
 		     no overlaps.  */
 		  else
 		    {
 		      *overlaps_a = conflict_fn_no_dependence ();
 		      *overlaps_b = conflict_fn_no_dependence ();
 		      *last_conflicts = integer_zero_node;
 		      dependence_stats.num_siv_independent++;
 		      return;
 		    }
 		}
 	      else
 		{
 		  /* Example:
 		     chrec_a = 12
 		     chrec_b = {10, +, -1}
 		     In this case, chrec_a will not overlap with chrec_b.  */
 		  *overlaps_a = conflict_fn_no_dependence ();
 		  *overlaps_b = conflict_fn_no_dependence ();
 		  *last_conflicts = integer_zero_node;
 		  dependence_stats.num_siv_independent++;
 		  return;
 		}
 	    }
 	}
 else
 	{
 	  if (!chrec_is_positive (CHREC_RIGHT (chrec_b), &value2))
 	    {
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		fprintf (dump_file, "siv test failed: chrec not positive.\n");
 	      *overlaps_a = conflict_fn_not_known ();
 	      *overlaps_b = conflict_fn_not_known ();
 	      *last_conflicts = chrec_dont_know;
 	      dependence_stats.num_siv_unimplemented++;
 	      return;
 	    }
 	  else
 	    {
 	      if (value2 == false)
 		{
 		  /* Example:
 		     chrec_a = 3
 		     chrec_b = {10, +, -1}
 		  */
 		  if (tree_fold_divides_p (CHREC_RIGHT (chrec_b), difference))
 		    {
 			  *overlaps_a = conflict_fn_no_dependence ();
 			  *overlaps_b = conflict_fn_no_dependence ();
 			  *last_conflicts = integer_zero_node;
 			  dependence_stats.num_siv_independent++;
 			  return;
 			}
 		      dependence_stats.num_siv_dependent++;
 		      return;
 		    }
 		  /* When the step does not divide the difference, there
 		     are no overlaps.  */
 		  else
 		    {
 		      *overlaps_a = conflict_fn_no_dependence ();
 		      *overlaps_b = conflict_fn_no_dependence ();
 		      *last_conflicts = integer_zero_node;
 		      dependence_stats.num_siv_independent++;
 		      return;
 		    }
 		}
 	      else
 		{
 		  /* Example:
 		     chrec_a = 3
 		     chrec_b = {4, +, 1}
 		     In this case, chrec_a will not overlap with chrec_b.  */
 		  *overlaps_a = conflict_fn_no_dependence ();
 		  *overlaps_b = conflict_fn_no_dependence ();
 		  *last_conflicts = integer_zero_node;
 		  dependence_stats.num_siv_independent++;
 }
 }
 #define FLOOR_DIV(x,y) ((x) / (y))
 /* Solves the special case of the Diophantine equation:
 | {0, +, STEP_A}_x (OVERLAPS_A) = {0, +, STEP_B}_y (OVERLAPS_B)
 Computes the descriptions OVERLAPS_A and OVERLAPS_B.  NITER is the
 number of iterations that loops X and Y run.  The overlaps will be
 constructed as evolutions in dimension DIM.  */
 static void
 compute_overlap_steps_for_affine_univar (int niter, int step_a, int step_b,
 					 affine_fn *overlaps_a,
 					 affine_fn *overlaps_b,
 					 tree *last_conflicts, int dim)
 {
 if (((step_a > 0 && step_b > 0)
 || (step_a < 0 && step_b < 0)))
 {
 	  *last_conflicts = build_int_cst (NULL_TREE, last_conflict);
 	}
 else
 	*last_conflicts = chrec_dont_know;
 *overlaps_a = affine_fn_univar (integer_zero_node, dim,
 				      build_int_cst (NULL_TREE,
 						     step_overlaps_a));
 *overlaps_b = affine_fn_univar (integer_zero_node, dim,
 				      build_int_cst (NULL_TREE,
 						     step_overlaps_b));
 }
 else
 {
 }
 }
 /* Solves the special case of a Diophantine equation where CHREC_A is
 an affine bivariate function, and CHREC_B is an affine univariate
 function.  For example,
 | {{0, +, 1}_x, +, 1335}_y = {0, +, 1336}_z
 has the following overlapping functions:
 | x (t, u, v) = {{0, +, 1336}_t, +, 1}_v
 | y (t, u, v) = {{0, +, 1336}_u, +, 1}_v
 | z (t, u, v) = {{{0, +, 1}_t, +, 1335}_u, +, 1}_v
 FORNOW: This is a specialized implementation for a case occurring in
 a common benchmark.  Implement the general algorithm.  */
 static void
 compute_overlap_steps_for_affine_1_2 (tree chrec_a, tree chrec_b,
 				      conflict_function **overlaps_a,
 				      conflict_function **overlaps_b,
 				      tree *last_conflicts)
 {
 bool xz_p, yz_p, xyz_p;
 int step_x, step_y, step_z;
 HOST_WIDE_INT niter_x, niter_y, niter_z, niter;
 step_x = int_cst_value (CHREC_RIGHT (CHREC_LEFT (chrec_a)));
 step_y = int_cst_value (CHREC_RIGHT (chrec_a));
 step_z = int_cst_value (CHREC_RIGHT (chrec_b));
 niter_x =
 estimated_loop_iterations_int (get_chrec_loop (CHREC_LEFT (chrec_a)),
 				   false);
 niter_y = estimated_loop_iterations_int (get_chrec_loop (chrec_a), false);
 niter_z = estimated_loop_iterations_int (get_chrec_loop (chrec_b), false);
 if (niter_x < 0 || niter_y < 0 || niter_z < 0)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "overlap steps test failed: no iteration counts.\n");
 *overlaps_a = conflict_fn_not_known ();
 *overlaps_b = conflict_fn_not_known ();
 *last_conflicts = chrec_dont_know;
 return;
 }
 CHREC_B, that are affine functions.  This function cannot handle
 symbolic evolution functions, ie. when initial conditions are
 parameters, because it uses lambda matrices of integers.  */
 static void
 analyze_subscript_affine_affine (tree chrec_a,
 				 tree chrec_b,
 				 conflict_function **overlaps_a,
 				 conflict_function **overlaps_b,
 				 tree *last_conflicts)
 {
 unsigned nb_vars_a, nb_vars_b, dim;
 HOST_WIDE_INT init_a, init_b, gamma, gcd_alpha_beta;
 lambda_matrix A, U, S;
 *last_conflicts = chrec_dont_know;
 return;
 }
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, "(analyze_subscript_affine_affine \n");
 /* For determining the initial intersection, we have to solve a
 Diophantine equation.  This is the most time consuming part.
 For answering to the question: "Is there a dependence?" we have
 to prove that there exists a solution to the Diophantine
 equation, and that the solution is in the iteration domain,
 i.e. the solution is positive or zero, and that the solution
 happens before the upper bound loop.nb_iterations.  Otherwise
 init_a = int_cst_value (initialize_matrix_A (A, chrec_a, 0, 1));
 init_b = int_cst_value (initialize_matrix_A (A, chrec_b, nb_vars_a, -1));
 gamma = init_b - init_a;
 /* Don't do all the hard work of solving the Diophantine equation
 when we already know the solution: for example,
 | {3, +, 1}_1
 | {3, +, 4}_2
 | gamma = 3 - 3 = 0.
 Then the first overlap occurs during the first iterations:
 | {3, +, 1}_1 ({0, +, 4}_x) = {3, +, 4}_2 ({0, +, 1}_x)
 */
 if (gamma == 0)
 {
 if (nb_vars_a == 1 && nb_vars_b == 1)
 						   false);
 	  niter = MIN (niter_a, niter_b);
 	  step_a = int_cst_value (CHREC_RIGHT (chrec_a));
 	  step_b = int_cst_value (CHREC_RIGHT (chrec_b));
 	  compute_overlap_steps_for_affine_univar (niter, step_a, step_b,
 						   &ova, &ovb,
 						   last_conflicts, 1);
 	  *overlaps_a = conflict_fn (1, ova);
 	  *overlaps_b = conflict_fn (1, ovb);
 	}
 /* Both functions should have the same evolution sign.  */
 if (((A[0][0] > 0 && -A[1][0] > 0)
 	   || (A[0][0] < 0 && -A[1][0] < 0)))
 	{
 	  /* The solutions are given by:
 	     |
 	     | [GAMMA/GCD_ALPHA_BETA  t].[u11 u12]  = [x0]
 	     |                           [u21 u22]    [y0]
 	     For a given integer t.  Using the following variables,
 	     | i0 = u11 * gamma / gcd_alpha_beta
 	     | j0 = u12 * gamma / gcd_alpha_beta
 	     | i1 = u21
 	     | j1 = u22
 	     the solutions are:
 	     | x0 = i0 + i1 * t,
 	     | y0 = j0 + j1 * t.  */
 	  HOST_WIDE_INT i0, j0, i1, j1;
 	  i0 = U[0][0] * gamma / gcd_alpha_beta;
 	  j0 = U[0][1] * gamma / gcd_alpha_beta;
 	  j1 = U[1][1];
 	  if ((i1 == 0 && i0 < 0)
 	      || (j1 == 0 && j0 < 0))
 	    {
 	      /* There is no solution.
 		 FIXME: The case "i0 > nb_iterations, j0 > nb_iterations"
 		 falls in here, but for the moment we don't look at the
 		 upper bound of the iteration domain.  */
 	      *overlaps_a = conflict_fn_no_dependence ();
 	      *overlaps_b = conflict_fn_no_dependence ();
 	      *last_conflicts = integer_zero_node;
 	      goto end_analyze_subs_aa;
 *overlaps_a = conflict_fn_not_known ();
 *overlaps_b = conflict_fn_not_known ();
 *last_conflicts = chrec_dont_know;
 }
 end_analyze_subs_aa:
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "  (overlaps_a = ");
 dump_conflict_function (dump_file, *overlaps_a);
 fprintf (dump_file, ")\n  (overlaps_b = ");
 /* Returns true when analyze_subscript_affine_affine can be used for
 determining the dependence relation between chrec_a and chrec_b,
 that contain symbols.  This function modifies chrec_a and chrec_b
 such that the analysis result is the same, and such that they don't
 contain symbols, and then can safely be passed to the analyzer.
 Example: The analysis of the following tuples of evolutions produce
 the same results: {x+1, +, 1}_1 vs. {x+3, +, 1}_1, and {-2, +, 1}_1
 vs. {0, +, 1}_1
 {x+1, +, 1}_1 ({2, +, 1}_1) = {x+3, +, 1}_1 ({0, +, 1}_1)
 {-2, +, 1}_1 ({2, +, 1}_1) = {0, +, 1}_1 ({0, +, 1}_1)
 */
 static bool
 return false;
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, "can_use_subscript_aff_aff_for_symbolic \n");
 *chrec_a = build_polynomial_chrec (CHREC_VARIABLE (*chrec_a),
 				     diff, CHREC_RIGHT (*chrec_a));
 right_b = chrec_convert (type, CHREC_RIGHT (*chrec_b), NULL);
 *chrec_b = build_polynomial_chrec (CHREC_VARIABLE (*chrec_b),
 				     build_int_cst (type, 0),
 				     right_b);
 CHREC_B.  For k >= 0, the following property is verified:
 CHREC_A (*OVERLAPS_A (k)) = CHREC_B (*OVERLAPS_B (k)).  */
 static void
 analyze_siv_subscript (tree chrec_a,
 		       tree chrec_b,
 		       conflict_function **overlaps_a,
 		       conflict_function **overlaps_b,
 		       tree *last_conflicts,
 		       int loop_nest_num)
 {
 dependence_stats.num_siv++;
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, "(analyze_siv_subscript \n");
 if (evolution_function_is_constant_p (chrec_a)
 && evolution_function_is_affine_in_loop (chrec_b, loop_nest_num))
 analyze_siv_subscript_cst_affine (chrec_a, chrec_b,
 				      overlaps_a, overlaps_b, last_conflicts);
 else if (evolution_function_is_affine_in_loop (chrec_a, loop_nest_num)
 	   && evolution_function_is_constant_p (chrec_b))
 analyze_siv_subscript_cst_affine (chrec_b, chrec_a,
 				      overlaps_b, overlaps_a, last_conflicts);
 else if (evolution_function_is_affine_in_loop (chrec_a, loop_nest_num)
 	   && evolution_function_is_affine_in_loop (chrec_b, loop_nest_num))
 {
 if (!chrec_contains_symbols (chrec_a)
 	  && !chrec_contains_symbols (chrec_b))
 	{
 	  analyze_subscript_affine_affine (chrec_a, chrec_b,
 					   overlaps_a, overlaps_b,
 					   last_conflicts);
 	  if (CF_NOT_KNOWN_P (*overlaps_a)
 	      || CF_NOT_KNOWN_P (*overlaps_b))
 	    dependence_stats.num_siv_unimplemented++;
 		   || CF_NO_DEPENDENCE_P (*overlaps_b))
 	    dependence_stats.num_siv_independent++;
 	  else
 	    dependence_stats.num_siv_dependent++;
 	}
 else if (can_use_analyze_subscript_affine_affine (&chrec_a,
 							&chrec_b))
 	{
 	  analyze_subscript_affine_affine (chrec_a, chrec_b,
 					   overlaps_a, overlaps_b,
 					   last_conflicts);
 	  if (CF_NOT_KNOWN_P (*overlaps_a)
 	      || CF_NOT_KNOWN_P (*overlaps_b))
 	    dependence_stats.num_siv_unimplemented++;
 *overlaps_a = conflict_fn_not_known ();
 *overlaps_b = conflict_fn_not_known ();
 *last_conflicts = chrec_dont_know;
 dependence_stats.num_siv_unimplemented++;
 }
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, ")\n");
 }
 /* Returns false if we can prove that the greatest common divisor of the steps
 is verified:
 CHREC_A (*OVERLAPS_A (k)) = CHREC_B (*OVERLAPS_B (k)).  */
 static void
 analyze_miv_subscript (tree chrec_a,
 		       tree chrec_b,
 		       conflict_function **overlaps_a,
 		       conflict_function **overlaps_b,
 		       tree *last_conflicts,
 		       struct loop *loop_nest)
 {
 /* FIXME:  This is a MIV subscript, not yet handled.
 Example: (A[{1, +, 1}_1] vs. A[{1, +, 1}_2]) that comes from
 (A[i] vs. A[j]).
 In the SIV test we had to solve a Diophantine equation with two
 variables.  In the MIV case we have to solve a Diophantine
 equation with 2*n variables (if the subscript uses n IVs).
 */
 tree type, difference;
 type = signed_type_for_types (TREE_TYPE (chrec_a), TREE_TYPE (chrec_b));
 chrec_a = chrec_convert (type, chrec_a, NULL);
 chrec_b = chrec_convert (type, chrec_b, NULL);
 difference = chrec_fold_minus (type, chrec_a, chrec_b);
 if (eq_evolutions_p (chrec_a, chrec_b))
 {
 /* Access functions are the same: all the elements are accessed
 	 in the same order.  */
 *overlaps_a = conflict_fn (1, affine_fn_cst (integer_zero_node));
 *overlaps_b = conflict_fn (1, affine_fn_cst (integer_zero_node));
 *last_conflicts = estimated_loop_iterations_tree
 				(get_chrec_loop (chrec_a), true);
 dependence_stats.num_miv_dependent++;
 }
 else if (evolution_function_is_constant_p (difference)
 	   /* For the moment, the following is verified:
 	      evolution_function_is_affine_multivariate_p (chrec_a,
 	      loop_nest->num) */
 	   && !gcd_of_steps_may_divide_p (chrec_a, difference))
 {
 /* testsuite/.../ssa-chrec-33.c
 	 {{21, +, 2}_1, +, -2}_2  vs.  {{20, +, 2}_1, +, -2}_2
 	 The difference is 1, and all the evolution steps are multiples
 	 of 2, consequently there are no overlapping elements.  */
 *overlaps_a = conflict_fn_no_dependence ();
 *overlaps_b = conflict_fn_no_dependence ();
 *last_conflicts = integer_zero_node;
 dependence_stats.num_miv_independent++;
 }
 else if (evolution_function_is_affine_multivariate_p (chrec_a, loop_nest->num)
 	   && !chrec_contains_symbols (chrec_a)
 	   && evolution_function_is_affine_multivariate_p (chrec_b, loop_nest->num)
 	   && !chrec_contains_symbols (chrec_b))
 {
 /* testsuite/.../ssa-chrec-35.c
 	 {0, +, 1}_2  vs.  {0, +, 1}_3
 	 the overlapping elements are respectively located at iterations:
 	 {0, +, 1}_x and {0, +, 1}_x,
 	 in other words, we have the equality:
 	 {0, +, 1}_2 ({0, +, 1}_x) = {0, +, 1}_3 ({0, +, 1}_x)
 	 Other examples:
 	 {{0, +, 1}_1, +, 2}_2 ({0, +, 1}_x, {0, +, 1}_y) =
 	 {0, +, 1}_1 ({{0, +, 1}_x, +, 2}_y)
 	 {{0, +, 2}_1, +, 3}_2 ({0, +, 1}_y, {0, +, 1}_x) =
 	 {{0, +, 3}_1, +, 2}_2 ({0, +, 1}_x, {0, +, 1}_y)
 */
 analyze_subscript_affine_affine (chrec_a, chrec_b,
 				       overlaps_a, overlaps_b, last_conflicts);
 if (CF_NOT_KNOWN_P (*overlaps_a)
 	  || CF_NOT_KNOWN_P (*overlaps_b))
 	dependence_stats.num_miv_unimplemented++;
 	       || CF_NO_DEPENDENCE_P (*overlaps_b))
 	dependence_stats.num_miv_independent++;
 else
 	dependence_stats.num_miv_dependent++;
 }
 else
 {
 /* When the analysis is too difficult, answer "don't know".  */
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "analyze_miv_subscript test failed: unimplemented.\n");
 *overlaps_a = conflict_fn_not_known ();
 *overlaps_b = conflict_fn_not_known ();
 *last_conflicts = chrec_dont_know;
 dependence_stats.num_miv_unimplemented++;
 }
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, ")\n");
 }
 /* Determines the iterations for which CHREC_A is equal to CHREC_B in
 with respect to LOOP_NEST.  OVERLAP_ITERATIONS_A and
 OVERLAP_ITERATIONS_B are initialized with two functions that
 describe the iterations that contain conflicting elements.
 Remark: For an integer k >= 0, the following equality is true:
 CHREC_A (OVERLAP_ITERATIONS_A (k)) == CHREC_B (OVERLAP_ITERATIONS_B (k)).
 */
 static void
 analyze_overlapping_iterations (tree chrec_a,
 				tree chrec_b,
 				conflict_function **overlap_iterations_a,
 				conflict_function **overlap_iterations_b,
 				tree *last_conflicts, struct loop *loop_nest)
 {
 unsigned int lnn = loop_nest->num;
 dependence_stats.num_subscript_tests++;
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "(analyze_overlapping_iterations \n");
 fprintf (dump_file, "  (chrec_a = ");
 print_generic_expr (dump_file, chrec_a, 0);
 || chrec_b == NULL_TREE
 || chrec_contains_undetermined (chrec_a)
 || chrec_contains_undetermined (chrec_b))
 {
 dependence_stats.num_subscript_undetermined++;
 *overlap_iterations_a = conflict_fn_not_known ();
 *overlap_iterations_b = conflict_fn_not_known ();
 }
 /* If they are the same chrec, and are affine, they overlap
 on every iteration.  */
 else if (eq_evolutions_p (chrec_a, chrec_b)
 	   && evolution_function_is_affine_multivariate_p (chrec_a, lnn))
 {
 dependence_stats.num_same_subscript_function++;
 *last_conflicts = chrec_dont_know;
 }
 /* If they aren't the same, and aren't affine, we can't do anything
 yet. */
 else if ((chrec_contains_symbols (chrec_a)
 	    || chrec_contains_symbols (chrec_b))
 	   && (!evolution_function_is_affine_multivariate_p (chrec_a, lnn)
 	       || !evolution_function_is_affine_multivariate_p (chrec_b, lnn)))
 {
 dependence_stats.num_subscript_undetermined++;
 *overlap_iterations_a = conflict_fn_not_known ();
 *overlap_iterations_b = conflict_fn_not_known ();
 }
 else if (ziv_subscript_p (chrec_a, chrec_b))
 analyze_ziv_subscript (chrec_a, chrec_b,
 			   overlap_iterations_a, overlap_iterations_b,
 			   last_conflicts);
 else if (siv_subscript_p (chrec_a, chrec_b))
 analyze_siv_subscript (chrec_a, chrec_b,
 			   overlap_iterations_a, overlap_iterations_b,
 			   last_conflicts, lnn);
 else
 analyze_miv_subscript (chrec_a, chrec_b,
 			   overlap_iterations_a, overlap_iterations_b,
 			   last_conflicts, loop_nest);
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "  (overlap_iterations_a = ");
 dump_conflict_function (dump_file, *overlap_iterations_a);
 fprintf (dump_file, ")\n  (overlap_iterations_b = ");
 	}
 access_fn_a = DR_ACCESS_FN (ddr_a, i);
 access_fn_b = DR_ACCESS_FN (ddr_b, i);
 if (TREE_CODE (access_fn_a) == POLYNOMIAL_CHREC
 	  && TREE_CODE (access_fn_b) == POLYNOMIAL_CHREC)
 	{
 	  int dist, index;
 	  int index_a = index_in_loop_nest (CHREC_VARIABLE (access_fn_a),
 					    DDR_LOOP_NEST (ddr));
 	  if (chrec_contains_undetermined (SUB_DISTANCE (subscript)))
 	    {
 	      non_affine_dependence_relation (ddr);
 	      return false;
 	    }
 	  dist = int_cst_value (SUB_DISTANCE (subscript));
 	  /* This is the subscript coupling test.  If we have already
 	     recorded a distance for this loop (a distance coming from
 	     another subscript), it should be the same.  For example,
 	     |     {
 	     |       t = T[j+1][i-1];  // A
 	     |       T[j][i] = t + 2;  // B
 	     |     }
 	     the vectors are:
 	     (0,  1, -1)
 	     (1,  1, -1)
 	     (1, -1,  1)
 	  */
 	  if (DDR_NB_LOOPS (ddr) > 1)
 for (i = 0; VEC_iterate (subscript_p, DDR_SUBSCRIPTS (ddr), i, subscript);
 i++)
 {
 conflict_function *overlaps_a, *overlaps_b;
 analyze_overlapping_iterations (DR_ACCESS_FN (dra, i),
 				      DR_ACCESS_FN (drb, i),
 				      &overlaps_a, &overlaps_b,
 				      &last_conflicts, loop_nest);
 if (CF_NOT_KNOWN_P (overlaps_a)
 	  || CF_NOT_KNOWN_P (overlaps_b))
 	{
 static void
 subscript_dependence_tester (struct data_dependence_relation *ddr,
 			     struct loop *loop_nest)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, "(subscript_dependence_tester \n");
 if (subscript_dependence_tester_1 (ddr, DDR_A (ddr), DDR_B (ddr), loop_nest))
 dependence_stats.num_dependence_dependent++;
 compute_subscript_distance (ddr);
 if (build_classic_dist_vector (ddr, loop_nest))
 }
 /* Returns true when all the access functions of A are affine or
 constant with respect to LOOP_NEST.  */
 static bool
 access_functions_are_affine_or_constant_p (const struct data_reference *a,
 					   const struct loop *loop_nest)
 {
 unsigned int i;
 VEC(tree,heap) *fns = DR_ACCESS_FNS (a);
 for (i = 0; VEC_iterate (tree, fns, i, t); i++)
 if (!evolution_function_is_invariant_p (t, loop_nest->num)
 	&& !evolution_function_is_affine_multivariate_p (t, loop_nest->num))
 return false;
 return true;
-}
-/* Return true if we can create an affine data-ref for OP in STMT.  */
-bool
-stmt_simple_memref_p (struct loop *loop, gimple stmt, tree op)
-{
-data_reference_p dr;
-bool res = true;
-dr = create_data_ref (loop, op, stmt, true);
-if (!access_functions_are_affine_or_constant_p (dr, loop))
-res = false;
-free_data_ref (dr);
-return res;
 }
 /* Initializes an equation for an OMEGA problem using the information
 contained in the ACCESS_FUN.  Returns true when the operation
 succeeded.
 dependence accesses.  OFFSET is set either to 0 for the first n variables,
 then it is set to n.
 ACCESS_FUN is expected to be an affine chrec.  */
 static bool
 init_omega_eq_with_af (omega_pb pb, unsigned eq,
 		       unsigned int offset, tree access_fun,
 		       struct data_dependence_relation *ddr)
 {
 switch (TREE_CODE (access_fun))
 {
 case POLYNOMIAL_CHREC:
 	/* Compute the innermost loop index.  */
 	DDR_INNER_LOOP (ddr) = MAX (DDR_INNER_LOOP (ddr), var_idx);
 	if (offset == 0)
 	  pb->eqs[eq].coef[var_idx + DDR_NB_LOOPS (ddr) + 1]
 	    += int_cst_value (right);
 	switch (TREE_CODE (left))
 	  {
 	  case POLYNOMIAL_CHREC:
 enum omega_result res;
 /* Set a new problem for each loop in the nest.  The basis is the
 problem that we have initialized until now.  On top of this we
 add new constraints.  */
 for (i = 0; i <= DDR_INNER_LOOP (ddr)
 	 && VEC_iterate (loop_p, DDR_LOOP_NEST (ddr), i, loopi); i++)
 {
 int dist = 0;
 omega_pb copy = omega_alloc_problem (2 * DDR_NB_LOOPS (ddr),
 					   DDR_NB_LOOPS (ddr));
 copy->geqs[geq].coef[i + 1] = 1;
 /* Reduce the constraint system, and test that the current
 	 problem is feasible.  */
 res = omega_simplify_problem (copy);
 if (res == omega_false
 	  || res == omega_unknown
 	  || copy->num_geqs > (int) DDR_NB_LOOPS (ddr))
 	goto next_problem;
 for (eq = 0; eq < copy->num_subs; eq++)
 	  eq = omega_add_zero_eq (copy, omega_black);
 	  copy->eqs[eq].coef[i + 1] = 1;
 	  copy->eqs[eq].coef[0] = -1;
 	  res = omega_simplify_problem (copy);
 	  if (res == omega_false
 	      || res == omega_unknown
 	      || copy->num_geqs > (int) DDR_NB_LOOPS (ddr))
 	    goto next_problem;
 	  for (eq = 0; eq < copy->num_subs; eq++)
 constraints cannot be built: answer "don't know".  */
 return false;
 /* GCD test.  */
 if (DDR_NB_LOOPS (ddr) != 0 && pb->eqs[eq].coef[0]
 && !int_divides_p (lambda_vector_gcd
 			 ((lambda_vector) &(pb->eqs[eq].coef[1]),
 			  2 * DDR_NB_LOOPS (ddr)),
 			 pb->eqs[eq].coef[0]))
 {
 /* There is no dependence.  */
 - coef[0] is the constant
 - coef[1..nb_loops] are the protected variables that will not be
 removed by the solver: the "dx"
 - coef[nb_loops + 1, 2*nb_loops] are the loop variables: "loop_x".
 */
 for (i = 0; i <= DDR_INNER_LOOP (ddr)
 	 && VEC_iterate (loop_p, DDR_LOOP_NEST (ddr), i, loopi); i++)
 {
 HOST_WIDE_INT nbi = estimated_loop_iterations_int (loopi, false);
 /* 0 <= loop_x */
 otherwise, and when independence has been proved (using one of the
 trivial dependence test), set MAYBE_DEPENDENT to false, otherwise
 set MAYBE_DEPENDENT to true.
 Example: for setting up the dependence system corresponding to the
 conflicting accesses
 | loop_i
 |   loop_j
 |     A[i, i+1] = ...
 |     ... A[2*j, 2*(i + j)]
 |   endloop_j
 | endloop_i
 the following constraints come from the iteration domain:
 0 <= i <= Ni
 0 <= i + di <= Ni
 0 <= j <= Nj
 	  dump_data_dependence_relation (file, ddr);
 	  fprintf (file, ")\n");
 	}
 }
 return true;
 }
 /* This computes the affine dependence relation between A and B with
 respect to LOOP_NEST.  CHREC_KNOWN is used for representing the
 independence between two accesses, while CHREC_DONT_KNOW is used
 for representing the unknown relation.
 Note that it is possible to stop the computation of the dependence
 relation the first time we detect a CHREC_KNOWN element for a given
 subscript.  */
 static void
 compute_affine_dependence (struct data_dependence_relation *ddr,
 			   struct loop *loop_nest)
 {
 struct data_reference *dra = DDR_A (ddr);
 struct data_reference *drb = DDR_B (ddr);
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "(compute_affine_dependence\n");
 fprintf (dump_file, "  (stmt_a = \n");
 print_gimple_stmt (dump_file, DR_STMT (dra), 0, 0);
 		}
 	    }
 	  else
 	    subscript_dependence_tester (ddr, loop_nest);
 	}
 /* As a last case, if the dependence cannot be determined, or if
 	 the dependence is considered too difficult to determine, answer
 	 "don't know".  */
 else
 	{
 	      fprintf (dump_file, "affine dependence test not usable: access function not affine or constant.\n");
 	    }
 	  finalize_ddr_dependent (ddr, chrec_dont_know);
 	}
 }
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, ")\n");
 }
 /* This computes the dependence relation for the same data
 /* Compute in DEPENDENCE_RELATIONS the data dependence graph for all
 the data references in DATAREFS, in the LOOP_NEST.  When
 COMPUTE_SELF_AND_RR is FALSE, don't compute read-read and self
 relations.  */
 void
 compute_all_dependences (VEC (data_reference_p, heap) *datarefs,
 			 VEC (ddr_p, heap) **dependence_relations,
 			 VEC (loop_p, heap) *loop_nest,
 			 bool compute_self_and_rr)
 {
 for (j = i + 1; VEC_iterate (data_reference_p, datarefs, j, b); j++)
 if (!DR_IS_READ (a) || !DR_IS_READ (b) || compute_self_and_rr)
 	{
 	  ddr = initialize_data_dependence_relation (a, b, loop_nest);
 	  VEC_safe_push (ddr_p, heap, *dependence_relations, ddr);
-	  compute_affine_dependence (ddr, VEC_index (loop_p, loop_nest, 0));
+if (loop_nest)
+	    compute_affine_dependence (ddr, VEC_index (loop_p, loop_nest, 0));
 	}
 if (compute_self_and_rr)
 for (i = 0; VEC_iterate (data_reference_p, datarefs, i, a); i++)
 {
 && !(gimple_call_flags (stmt) & (ECF_CONST | ECF_PURE)))
 || (stmt_code == GIMPLE_ASM
 	  && gimple_asm_volatile_p (stmt)))
 clobbers_memory = true;
-if (ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
+if (!gimple_vuse (stmt))
 return clobbers_memory;
 if (stmt_code == GIMPLE_ASSIGN)
 {
 tree base;
 op0 = gimple_assign_lhs_ptr (stmt);
 op1 = gimple_assign_rhs1_ptr (stmt);
 if (DECL_P (*op1)
 	  || (REFERENCE_CLASS_P (*op1)
 	      && (base = get_base_address (*op1))
 	      && TREE_CODE (base) != SSA_NAME))
 	{
 for (i = 0; VEC_iterate (data_ref_loc, references, i, ref); i++)
 {
 dr = create_data_ref (nest, *ref->pos, stmt, ref->is_read);
 gcc_assert (dr != NULL);
-/* FIXME -- data dependence analysis does not work correctly for objects with
+/* FIXME -- data dependence analysis does not work correctly for objects
-	 invariant addresses.  Let us fail here until the problem is fixed.  */
+with invariant addresses in loop nests.  Let us fail here until the
-if (dr_address_invariant_p (dr))
+	 problem is fixed.  */
+if (dr_address_invariant_p (dr) && nest)
 	{
 	  free_data_ref (dr);
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    fprintf (dump_file, "\tFAILED as dr address is invariant\n");
 	  ret = false;
 }
 VEC_free (data_ref_loc, heap, references);
 return ret;
 }
+/* Stores the data references in STMT to DATAREFS.  If there is an unanalyzable
+reference, returns false, otherwise returns true.  NEST is the outermost
+loop of the loop nest in which the references should be analyzed.  */
+bool
+graphite_find_data_references_in_stmt (struct loop *nest, gimple stmt,
+				       VEC (data_reference_p, heap) **datarefs)
+{
+unsigned i;
+VEC (data_ref_loc, heap) *references;
+data_ref_loc *ref;
+bool ret = true;
+data_reference_p dr;
+if (get_references_in_stmt (stmt, &references))
+{
+VEC_free (data_ref_loc, heap, references);
+return false;
+}
+for (i = 0; VEC_iterate (data_ref_loc, references, i, ref); i++)
+{
+dr = create_data_ref (nest, *ref->pos, stmt, ref->is_read);
+gcc_assert (dr != NULL);
+VEC_safe_push (data_reference_p, heap, *datarefs, dr);
+}
+VEC_free (data_ref_loc, heap, references);
+return ret;
+}
+/* Search the data references in LOOP, and record the information into
+DATAREFS.  Returns chrec_dont_know when failing to analyze a
+difficult case, returns NULL_TREE otherwise.  */
+static tree
+find_data_references_in_bb (struct loop *loop, basic_block bb,
+VEC (data_reference_p, heap) **datarefs)
+{
+gimple_stmt_iterator bsi;
+for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
+{
+gimple stmt = gsi_stmt (bsi);
+if (!find_data_references_in_stmt (loop, stmt, datarefs))
+{
+struct data_reference *res;
+res = XCNEW (struct data_reference);
+VEC_safe_push (data_reference_p, heap, *datarefs, res);
+return chrec_dont_know;
+}
+}
+return NULL_TREE;
+}
 /* Search the data references in LOOP, and record the information into
 DATAREFS.  Returns chrec_dont_know when failing to analyze a
 difficult case, returns NULL_TREE otherwise.
 TODO: This function should be made smarter so that it can handle address
 arithmetic as if they were array accesses, etc.  */
 tree
 find_data_references_in_loop (struct loop *loop,
 			      VEC (data_reference_p, heap) **datarefs)
 {
 basic_block bb, *bbs;
 unsigned int i;
-gimple_stmt_iterator bsi;
 bbs = get_loop_body_in_dom_order (loop);
 for (i = 0; i < loop->num_nodes; i++)
 {
 bb = bbs[i];
-for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
+if (find_data_references_in_bb (loop, bb, datarefs) == chrec_dont_know)
-	{
+{
-	  gimple stmt = gsi_stmt (bsi);
+free (bbs);
+return chrec_dont_know;
-	  if (!find_data_references_in_stmt (loop, stmt, datarefs))
+}
-	    {
-	      struct data_reference *res;
-	      res = XCNEW (struct data_reference);
-	      VEC_safe_push (data_reference_p, heap, *datarefs, res);
-	      free (bbs);
-	      return chrec_dont_know;
-	    }
-	}
 }
 free (bbs);
 return NULL_TREE;
 }
 return true;
 }
 /* Returns true when the data dependences have been computed, false otherwise.
 Given a loop nest LOOP, the following vectors are returned:
 DATAREFS is initialized to all the array elements contained in this loop,
 DEPENDENCE_RELATIONS contains the relations between the data references.
 Compute read-read and self relations if
 COMPUTE_SELF_AND_READ_READ_DEPENDENCES is TRUE.  */
 bool
 compute_data_dependences_for_loop (struct loop *loop,
 				   bool compute_self_and_read_read_dependences,
 				   VEC (data_reference_p, heap) **datarefs,
 				   VEC (ddr_p, heap) **dependence_relations)
 {
 bool res = true;
 VEC (loop_p, heap) *vloops = VEC_alloc (loop_p, heap, 3);
 memset (&dependence_stats, 0, sizeof (dependence_stats));
 /* If the loop nest is not well formed, or one of the data references
 is not computable, give up without spending time to compute other
 dependences.  */
 if (!loop
 || !find_loop_nest (loop, &vloops)
 || find_data_references_in_loop (loop, datarefs) == chrec_dont_know)
 if (dump_file && (dump_flags & TDF_STATS))
 {
 fprintf (dump_file, "Dependence tester statistics:\n");
 fprintf (dump_file, "Number of dependence tests: %d\n",
 	       dependence_stats.num_dependence_tests);
 fprintf (dump_file, "Number of dependence tests classified dependent: %d\n",
 	       dependence_stats.num_dependence_dependent);
 fprintf (dump_file, "Number of dependence tests classified independent: %d\n",
 	       dependence_stats.num_dependence_independent);
 fprintf (dump_file, "Number of undetermined dependence tests: %d\n",
 	       dependence_stats.num_dependence_undetermined);
 fprintf (dump_file, "Number of subscript tests: %d\n",
 	       dependence_stats.num_subscript_tests);
 fprintf (dump_file, "Number of undetermined subscript tests: %d\n",
 	       dependence_stats.num_subscript_undetermined);
 fprintf (dump_file, "Number of same subscript function: %d\n",
 	       dependence_stats.num_same_subscript_function);
 fprintf (dump_file, "Number of ziv tests: %d\n",
 	       dependence_stats.num_ziv);
 fprintf (dump_file, "Number of ziv tests returning dependent: %d\n",
 	       dependence_stats.num_ziv_dependent);
 fprintf (dump_file, "Number of ziv tests returning independent: %d\n",
 	       dependence_stats.num_ziv_independent);
 fprintf (dump_file, "Number of ziv tests unimplemented: %d\n",
 	       dependence_stats.num_ziv_unimplemented);
 fprintf (dump_file, "Number of siv tests: %d\n",
 	       dependence_stats.num_siv);
 fprintf (dump_file, "Number of siv tests returning dependent: %d\n",
 	       dependence_stats.num_siv_dependent);
 fprintf (dump_file, "Number of siv tests returning independent: %d\n",
 	       dependence_stats.num_siv_independent);
 fprintf (dump_file, "Number of siv tests unimplemented: %d\n",
 	       dependence_stats.num_siv_unimplemented);
 fprintf (dump_file, "Number of miv tests: %d\n",
 	       dependence_stats.num_miv);
 fprintf (dump_file, "Number of miv tests returning dependent: %d\n",
 	       dependence_stats.num_miv_dependent);
 fprintf (dump_file, "Number of miv tests returning independent: %d\n",
 	       dependence_stats.num_miv_independent);
 }
 return res;
 }
+/* Returns true when the data dependences for the basic block BB have been
+computed, false otherwise.
+DATAREFS is initialized to all the array elements contained in this basic
+block, DEPENDENCE_RELATIONS contains the relations between the data
+references. Compute read-read and self relations if
+COMPUTE_SELF_AND_READ_READ_DEPENDENCES is TRUE.  */
+bool
+compute_data_dependences_for_bb (basic_block bb,
+bool compute_self_and_read_read_dependences,
+VEC (data_reference_p, heap) **datarefs,
+VEC (ddr_p, heap) **dependence_relations)
+{
+if (find_data_references_in_bb (NULL, bb, datarefs) == chrec_dont_know)
+return false;
+compute_all_dependences (*datarefs, dependence_relations, NULL,
+compute_self_and_read_read_dependences);
+return true;
+}
 /* Entry point (for testing only).  Analyze all the data references
 and the dependence relations in LOOP.
 The data references are computed first.
 A relation on these nodes is represented by a complete graph.  Some
 of the relations could be of no interest, thus the relations can be
 computed on demand.
 In the following function we compute all the relations.  This is
 just a first implementation that is here for:
 - for showing how to ask for the dependence relations,
 - for the debugging the whole dependence graph,
 - for the dejagnu testcases and maintenance.
 It is possible to ask only for a part of the graph, avoiding to
 compute the whole dependence graph.  The computed dependences are
 stored in a knowledge base (KB) such that later queries don't
 recompute the same information.  The implementation of this KB is
 transparent to the optimizer, and thus the KB can be changed with a
 more efficient implementation, or the KB could be disabled.  */
 static void
 analyze_all_data_dependences (struct loop *loop)
 {
 unsigned int i;
 int nb_data_refs = 10;
 VEC (data_reference_p, heap) *datarefs =
 VEC_alloc (data_reference_p, heap, nb_data_refs);
 VEC (ddr_p, heap) *dependence_relations =
 VEC_alloc (ddr_p, heap, nb_data_refs * nb_data_refs);
 /* Compute DDs on the whole function.  */
 compute_data_dependences_for_loop (loop, false, &datarefs,
 				     &dependence_relations);
 if (dump_flags & TDF_STATS)
 	{
 	  unsigned nb_top_relations = 0;
 	  unsigned nb_bot_relations = 0;
-	  unsigned nb_basename_differ = 0;
 	  unsigned nb_chrec_relations = 0;
 	  struct data_dependence_relation *ddr;
 	  for (i = 0; VEC_iterate (ddr_p, dependence_relations, i, ddr); i++)
 	    {
 	      if (chrec_contains_undetermined (DDR_ARE_DEPENDENT (ddr)))
 		nb_top_relations++;
 	      else if (DDR_ARE_DEPENDENT (ddr) == chrec_known)
-		{
+		nb_bot_relations++;
-		  struct data_reference *a = DDR_A (ddr);
-		  struct data_reference *b = DDR_B (ddr);
+	      else
-		  if (!bitmap_intersect_p (DR_VOPS (a), DR_VOPS (b)))
-		    nb_basename_differ++;
-		  else
-		    nb_bot_relations++;
-		}
-	      else
 		nb_chrec_relations++;
 	    }
 	  gather_stats_on_scev_database ();
 	}
 }
 free_dependence_relations (dependence_relations);
 }
 /* Free the memory used by the data dependence relations from
 DEPENDENCE_RELATIONS.  */
 void
 free_dependence_relations (VEC (ddr_p, heap) *dependence_relations)
 {
 unsigned int i;
 struct data_dependence_relation *ddr;
 VEC (loop_p, heap) *loop_nest = NULL;
 dump_rdg_vertex (FILE *file, struct graph *rdg, int i)
 {
 struct vertex *v = &(rdg->vertices[i]);
 struct graph_edge *e;
 fprintf (file, "(vertex %d: (%s%s) (in:", i,
 	   RDG_MEM_WRITE_STMT (rdg, i) ? "w" : "",
 	   RDG_MEM_READS_STMT (rdg, i) ? "r" : "");
 if (v->pred)
 for (e = v->pred; e; e = e->pred_next)
 debug_rdg (struct graph *rdg)
 {
 dump_rdg (stderr, rdg);
 }
-static void
-dot_rdg_1 (FILE *file, struct graph *rdg)
-{
-int i;
-fprintf (file, "digraph RDG {\n");
-for (i = 0; i < rdg->n_vertices; i++)
-{
-struct vertex *v = &(rdg->vertices[i]);
-struct graph_edge *e;
-/* Highlight reads from memory.  */
-if (RDG_MEM_READS_STMT (rdg, i))
-	fprintf (file, "%d [style=filled, fillcolor=green]\n", i);
-/* Highlight stores to memory.  */
-if (RDG_MEM_WRITE_STMT (rdg, i))
-	fprintf (file, "%d [style=filled, fillcolor=red]\n", i);
-if (v->succ)
-	for (e = v->succ; e; e = e->succ_next)
-	  switch (RDGE_TYPE (e))
-	    {
-	    case input_dd:
-	      fprintf (file, "%d -> %d [label=input] \n", i, e->dest);
-	      break;
-	    case output_dd:
-	      fprintf (file, "%d -> %d [label=output] \n", i, e->dest);
-	      break;
-	    case flow_dd:
-	      /* These are the most common dependences: don't print these. */
-	      fprintf (file, "%d -> %d \n", i, e->dest);
-	      break;
-	    case anti_dd:
-	      fprintf (file, "%d -> %d [label=anti] \n", i, e->dest);
-	      break;
-	    default:
-	      gcc_unreachable ();
-	    }
-}
-fprintf (file, "}\n\n");
-}
-/* Display SCOP using dotty.  */
-void
-dot_rdg (struct graph *rdg)
-{
-FILE *file = fopen ("/tmp/rdg.dot", "w");
-gcc_assert (file != NULL);
-dot_rdg_1 (file, rdg);
-fclose (file);
-system ("dotty /tmp/rdg.dot");
-}
 /* This structure is used for recording the mapping statement index in
 the RDG.  */
-struct rdg_vertex_info GTY(())
+struct GTY(()) rdg_vertex_info
 {
 gimple stmt;
 int index;
 };
 static void
 create_rdg_edges_for_scalar (struct graph *rdg, tree def, int idef)
 {
 use_operand_p imm_use_p;
 imm_use_iterator iterator;
 FOR_EACH_IMM_USE_FAST (imm_use_p, iterator, def)
 {
 struct graph_edge *e;
 int use = rdg_vertex_for_stmt (rdg, USE_STMT (imm_use_p));
 unsigned int i;
 for (i = 0; VEC_iterate (ddr_p, dependence_relations, i, ddr); i++)
 if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
 return false;
 return true;
 }
 /* Computes a hash function for element ELT.  */
 int nb_data_refs = 10;
 struct graph *rdg = NULL;
 VEC (ddr_p, heap) *dependence_relations;
 VEC (data_reference_p, heap) *datarefs;
 VEC (gimple, heap) *stmts = VEC_alloc (gimple, heap, nb_data_refs);
 dependence_relations = VEC_alloc (ddr_p, heap, nb_data_refs * nb_data_refs) ;
 datarefs = VEC_alloc (data_reference_p, heap, nb_data_refs);
 compute_data_dependences_for_loop (loop,
 false,
 &datarefs,
 &dependence_relations);
 if (!known_dependences_p (dependence_relations))
 {
 basic_block bb = bbs[i];
 gimple_stmt_iterator bsi;
 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
-	if (!ZERO_SSA_OPERANDS (gsi_stmt (bsi), SSA_OP_VDEF))
+	if (gimple_vdef (gsi_stmt (bsi)))
 	  VEC_safe_push (gimple, heap, *stmts, gsi_stmt (bsi));
 }
 free (bbs);
 }
 }
 /* Returns the index of PARAMETER in the parameters vector of the
 ACCESS_MATRIX.  If PARAMETER does not exist return -1.  */
 int
 access_matrix_get_index_for_parameter (tree parameter,
 				       struct access_matrix *access_matrix)
 {
 int i;
 VEC (tree,heap) *lambda_parameters = AM_PARAMETERS (access_matrix);
 tree lambda_parameter;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-data-ref.c @ 55:77e2b8dfacca gcc-4.4.5