/* Data dependence analysis for Graphite.
- Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2009-2020 Free Software Foundation, Inc.
Contributed by Sebastian Pop <sebastian.pop@amd.com> and
Konrad Trifunovic <konrad.trifunovic@inria.fr>.
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
+#define USES_ISL
+
#include "config.h"
+
+#ifdef HAVE_isl
+
#include "system.h"
#include "coretypes.h"
-#include "tree-flow.h"
-#include "tree-dump.h"
+#include "backend.h"
+#include "cfghooks.h"
+#include "tree.h"
+#include "gimple.h"
+#include "fold-const.h"
+#include "gimple-iterator.h"
+#include "tree-ssa-loop.h"
+#include "tree-pass.h"
#include "cfgloop.h"
-#include "tree-chrec.h"
#include "tree-data-ref.h"
-#include "tree-scalar-evolution.h"
-#include "sese.h"
-
-#ifdef HAVE_cloog
-#include "ppl_c.h"
-#include "graphite-ppl.h"
-#include "graphite-poly.h"
-#include "graphite-dependences.h"
-
-/* Returns a new polyhedral Data Dependence Relation (DDR). SOURCE is
- the source data reference, SINK is the sink data reference. When
- the Data Dependence Polyhedron DDP is not NULL or not empty, SOURCE
- and SINK are in dependence as described by DDP. */
-
-static poly_ddr_p
-new_poly_ddr (poly_dr_p source, poly_dr_p sink,
- ppl_Pointset_Powerset_C_Polyhedron_t ddp,
- bool original_scattering_p)
-{
- poly_ddr_p pddr = XNEW (struct poly_ddr);
-
- PDDR_SOURCE (pddr) = source;
- PDDR_SINK (pddr) = sink;
- PDDR_DDP (pddr) = ddp;
- PDDR_ORIGINAL_SCATTERING_P (pddr) = original_scattering_p;
-
- if (!ddp || ppl_Pointset_Powerset_C_Polyhedron_is_empty (ddp))
- PDDR_KIND (pddr) = no_dependence;
- else
- PDDR_KIND (pddr) = has_dependence;
-
- return pddr;
-}
-
-/* Free the poly_ddr_p P. */
-
-void
-free_poly_ddr (void *p)
-{
- poly_ddr_p pddr = (poly_ddr_p) p;
- ppl_delete_Pointset_Powerset_C_Polyhedron (PDDR_DDP (pddr));
- free (pddr);
-}
-
-/* Comparison function for poly_ddr hash table. */
-
-int
-eq_poly_ddr_p (const void *pddr1, const void *pddr2)
-{
- const struct poly_ddr *p1 = (const struct poly_ddr *) pddr1;
- const struct poly_ddr *p2 = (const struct poly_ddr *) pddr2;
-
- return (PDDR_SOURCE (p1) == PDDR_SOURCE (p2)
- && PDDR_SINK (p1) == PDDR_SINK (p2));
-}
+#include "graphite.h"
-/* Hash function for poly_ddr hashtable. */
+/* Add the constraints from the set S to the domain of MAP. */
-hashval_t
-hash_poly_ddr_p (const void *pddr)
+static isl_map *
+constrain_domain (isl_map *map, isl_set *s)
{
- const struct poly_ddr *p = (const struct poly_ddr *) pddr;
+ isl_space *d = isl_map_get_space (map);
+ isl_id *id = isl_space_get_tuple_id (d, isl_dim_in);
- return (hashval_t) ((long) PDDR_SOURCE (p) + (long) PDDR_SINK (p));
+ s = isl_set_set_tuple_id (s, id);
+ isl_space_free (d);
+ return isl_map_coalesce (isl_map_intersect_domain (map, s));
}
-/* Returns true when PDDR has no dependence. */
+/* Constrain pdr->accesses with pdr->subscript_sizes and pbb->domain. */
-static bool
-pddr_is_empty (poly_ddr_p pddr)
+static isl_map *
+add_pdr_constraints (poly_dr_p pdr, poly_bb_p pbb)
{
- if (!pddr)
- return true;
-
- gcc_assert (PDDR_KIND (pddr) != unknown_dependence);
-
- return PDDR_KIND (pddr) == no_dependence ? true : false;
+ isl_map *x = isl_map_intersect_range (isl_map_copy (pdr->accesses),
+ isl_set_copy (pdr->subscript_sizes));
+ x = isl_map_coalesce (x);
+ return constrain_domain (x, isl_set_copy (pbb->domain));
}
-/* Prints to FILE the layout of the dependence polyhedron of PDDR:
-
- T1|I1|T2|I2|S1|S2|G
-
- with
- | T1 and T2 the scattering dimensions for PDDR_SOURCE and PDDR_SINK
- | I1 and I2 the iteration domains
- | S1 and S2 the subscripts
- | G the global parameters. */
+/* Returns an isl description of all memory operations in SCOP. The memory
+ reads are returned in READS and writes in MUST_WRITES and MAY_WRITES. */
static void
-print_dependence_polyhedron_layout (FILE *file, poly_ddr_p pddr)
+scop_get_reads_and_writes (scop_p scop, isl_union_map *&reads,
+ isl_union_map *&must_writes,
+ isl_union_map *&may_writes)
{
- poly_dr_p pdr1 = PDDR_SOURCE (pddr);
- poly_dr_p pdr2 = PDDR_SINK (pddr);
- poly_bb_p pbb1 = PDR_PBB (pdr1);
- poly_bb_p pbb2 = PDR_PBB (pdr2);
-
- graphite_dim_t i;
- graphite_dim_t tdim1 = PDDR_ORIGINAL_SCATTERING_P (pddr) ?
- pbb_nb_scattering_orig (pbb1) : pbb_nb_scattering_transform (pbb1);
- graphite_dim_t tdim2 = PDDR_ORIGINAL_SCATTERING_P (pddr) ?
- pbb_nb_scattering_orig (pbb2) : pbb_nb_scattering_transform (pbb2);
- graphite_dim_t idim1 = pbb_dim_iter_domain (pbb1);
- graphite_dim_t idim2 = pbb_dim_iter_domain (pbb2);
- graphite_dim_t sdim1 = PDR_NB_SUBSCRIPTS (pdr1) + 1;
- graphite_dim_t sdim2 = PDR_NB_SUBSCRIPTS (pdr2) + 1;
- graphite_dim_t gdim = scop_nb_params (PBB_SCOP (pbb1));
-
- fprintf (file, "# eq");
-
- for (i = 0; i < tdim1; i++)
- fprintf (file, " t1_%d", (int) i);
- for (i = 0; i < idim1; i++)
- fprintf (file, " i1_%d", (int) i);
- for (i = 0; i < tdim2; i++)
- fprintf (file, " t2_%d", (int) i);
- for (i = 0; i < idim2; i++)
- fprintf (file, " i2_%d", (int) i);
- for (i = 0; i < sdim1; i++)
- fprintf (file, " s1_%d", (int) i);
- for (i = 0; i < sdim2; i++)
- fprintf (file, " s2_%d", (int) i);
- for (i = 0; i < gdim; i++)
- fprintf (file, " g_%d", (int) i);
-
- fprintf (file, " cst\n");
-}
-
-/* Prints to FILE the poly_ddr_p PDDR. */
-
-void
-print_pddr (FILE *file, poly_ddr_p pddr)
-{
- fprintf (file, "pddr (kind: ");
-
- if (PDDR_KIND (pddr) == unknown_dependence)
- fprintf (file, "unknown_dependence");
- else if (PDDR_KIND (pddr) == no_dependence)
- fprintf (file, "no_dependence");
- else if (PDDR_KIND (pddr) == has_dependence)
- fprintf (file, "has_dependence");
-
- fprintf (file, "\n source ");
- print_pdr (file, PDDR_SOURCE (pddr), 2);
-
- fprintf (file, "\n sink ");
- print_pdr (file, PDDR_SINK (pddr), 2);
+ int i, j;
+ poly_bb_p pbb;
+ poly_dr_p pdr;
- if (PDDR_KIND (pddr) == has_dependence)
+ FOR_EACH_VEC_ELT (scop->pbbs, i, pbb)
{
- fprintf (file, "\n dependence polyhedron (\n");
- print_dependence_polyhedron_layout (file, pddr);
- ppl_print_powerset_matrix (file, PDDR_DDP (pddr));
- ppl_io_fprint_Pointset_Powerset_C_Polyhedron (file, PDDR_DDP (pddr));
- fprintf (file, ")\n");
+ FOR_EACH_VEC_ELT (PBB_DRS (pbb), j, pdr) {
+ if (pdr_read_p (pdr))
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, "Adding read to depedence graph: ");
+ print_pdr (dump_file, pdr);
+ }
+ isl_union_map *um
+ = isl_union_map_from_map (add_pdr_constraints (pdr, pbb));
+ reads = isl_union_map_union (reads, um);
+ if (dump_file)
+ {
+ fprintf (dump_file, "Reads depedence graph: ");
+ print_isl_union_map (dump_file, reads);
+ }
+ }
+ else if (pdr_write_p (pdr))
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, "Adding must write to depedence graph: ");
+ print_pdr (dump_file, pdr);
+ }
+ isl_union_map *um
+ = isl_union_map_from_map (add_pdr_constraints (pdr, pbb));
+ must_writes = isl_union_map_union (must_writes, um);
+ if (dump_file)
+ {
+ fprintf (dump_file, "Must writes depedence graph: ");
+ print_isl_union_map (dump_file, must_writes);
+ }
+ }
+ else if (pdr_may_write_p (pdr))
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, "Adding may write to depedence graph: ");
+ print_pdr (dump_file, pdr);
+ }
+ isl_union_map *um
+ = isl_union_map_from_map (add_pdr_constraints (pdr, pbb));
+ may_writes = isl_union_map_union (may_writes, um);
+ if (dump_file)
+ {
+ fprintf (dump_file, "May writes depedence graph: ");
+ print_isl_union_map (dump_file, may_writes);
+ }
+ }
+ }
}
-
- fprintf (file, ")\n");
}
-/* Prints to STDERR the poly_ddr_p PDDR. */
+/* Helper function used on each MAP of a isl_union_map. Computes the
+ maximal output dimension. */
-DEBUG_FUNCTION void
-debug_pddr (poly_ddr_p pddr)
+static isl_stat
+max_number_of_out_dimensions (__isl_take isl_map *map, void *user)
{
- print_pddr (stderr, pddr);
-}
-
+ int global_max = *((int *) user);
+ isl_space *space = isl_map_get_space (map);
+ int nb_out = isl_space_dim (space, isl_dim_out);
-/* Remove all the dimensions except alias information at dimension
- ALIAS_DIM. */
+ if (global_max < nb_out)
+ *((int *) user) = nb_out;
-static void
-build_alias_set_powerset (ppl_Pointset_Powerset_C_Polyhedron_t alias_powerset,
- ppl_dimension_type alias_dim)
-{
- ppl_dimension_type *ds;
- ppl_dimension_type access_dim;
- unsigned i, pos = 0;
-
- ppl_Pointset_Powerset_C_Polyhedron_space_dimension (alias_powerset,
- &access_dim);
- ds = XNEWVEC (ppl_dimension_type, access_dim-1);
- for (i = 0; i < access_dim; i++)
- {
- if (i == alias_dim)
- continue;
-
- ds[pos] = i;
- pos++;
- }
-
- ppl_Pointset_Powerset_C_Polyhedron_remove_space_dimensions (alias_powerset,
- ds,
- access_dim - 1);
- free (ds);
+ isl_map_free (map);
+ isl_space_free (space);
+ return isl_stat_ok;
}
-/* Return true when PDR1 and PDR2 may alias. */
+/* Extends the output dimension of MAP to MAX dimensions. */
-static bool
-poly_drs_may_alias_p (poly_dr_p pdr1, poly_dr_p pdr2)
+static __isl_give isl_map *
+extend_map (__isl_take isl_map *map, int max)
{
- ppl_Pointset_Powerset_C_Polyhedron_t alias_powerset1, alias_powerset2;
- ppl_Pointset_Powerset_C_Polyhedron_t accesses1 = PDR_ACCESSES (pdr1);
- ppl_Pointset_Powerset_C_Polyhedron_t accesses2 = PDR_ACCESSES (pdr2);
- ppl_dimension_type alias_dim1 = pdr_alias_set_dim (pdr1);
- ppl_dimension_type alias_dim2 = pdr_alias_set_dim (pdr2);
- int empty_p;
-
- ppl_new_Pointset_Powerset_C_Polyhedron_from_Pointset_Powerset_C_Polyhedron
- (&alias_powerset1, accesses1);
- ppl_new_Pointset_Powerset_C_Polyhedron_from_Pointset_Powerset_C_Polyhedron
- (&alias_powerset2, accesses2);
-
- build_alias_set_powerset (alias_powerset1, alias_dim1);
- build_alias_set_powerset (alias_powerset2, alias_dim2);
-
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign
- (alias_powerset1, alias_powerset2);
+ isl_space *space = isl_map_get_space (map);
+ int n = isl_space_dim (space, isl_dim_out);
- empty_p = ppl_Pointset_Powerset_C_Polyhedron_is_empty (alias_powerset1);
-
- ppl_delete_Pointset_Powerset_C_Polyhedron (alias_powerset1);
- ppl_delete_Pointset_Powerset_C_Polyhedron (alias_powerset2);
-
- return !empty_p;
+ isl_space_free (space);
+ return isl_map_add_dims (map, isl_dim_out, max - n);
}
-/* Swap [cut0, ..., cut1] to the end of DR: "a CUT0 b CUT1 c" is
- transformed into "a CUT0 c CUT1' b"
-
- Add NB0 zeros before "a": "00...0 a CUT0 c CUT1' b"
- Add NB1 zeros between "a" and "c": "00...0 a 00...0 c CUT1' b"
- Add DIM - NB0 - NB1 - PDIM zeros between "c" and "b":
- "00...0 a 00...0 c 00...0 b". */
-
-static ppl_Pointset_Powerset_C_Polyhedron_t
-map_dr_into_dep_poly (graphite_dim_t dim,
- ppl_Pointset_Powerset_C_Polyhedron_t dr,
- graphite_dim_t cut0, graphite_dim_t cut1,
- graphite_dim_t nb0, graphite_dim_t nb1)
-{
- ppl_dimension_type pdim;
- ppl_dimension_type *map;
- ppl_Pointset_Powerset_C_Polyhedron_t res;
- ppl_dimension_type i;
-
- ppl_new_Pointset_Powerset_C_Polyhedron_from_Pointset_Powerset_C_Polyhedron
- (&res, dr);
- ppl_Pointset_Powerset_C_Polyhedron_space_dimension (res, &pdim);
-
- map = (ppl_dimension_type *) XNEWVEC (ppl_dimension_type, pdim);
-
- /* First mapping: move 'g' vector to right position. */
- for (i = 0; i < cut0; i++)
- map[i] = i;
-
- for (i = cut0; i < cut1; i++)
- map[i] = pdim - cut1 + i;
-
- for (i = cut1; i < pdim; i++)
- map[i] = cut0 + i - cut1;
-
- ppl_Pointset_Powerset_C_Polyhedron_map_space_dimensions (res, map, pdim);
- free (map);
+/* Structure used to pass parameters to extend_schedule_1. */
- /* After swapping 's' and 'g' vectors, we have to update a new cut. */
- cut1 = pdim - cut1 + cut0;
+struct extend_schedule_str {
+ int max;
+ isl_union_map *umap;
+};
- ppl_insert_dimensions_pointset (res, 0, nb0);
- ppl_insert_dimensions_pointset (res, nb0 + cut0, nb1);
- ppl_insert_dimensions_pointset (res, nb0 + nb1 + cut1,
- dim - nb0 - nb1 - pdim);
+/* Helper function for extend_schedule. */
- return res;
-}
-
-/* Builds subscript equality constraints. */
-
-static ppl_Pointset_Powerset_C_Polyhedron_t
-dr_equality_constraints (graphite_dim_t dim,
- graphite_dim_t pos, graphite_dim_t nb_subscripts)
+static isl_stat
+extend_schedule_1 (__isl_take isl_map *map, void *user)
{
- ppl_Polyhedron_t eqs;
- ppl_Pointset_Powerset_C_Polyhedron_t res;
- graphite_dim_t i;
-
- ppl_new_C_Polyhedron_from_space_dimension (&eqs, dim, 0);
-
- for (i = 0; i < nb_subscripts; i++)
- {
- ppl_Constraint_t cstr
- = ppl_build_relation (dim, pos + i, pos + i + nb_subscripts,
- 0, PPL_CONSTRAINT_TYPE_EQUAL);
- ppl_Polyhedron_add_constraint (eqs, cstr);
- ppl_delete_Constraint (cstr);
- }
-
- ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron (&res, eqs);
- ppl_delete_Polyhedron (eqs);
- return res;
+ struct extend_schedule_str *str = (struct extend_schedule_str *) user;
+ str->umap = isl_union_map_add_map (str->umap, extend_map (map, str->max));
+ return isl_stat_ok;
}
-/* Builds scheduling inequality constraints: when DIRECTION is
- 1 builds a GE constraint,
- 0 builds an EQ constraint,
- -1 builds a LE constraint.
- DIM is the dimension of the scheduling space.
- POS and POS + OFFSET are the dimensions that are related. */
-
-static ppl_Pointset_Powerset_C_Polyhedron_t
-build_pairwise_scheduling (graphite_dim_t dim,
- graphite_dim_t pos,
- graphite_dim_t offset,
- int direction)
-{
- ppl_Pointset_Powerset_C_Polyhedron_t res;
- ppl_Polyhedron_t equalities;
- ppl_Constraint_t cstr;
- graphite_dim_t a = pos;
- graphite_dim_t b = pos + offset;
-
- ppl_new_C_Polyhedron_from_space_dimension (&equalities, dim, 0);
-
- switch (direction)
- {
- case 1:
- /* Builds "a + 1 <= b. */
- cstr = ppl_build_relation (dim, a, b, 1,
- PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL);
- break;
-
- case 0:
- /* Builds "a = b. */
- cstr = ppl_build_relation (dim, a, b, 0,
- PPL_CONSTRAINT_TYPE_EQUAL);
- break;
-
- case -1:
- /* Builds "a >= b + 1. */
- cstr = ppl_build_relation (dim, a, b, -1,
- PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
- break;
-
- default:
- gcc_unreachable ();
- }
-
- ppl_Polyhedron_add_constraint (equalities, cstr);
- ppl_delete_Constraint (cstr);
-
- ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron (&res, equalities);
- ppl_delete_Polyhedron (equalities);
- return res;
-}
+/* Return a relation that has uniform output dimensions. */
-/* Add to a non empty polyhedron BAG the precedence constraints for
- the lexicographical comparison of time vectors in BAG following the
- lexicographical order. DIM is the dimension of the polyhedron BAG.
- TDIM is the number of loops common to the two statements that are
- compared lexicographically, i.e. the number of loops containing
- both statements. OFFSET is the number of dimensions needed to
- represent the first statement, i.e. dimT1 + dimI1 in the layout of
- the BAG polyhedron: T1|I1|T2|I2|S1|S2|G. When DIRECTION is set to
- 1, compute the direct dependence from PDR1 to PDR2, and when
- DIRECTION is -1, compute the reversed dependence relation, from
- PDR2 to PDR1. */
-
-static ppl_Pointset_Powerset_C_Polyhedron_t
-build_lexicographical_constraint (ppl_Pointset_Powerset_C_Polyhedron_t bag,
- graphite_dim_t dim,
- graphite_dim_t tdim,
- graphite_dim_t offset,
- int direction)
+static __isl_give isl_union_map *
+extend_schedule (__isl_take isl_union_map *x)
{
- graphite_dim_t i;
- ppl_Pointset_Powerset_C_Polyhedron_t res, lex;
-
- ppl_new_Pointset_Powerset_C_Polyhedron_from_space_dimension (&res, dim, 1);
-
- lex = build_pairwise_scheduling (dim, 0, offset, direction);
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (lex, bag);
-
- if (!ppl_Pointset_Powerset_C_Polyhedron_is_empty (lex))
- ppl_Pointset_Powerset_C_Polyhedron_upper_bound_assign (res, lex);
-
- ppl_delete_Pointset_Powerset_C_Polyhedron (lex);
-
- for (i = 0; i < tdim - 1; i++)
- {
- ppl_Pointset_Powerset_C_Polyhedron_t sceq;
-
- sceq = build_pairwise_scheduling (dim, i, offset, 0);
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (bag, sceq);
- ppl_delete_Pointset_Powerset_C_Polyhedron (sceq);
-
- if (ppl_Pointset_Powerset_C_Polyhedron_is_empty (bag))
- break;
-
- lex = build_pairwise_scheduling (dim, i + 1, offset, direction);
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (lex, bag);
-
- if (!ppl_Pointset_Powerset_C_Polyhedron_is_empty (lex))
- ppl_Pointset_Powerset_C_Polyhedron_upper_bound_assign (res, lex);
+ int max = 0;
+ struct extend_schedule_str str;
- ppl_delete_Pointset_Powerset_C_Polyhedron (lex);
- }
-
- return res;
+ isl_union_map_foreach_map (x, max_number_of_out_dimensions, (void *) &max);
+ str.max = max;
+ str.umap = isl_union_map_empty (isl_union_map_get_space (x));
+ isl_union_map_foreach_map (x, extend_schedule_1, (void *) &str);
+ isl_union_map_free (x);
+ return isl_union_map_coalesce (str.umap);
}
-/* Build the dependence polyhedron for data references PDR1 and PDR2.
- The layout of the dependence polyhedron is:
-
- T1|I1|T2|I2|S1|S2|G
+/* Applies SCHEDULE to the in and out dimensions of the dependences
+ DEPS and return the resulting relation. */
- with
- | T1 and T2 the scattering dimensions for PDR1 and PDR2
- | I1 and I2 the iteration domains
- | S1 and S2 the subscripts
- | G the global parameters.
-
- When DIRECTION is set to 1, compute the direct dependence from PDR1
- to PDR2, and when DIRECTION is -1, compute the reversed dependence
- relation, from PDR2 to PDR1. */
-
-static ppl_Pointset_Powerset_C_Polyhedron_t
-dependence_polyhedron_1 (poly_dr_p pdr1, poly_dr_p pdr2,
- int direction, bool original_scattering_p)
+static isl_map *
+apply_schedule_on_deps (__isl_keep isl_union_map *schedule,
+ __isl_keep isl_union_map *deps)
{
- poly_bb_p pbb1 = PDR_PBB (pdr1);
- poly_bb_p pbb2 = PDR_PBB (pdr2);
- scop_p scop = PBB_SCOP (pbb1);
- graphite_dim_t tdim1 = original_scattering_p ?
- pbb_nb_scattering_orig (pbb1) : pbb_nb_scattering_transform (pbb1);
- graphite_dim_t tdim2 = original_scattering_p ?
- pbb_nb_scattering_orig (pbb2) : pbb_nb_scattering_transform (pbb2);
- graphite_dim_t ddim1 = pbb_dim_iter_domain (pbb1);
- graphite_dim_t ddim2 = pbb_dim_iter_domain (pbb2);
- graphite_dim_t sdim1 = PDR_NB_SUBSCRIPTS (pdr1) + 1;
- graphite_dim_t sdim2 = PDR_NB_SUBSCRIPTS (pdr2) + 1;
- graphite_dim_t gdim = scop_nb_params (scop);
- graphite_dim_t dim1 = pdr_dim (pdr1);
- graphite_dim_t dim2 = pdr_dim (pdr2);
- graphite_dim_t dim = tdim1 + tdim2 + dim1 + dim2 - gdim;
- ppl_Pointset_Powerset_C_Polyhedron_t res;
- ppl_Pointset_Powerset_C_Polyhedron_t idr1, idr2;
- ppl_Pointset_Powerset_C_Polyhedron_t sc1, sc2, dreq;
-
- gcc_assert (PBB_SCOP (pbb1) == PBB_SCOP (pbb2));
-
- combine_context_id_scat (&sc1, pbb1, original_scattering_p);
- combine_context_id_scat (&sc2, pbb2, original_scattering_p);
-
- ppl_insert_dimensions_pointset (sc1, tdim1 + ddim1,
- tdim2 + ddim2 + sdim1 + sdim2);
-
- ppl_insert_dimensions_pointset (sc2, 0, tdim1 + ddim1);
- ppl_insert_dimensions_pointset (sc2, tdim1 + ddim1 + tdim2 + ddim2,
- sdim1 + sdim2);
-
- idr1 = map_dr_into_dep_poly (dim, PDR_ACCESSES (pdr1), ddim1, ddim1 + gdim,
- tdim1, tdim2 + ddim2);
- idr2 = map_dr_into_dep_poly (dim, PDR_ACCESSES (pdr2), ddim2, ddim2 + gdim,
- tdim1 + ddim1 + tdim2, sdim1);
-
- /* Now add the subscript equalities. */
- dreq = dr_equality_constraints (dim, tdim1 + ddim1 + tdim2 + ddim2, sdim1);
-
- ppl_new_Pointset_Powerset_C_Polyhedron_from_space_dimension (&res, dim, 0);
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (res, sc1);
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (res, sc2);
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (res, idr1);
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (res, idr2);
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (res, dreq);
- ppl_delete_Pointset_Powerset_C_Polyhedron (sc1);
- ppl_delete_Pointset_Powerset_C_Polyhedron (sc2);
- ppl_delete_Pointset_Powerset_C_Polyhedron (idr1);
- ppl_delete_Pointset_Powerset_C_Polyhedron (idr2);
- ppl_delete_Pointset_Powerset_C_Polyhedron (dreq);
-
- if (!ppl_Pointset_Powerset_C_Polyhedron_is_empty (res))
- {
- ppl_Pointset_Powerset_C_Polyhedron_t lex =
- build_lexicographical_constraint (res, dim, MIN (tdim1, tdim2),
- tdim1 + ddim1, direction);
- ppl_delete_Pointset_Powerset_C_Polyhedron (res);
- res = lex;
- }
-
- return res;
-}
+ isl_union_map *trans = extend_schedule (isl_union_map_copy (schedule));
+ isl_union_map *ux = isl_union_map_copy (deps);
+ ux = isl_union_map_apply_domain (ux, isl_union_map_copy (trans));
+ ux = isl_union_map_apply_range (ux, trans);
+ ux = isl_union_map_coalesce (ux);
-/* Build the dependence polyhedron for data references PDR1 and PDR2.
- If possible use already cached information.
-
- When DIRECTION is set to 1, compute the direct dependence from PDR1
- to PDR2, and when DIRECTION is -1, compute the reversed dependence
- relation, from PDR2 to PDR1. */
-
-static poly_ddr_p
-dependence_polyhedron (poly_dr_p pdr1, poly_dr_p pdr2,
- int direction, bool original_scattering_p)
-{
- PTR *x = NULL;
- poly_ddr_p res;
- ppl_Pointset_Powerset_C_Polyhedron_t ddp;
+ if (!isl_union_map_is_empty (ux))
+ return isl_map_from_union_map (ux);
- /* Return the PDDR from the cache if it already has been computed. */
- if (original_scattering_p)
- {
- struct poly_ddr tmp;
- scop_p scop = PBB_SCOP (PDR_PBB (pdr1));
-
- tmp.source = pdr1;
- tmp.sink = pdr2;
- x = htab_find_slot (SCOP_ORIGINAL_PDDRS (scop),
- &tmp, INSERT);
-
- if (x && *x)
- return (poly_ddr_p) *x;
- }
-
- if ((pdr_read_p (pdr1) && pdr_read_p (pdr2))
- || PDR_BASE_OBJECT_SET (pdr1) != PDR_BASE_OBJECT_SET (pdr2)
- || PDR_NB_SUBSCRIPTS (pdr1) != PDR_NB_SUBSCRIPTS (pdr2)
- || !poly_drs_may_alias_p (pdr1, pdr2))
- ddp = NULL;
- else
- ddp = dependence_polyhedron_1 (pdr1, pdr2, direction,
- original_scattering_p);
-
- res = new_poly_ddr (pdr1, pdr2, ddp, original_scattering_p);
-
- if (!(pdr_read_p (pdr1) && pdr_read_p (pdr2))
- && PDR_BASE_OBJECT_SET (pdr1) != PDR_BASE_OBJECT_SET (pdr2)
- && poly_drs_may_alias_p (pdr1, pdr2))
- PDDR_KIND (res) = unknown_dependence;
-
- if (original_scattering_p)
- *x = res;
-
- return res;
+ isl_union_map_free (ux);
+ return NULL;
}
-/* Return true when the data dependence relation between the data
- references PDR1 belonging to PBB1 and PDR2 is part of a
- reduction. */
+/* Return true when DEPS is non empty and the intersection of LEX with
+ the DEPS transformed by SCHEDULE is non empty. LEX is the relation
+ in which all the inputs before DEPTH occur at the same time as the
+ output, and the input at DEPTH occurs before output. */
-static inline bool
-reduction_dr_1 (poly_bb_p pbb1, poly_dr_p pdr1, poly_dr_p pdr2)
-{
- int i;
- poly_dr_p pdr;
-
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb1), i, pdr)
- if (PDR_TYPE (pdr) == PDR_WRITE)
- break;
-
- return same_pdr_p (pdr, pdr1) && same_pdr_p (pdr, pdr2);
-}
-
-/* Return true when the data dependence relation between the data
- references PDR1 belonging to PBB1 and PDR2 belonging to PBB2 is
- part of a reduction. */
-
-static inline bool
-reduction_dr_p (poly_dr_p pdr1, poly_dr_p pdr2)
-{
- poly_bb_p pbb1 = PDR_PBB (pdr1);
- poly_bb_p pbb2 = PDR_PBB (pdr2);
-
- if (PBB_IS_REDUCTION (pbb1))
- return reduction_dr_1 (pbb1, pdr1, pdr2);
-
- if (PBB_IS_REDUCTION (pbb2))
- return reduction_dr_1 (pbb2, pdr2, pdr1);
-
- return false;
-}
-
-/* Returns true when the PBB_TRANSFORMED_SCATTERING functions of PBB1
- and PBB2 respect the data dependences of PBB_ORIGINAL_SCATTERING
- functions. */
-
-static bool
-graphite_legal_transform_dr (poly_dr_p pdr1, poly_dr_p pdr2)
+bool
+carries_deps (__isl_keep isl_union_map *schedule,
+ __isl_keep isl_union_map *deps,
+ int depth)
{
- ppl_Pointset_Powerset_C_Polyhedron_t po, pt;
- graphite_dim_t ddim1, otdim1, otdim2, ttdim1, ttdim2;
- ppl_Pointset_Powerset_C_Polyhedron_t po_temp;
- ppl_dimension_type pdim;
- bool is_empty_p;
- poly_ddr_p opddr, tpddr;
- poly_bb_p pbb1, pbb2;
-
- if (reduction_dr_p (pdr1, pdr2))
- return true;
-
- /* We build the reverse dependence relation for the transformed
- scattering, such that when we intersect it with the original PO,
- we get an empty intersection when the transform is legal:
- i.e. the transform should reverse no dependences, and so PT, the
- reversed transformed PDDR, should have no constraint from PO. */
- opddr = dependence_polyhedron (pdr1, pdr2, 1, true);
-
- if (PDDR_KIND (opddr) == unknown_dependence)
+ if (isl_union_map_is_empty (deps))
return false;
- /* There are no dependences between PDR1 and PDR2 in the original
- version of the program, or after the transform, so the
- transform is legal. */
- if (pddr_is_empty (opddr))
- return true;
-
- tpddr = dependence_polyhedron (pdr1, pdr2, -1, false);
-
- if (PDDR_KIND (tpddr) == unknown_dependence)
- {
- free_poly_ddr (tpddr);
- return false;
- }
-
- if (pddr_is_empty (tpddr))
- {
- free_poly_ddr (tpddr);
- return true;
- }
-
- po = PDDR_DDP (opddr);
- pt = PDDR_DDP (tpddr);
-
- /* Copy PO into PO_TEMP, such that PO is not destroyed. PO is
- stored in a cache and should not be modified or freed. */
- ppl_Pointset_Powerset_C_Polyhedron_space_dimension (po, &pdim);
- ppl_new_Pointset_Powerset_C_Polyhedron_from_space_dimension (&po_temp,
- pdim, 0);
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (po_temp, po);
-
- /* Extend PO and PT to have the same dimensions. */
- pbb1 = PDR_PBB (pdr1);
- pbb2 = PDR_PBB (pdr2);
- ddim1 = pbb_dim_iter_domain (pbb1);
- otdim1 = pbb_nb_scattering_orig (pbb1);
- otdim2 = pbb_nb_scattering_orig (pbb2);
- ttdim1 = pbb_nb_scattering_transform (pbb1);
- ttdim2 = pbb_nb_scattering_transform (pbb2);
- ppl_insert_dimensions_pointset (po_temp, otdim1, ttdim1);
- ppl_insert_dimensions_pointset (po_temp, otdim1 + ttdim1 + ddim1 + otdim2,
- ttdim2);
- ppl_insert_dimensions_pointset (pt, 0, otdim1);
- ppl_insert_dimensions_pointset (pt, otdim1 + ttdim1 + ddim1, otdim2);
-
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (po_temp, pt);
- is_empty_p = ppl_Pointset_Powerset_C_Polyhedron_is_empty (po_temp);
-
- ppl_delete_Pointset_Powerset_C_Polyhedron (po_temp);
- free_poly_ddr (tpddr);
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "\nloop carries dependency.\n");
-
- return is_empty_p;
-}
-
-/* Return true when the data dependence relation for PBB1 and PBB2 is
- part of a reduction. */
-
-static inline bool
-reduction_ddr_p (poly_bb_p pbb1, poly_bb_p pbb2)
-{
- return pbb1 == pbb2 && PBB_IS_REDUCTION (pbb1);
-}
-
-/* Iterates over the data references of PBB1 and PBB2 and detect
- whether the transformed schedule is correct. */
-
-static bool
-graphite_legal_transform_bb (poly_bb_p pbb1, poly_bb_p pbb2)
-{
- int i, j;
- poly_dr_p pdr1, pdr2;
-
- if (!PBB_PDR_DUPLICATES_REMOVED (pbb1))
- pbb_remove_duplicate_pdrs (pbb1);
+ isl_map *x = apply_schedule_on_deps (schedule, deps);
+ if (x == NULL)
+ return false;
- if (!PBB_PDR_DUPLICATES_REMOVED (pbb2))
- pbb_remove_duplicate_pdrs (pbb2);
+ isl_space *space = isl_map_get_space (x);
+ isl_map *lex = isl_map_lex_le (isl_space_range (space));
+ isl_constraint *ineq = isl_inequality_alloc
+ (isl_local_space_from_space (isl_map_get_space (x)));
- if (reduction_ddr_p (pbb1, pbb2))
- return true;
+ for (int i = 0; i < depth - 1; i++)
+ lex = isl_map_equate (lex, isl_dim_in, i, isl_dim_out, i);
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb1), i, pdr1)
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb2), j, pdr2)
- if (!graphite_legal_transform_dr (pdr1, pdr2))
- return false;
+ /* in + 1 <= out */
+ ineq = isl_constraint_set_coefficient_si (ineq, isl_dim_out, depth - 1, 1);
+ ineq = isl_constraint_set_coefficient_si (ineq, isl_dim_in, depth - 1, -1);
+ ineq = isl_constraint_set_constant_si (ineq, -1);
+ lex = isl_map_add_constraint (lex, ineq);
+ lex = isl_map_coalesce (lex);
+ x = isl_map_intersect (x, lex);
+ bool res = !isl_map_is_empty (x);
- return true;
+ isl_map_free (x);
+ return res;
}
-/* Iterates over the SCOP and detect whether the transformed schedule
- is correct. */
+/* Compute the dependence relations for the SCOP:
+ RAW are read after write dependences,
+ WAR are write after read dependences,
+ WAW are write after write dependences. */
-bool
-graphite_legal_transform (scop_p scop)
+void
+scop_get_dependences (scop_p scop)
{
- int i, j;
- poly_bb_p pbb1, pbb2;
-
- timevar_push (TV_GRAPHITE_DATA_DEPS);
-
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb1)
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), j, pbb2)
- if (!graphite_legal_transform_bb (pbb1, pbb2))
- {
- timevar_pop (TV_GRAPHITE_DATA_DEPS);
- return false;
- }
-
- timevar_pop (TV_GRAPHITE_DATA_DEPS);
- return true;
-}
+ if (scop->dependence)
+ return;
-/* Returns TRUE when the dependence polyhedron between PDR1 and
- PDR2 represents a loop carried dependence at level LEVEL. */
+ isl_space *space = isl_set_get_space (scop->param_context);
+ isl_union_map *reads = isl_union_map_empty (isl_space_copy (space));
+ isl_union_map *must_writes = isl_union_map_empty (isl_space_copy (space));
+ isl_union_map *may_writes = isl_union_map_empty (space);
+ scop_get_reads_and_writes (scop, reads, must_writes, may_writes);
-static bool
-graphite_carried_dependence_level_k (poly_dr_p pdr1, poly_dr_p pdr2,
- int level)
-{
- ppl_Pointset_Powerset_C_Polyhedron_t po;
- ppl_Pointset_Powerset_C_Polyhedron_t eqpp;
- graphite_dim_t tdim1 = pbb_nb_scattering_transform (PDR_PBB (pdr1));
- graphite_dim_t ddim1 = pbb_dim_iter_domain (PDR_PBB (pdr1));
- ppl_dimension_type dim;
- bool empty_p;
- poly_ddr_p pddr = dependence_polyhedron (pdr1, pdr2, 1, false);
-
- if (PDDR_KIND (pddr) == unknown_dependence)
+ if (dump_file)
{
- free_poly_ddr (pddr);
- return true;
+ fprintf (dump_file, "\n--- Documentation for datarefs dump: ---\n");
+ fprintf (dump_file, "Statements on the iteration domain are mapped to"
+ " array references.\n");
+ fprintf (dump_file, " To read the following data references:\n\n");
+ fprintf (dump_file, " S_5[i0] -> [106] : i0 >= 0 and i0 <= 3\n");
+ fprintf (dump_file, " S_8[i0] -> [1, i0] : i0 >= 0 and i0 <= 3\n\n");
+
+ fprintf (dump_file, " S_5[i0] is the dynamic instance of statement"
+ " bb_5 in a loop that accesses all iterations 0 <= i0 <= 3.\n");
+ fprintf (dump_file, " [1, i0] is a 'memref' with alias set 1"
+ " and first subscript access i0.\n");
+ fprintf (dump_file, " [106] is a 'scalar reference' which is the sum of"
+ " SSA_NAME_VERSION 6"
+ " and --param graphite-max-arrays-per-scop=100\n");
+ fprintf (dump_file, "-----------------------\n\n");
+
+ fprintf (dump_file, "data references (\n");
+ fprintf (dump_file, " reads: ");
+ print_isl_union_map (dump_file, reads);
+ fprintf (dump_file, " must_writes: ");
+ print_isl_union_map (dump_file, must_writes);
+ fprintf (dump_file, " may_writes: ");
+ print_isl_union_map (dump_file, may_writes);
+ fprintf (dump_file, ")\n");
}
- if (pddr_is_empty (pddr))
+ gcc_assert (scop->original_schedule);
+
+ isl_union_access_info *ai;
+ ai = isl_union_access_info_from_sink (isl_union_map_copy (reads));
+ ai = isl_union_access_info_set_must_source (ai, isl_union_map_copy (must_writes));
+ ai = isl_union_access_info_set_may_source (ai, may_writes);
+ ai = isl_union_access_info_set_schedule
+ (ai, isl_schedule_copy (scop->original_schedule));
+ isl_union_flow *flow = isl_union_access_info_compute_flow (ai);
+ isl_union_map *raw = isl_union_flow_get_must_dependence (flow);
+ isl_union_flow_free (flow);
+
+ ai = isl_union_access_info_from_sink (isl_union_map_copy (must_writes));
+ ai = isl_union_access_info_set_must_source (ai, must_writes);
+ ai = isl_union_access_info_set_may_source (ai, reads);
+ ai = isl_union_access_info_set_schedule
+ (ai, isl_schedule_copy (scop->original_schedule));
+ flow = isl_union_access_info_compute_flow (ai);
+
+ isl_union_map *waw = isl_union_flow_get_must_dependence (flow);
+ isl_union_map *war = isl_union_flow_get_may_dependence (flow);
+ war = isl_union_map_subtract (war, isl_union_map_copy (waw));
+ isl_union_flow_free (flow);
+
+ raw = isl_union_map_coalesce (raw);
+ waw = isl_union_map_coalesce (waw);
+ war = isl_union_map_coalesce (war);
+
+ isl_union_map *dependences = raw;
+ dependences = isl_union_map_union (dependences, war);
+ dependences = isl_union_map_union (dependences, waw);
+ dependences = isl_union_map_coalesce (dependences);
+
+ if (dump_file)
{
- free_poly_ddr (pddr);
- return false;
+ fprintf (dump_file, "data dependences (\n");
+ print_isl_union_map (dump_file, dependences);
+ fprintf (dump_file, ")\n");
}
- po = PDDR_DDP (pddr);
- ppl_Pointset_Powerset_C_Polyhedron_space_dimension (po, &dim);
- eqpp = build_pairwise_scheduling (dim, level, tdim1 + ddim1, 1);
-
- ppl_Pointset_Powerset_C_Polyhedron_intersection_assign (eqpp, po);
- empty_p = ppl_Pointset_Powerset_C_Polyhedron_is_empty (eqpp);
-
- ppl_delete_Pointset_Powerset_C_Polyhedron (eqpp);
- free_poly_ddr (pddr);
-
- return !empty_p;
-}
-
-/* Check data dependency between PBB1 and PBB2 at level LEVEL. */
-
-bool
-dependency_between_pbbs_p (poly_bb_p pbb1, poly_bb_p pbb2, int level)
-{
- int i, j;
- poly_dr_p pdr1, pdr2;
-
- timevar_push (TV_GRAPHITE_DATA_DEPS);
-
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb1), i, pdr1)
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb2), j, pdr2)
- if (graphite_carried_dependence_level_k (pdr1, pdr2, level))
- {
- timevar_pop (TV_GRAPHITE_DATA_DEPS);
- return true;
- }
-
- timevar_pop (TV_GRAPHITE_DATA_DEPS);
- return false;
-}
-
-/* Pretty print to FILE all the original data dependences of SCoP in
- DOT format. */
-
-static void
-dot_original_deps_stmt_1 (FILE *file, scop_p scop)
-{
- int i, j, k, l;
- poly_bb_p pbb1, pbb2;
- poly_dr_p pdr1, pdr2;
-
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb1)
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), j, pbb2)
- {
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb1), k, pdr1)
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb2), l, pdr2)
- if (!pddr_is_empty (dependence_polyhedron (pdr1, pdr2, 1, true)))
- {
- fprintf (file, "OS%d -> OS%d\n",
- pbb_index (pbb1), pbb_index (pbb2));
- goto done;
- }
- done:;
- }
-}
-
-/* Pretty print to FILE all the transformed data dependences of SCoP in
- DOT format. */
-
-static void
-dot_transformed_deps_stmt_1 (FILE *file, scop_p scop)
-{
- int i, j, k, l;
- poly_bb_p pbb1, pbb2;
- poly_dr_p pdr1, pdr2;
-
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb1)
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), j, pbb2)
- {
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb1), k, pdr1)
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb2), l, pdr2)
- {
- poly_ddr_p pddr = dependence_polyhedron (pdr1, pdr2, 1, false);
-
- if (!pddr_is_empty (pddr))
- {
- fprintf (file, "TS%d -> TS%d\n",
- pbb_index (pbb1), pbb_index (pbb2));
-
- free_poly_ddr (pddr);
- goto done;
- }
-
- free_poly_ddr (pddr);
- }
- done:;
- }
-}
-
-
-/* Pretty print to FILE all the data dependences of SCoP in DOT
- format. */
-
-static void
-dot_deps_stmt_1 (FILE *file, scop_p scop)
-{
- fputs ("digraph all {\n", file);
-
- dot_original_deps_stmt_1 (file, scop);
- dot_transformed_deps_stmt_1 (file, scop);
-
- fputs ("}\n\n", file);
-}
-
-/* Pretty print to FILE all the original data dependences of SCoP in
- DOT format. */
-
-static void
-dot_original_deps (FILE *file, scop_p scop)
-{
- int i, j, k, l;
- poly_bb_p pbb1, pbb2;
- poly_dr_p pdr1, pdr2;
-
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb1)
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), j, pbb2)
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb1), k, pdr1)
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb2), l, pdr2)
- if (!pddr_is_empty (dependence_polyhedron (pdr1, pdr2, 1, true)))
- fprintf (file, "OS%d_D%d -> OS%d_D%d\n",
- pbb_index (pbb1), PDR_ID (pdr1),
- pbb_index (pbb2), PDR_ID (pdr2));
-}
-
-/* Pretty print to FILE all the transformed data dependences of SCoP in
- DOT format. */
-
-static void
-dot_transformed_deps (FILE *file, scop_p scop)
-{
- int i, j, k, l;
- poly_bb_p pbb1, pbb2;
- poly_dr_p pdr1, pdr2;
-
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb1)
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), j, pbb2)
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb1), k, pdr1)
- FOR_EACH_VEC_ELT (poly_dr_p, PBB_DRS (pbb2), l, pdr2)
- {
- poly_ddr_p pddr = dependence_polyhedron (pdr1, pdr2, 1, false);
-
- if (!pddr_is_empty (pddr))
- fprintf (file, "TS%d_D%d -> TS%d_D%d\n",
- pbb_index (pbb1), PDR_ID (pdr1),
- pbb_index (pbb2), PDR_ID (pdr2));
-
- free_poly_ddr (pddr);
- }
-}
-
-/* Pretty print to FILE all the data dependences of SCoP in DOT
- format. */
-
-static void
-dot_deps_1 (FILE *file, scop_p scop)
-{
- fputs ("digraph all {\n", file);
-
- dot_original_deps (file, scop);
- dot_transformed_deps (file, scop);
-
- fputs ("}\n\n", file);
-}
-
-/* Display all the data dependences in SCoP using dotty. */
-
-DEBUG_FUNCTION void
-dot_deps (scop_p scop)
-{
- /* When debugging, enable the following code. This cannot be used
- in production compilers because it calls "system". */
-#if 0
- FILE *stream = fopen ("/tmp/scopdeps.dot", "w");
- gcc_assert (stream);
-
- dot_deps_1 (stream, scop);
- fclose (stream);
-
- system ("dotty /tmp/scopdeps.dot &");
-#else
- dot_deps_1 (stderr, scop);
-#endif
-}
-
-/* Display all the statement dependences in SCoP using dotty. */
-
-DEBUG_FUNCTION void
-dot_deps_stmt (scop_p scop)
-{
- /* When debugging, enable the following code. This cannot be used
- in production compilers because it calls "system". */
-#if 0
- FILE *stream = fopen ("/tmp/scopdeps.dot", "w");
- gcc_assert (stream);
-
- dot_deps_stmt_1 (stream, scop);
- fclose (stream);
-
- system ("dotty /tmp/scopdeps.dot &");
-#else
- dot_deps_stmt_1 (stderr, scop);
-#endif
+ scop->dependence = dependences;
}
-#endif
+#endif /* HAVE_isl */