--- /dev/null
+From b561f860f2fefa84459750d576807d214e4aad97 Mon Sep 17 00:00:00 2001
+From: Sven Verdoolaege <skimo@kotnet.org>
+Date: Sun, 12 Jan 2014 14:35:00 +0100
+Subject: [PATCH] cloog_domain_cube: reimplement using documented functions
+
+The original implementation used the undocumented
+isl_basic_set_interval function, which will be removed
+in the next release of isl.
+
+Signed-off-by: Sven Verdoolaege <skimo@kotnet.org>
+Signed-off-by: Cedric Bastoul <cedric.bastoul@unistra.fr>
+---
+ source/isl/domain.c | 20 ++++++++++----------
+ 1 files changed, 10 insertions(+), 10 deletions(-)
+
+diff --git a/source/isl/domain.c b/source/isl/domain.c
+index d11da7b..620584d 100644
+--- a/source/isl/domain.c
++++ b/source/isl/domain.c
+@@ -1389,20 +1389,20 @@ CloogDomain *cloog_domain_cube(CloogState *state,
+ int dim, cloog_int_t min, cloog_int_t max)
+ {
+ int i;
+- struct isl_basic_set *cube;
+- struct isl_basic_set *interval;
+- struct isl_basic_set_list *list;
++ isl_space *space;
++ isl_set *cube;
+
+ if (dim == 0)
+ return cloog_domain_universe(state, dim);
+
+- interval = isl_basic_set_interval(state->backend->ctx, min, max);
+- list = isl_basic_set_list_alloc(state->backend->ctx, dim);
+- for (i = 0; i < dim; ++i)
+- list = isl_basic_set_list_add(list, isl_basic_set_copy(interval));
+- isl_basic_set_free(interval);
+- cube = isl_basic_set_list_product(list);
+- return cloog_domain_from_isl_set(isl_set_from_basic_set(cube));
++ space = isl_space_set_alloc(state->backend->ctx, 0, dim);
++ cube = isl_set_universe(space);
++ for (i = 0; i < dim; ++i) {
++ cube = isl_set_lower_bound(cube, isl_dim_set, i, min);
++ cube = isl_set_upper_bound(cube, isl_dim_set, i, max);
++ }
++
++ return cloog_domain_from_isl_set(cube);
+ }
+
+
+--
+1.7.6.6.GIT
+
+From 2d8b7c6b43ee46fee978a57fa6877de49675f357 Mon Sep 17 00:00:00 2001
+From: Taj Muhammad Khan <taj.khan@lri.fr>
+Date: Thu, 5 Dec 2013 07:55:16 +0530
+Subject: [PATCH] Use isl_val instead of isl_int
+
+isl is moving from the macro-based isl_int to a more generic
+integer type isl_val, so CLooG does with this patch.
+Authors are Uday Bondhugula, Taj Muhammad Khan and Cedric Bastoul.
+---
+ include/cloog/isl/constraintset.h | 6 +
+ source/isl/constraints.c | 247 +++++++++++++++++++---------
+ source/isl/domain.c | 329 ++++++++++++++++++++++++-------------
+ 3 files changed, 389 insertions(+), 193 deletions(-)
+
+diff --git a/include/cloog/isl/constraintset.h b/include/cloog/isl/constraintset.h
+index c3c2eed..5d48cdb 100644
+--- a/include/cloog/isl/constraintset.h
++++ b/include/cloog/isl/constraintset.h
+@@ -27,6 +27,12 @@ CloogConstraintSet *cloog_constraint_set_from_isl_basic_set(struct isl_basic_set
+ CloogConstraint *cloog_constraint_from_isl_constraint(struct isl_constraint *constraint);
+ isl_constraint *cloog_constraint_to_isl(CloogConstraint *constraint);
+
++__isl_give isl_val *cloog_int_to_isl_val(isl_ctx* ctx, cloog_int_t c);
++void isl_val_to_cloog_int(__isl_keep isl_val *val, cloog_int_t *cint);
++
++__isl_give isl_val *cloog_constraint_coefficient_get_val(CloogConstraint *constraint,
++ int var);
++
+ #if defined(__cplusplus)
+ }
+ #endif
+diff --git a/source/isl/constraints.c b/source/isl/constraints.c
+index e860000..73d72df 100644
+--- a/source/isl/constraints.c
++++ b/source/isl/constraints.c
+@@ -5,11 +5,51 @@
+ #include <cloog/isl/backend.h>
+ #include <isl/aff.h>
+ #include <isl/set.h>
++#include <isl/val.h>
++#include <isl/val_gmp.h>
+
+
+ #define ALLOC(type) (type*)malloc(sizeof(type))
+ #define ALLOCN(type,n) (type*)malloc((n)*sizeof(type))
+
++__isl_give isl_val *cloog_int_to_isl_val(isl_ctx* ctx, cloog_int_t c)
++{
++ isl_val *v;
++#if defined(CLOOG_INT_INT)
++ v = isl_val_int_from_si(ctx, c);
++#elif defined(CLOOG_INT_LONG)
++ v = isl_val_int_from_si(ctx, c);
++#elif defined(CLOOG_INT_LONG_LONG)
++ v = isl_val_int_from_si(ctx, c);
++#elif defined(CLOOG_INT_GMP)
++ v = isl_val_int_from_gmp(ctx, c);
++#else
++#error "No integer type defined"
++#endif
++ return v;
++}
++
++/*
++ * CLooG'll be dealing in integers so we expect numerator/1 form
++ * from isl_val. Thus get numerator to assign to cloog_int
++ */
++void isl_val_to_cloog_int(__isl_keep isl_val *val, cloog_int_t *cint)
++{
++ assert(isl_val_is_int(val));
++#if defined(CLOOG_INT_INT)
++ *cint = isl_val_get_num_si(val);
++#elif defined(CLOOG_INT_LONG)
++ *cint = isl_val_get_num_si(val);
++#elif defined(CLOOG_INT_LONG_LONG)
++ *cint = isl_val_get_num_si(val);
++#elif defined(CLOOG_INT_GMP)
++ isl_val_get_num_gmp(val, *cint);
++#else
++#error "No integer type defined"
++#endif
++}
++
++
+ CloogConstraintSet *cloog_constraint_set_from_isl_basic_set(struct isl_basic_set *bset)
+ {
+ return (CloogConstraintSet *)bset;
+@@ -266,53 +306,65 @@ int cloog_equal_count(CloogEqualities *equal)
+ static int cloog_constraint_equal_type(CloogConstraint *cc, int level)
+ {
+ int i;
+- isl_int c;
++ isl_val *c;
+ int type = EQTYPE_NONE;
+ struct isl_constraint *constraint = cloog_constraint_to_isl(cc);
+
+- isl_int_init(c);
+- isl_constraint_get_constant(constraint, &c);
+- if (!isl_int_is_zero(c))
++ c = isl_constraint_get_constant_val(constraint);
++ if (!isl_val_is_zero(c))
+ type = EQTYPE_CONSTANT;
+- isl_constraint_get_coefficient(constraint, isl_dim_set, level - 1, &c);
+- if (!isl_int_is_one(c) && !isl_int_is_negone(c))
++ isl_val_free(c);
++ c = isl_constraint_get_coefficient_val(constraint, isl_dim_set, level - 1);
++ if (!isl_val_is_one(c) && !isl_val_is_negone(c))
+ type = EQTYPE_EXAFFINE;
++ isl_val_free(c);
+ for (i = 0; i < isl_constraint_dim(constraint, isl_dim_param); ++i) {
+- isl_constraint_get_coefficient(constraint, isl_dim_param, i, &c);
+- if (isl_int_is_zero(c))
++ c = isl_constraint_get_coefficient_val(constraint, isl_dim_param, i);
++ if (isl_val_is_zero(c)){
++ isl_val_free(c);
+ continue;
+- if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
++ }
++ if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) ||
+ type != EQTYPE_NONE) {
+ type = EQTYPE_EXAFFINE;
++ isl_val_free(c);
+ break;
+ }
+ type = EQTYPE_PUREITEM;
++ isl_val_free(c);
+ }
+ for (i = 0; i < isl_constraint_dim(constraint, isl_dim_set); ++i) {
+ if (i == level - 1)
+ continue;
+- isl_constraint_get_coefficient(constraint, isl_dim_set, i, &c);
+- if (isl_int_is_zero(c))
++ c = isl_constraint_get_coefficient_val(constraint, isl_dim_set, i);
++ if (isl_val_is_zero(c)){
++ isl_val_free(c);
+ continue;
+- if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
++ }
++ if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) ||
+ type != EQTYPE_NONE) {
+ type = EQTYPE_EXAFFINE;
++ isl_val_free(c);
+ break;
+ }
+ type = EQTYPE_PUREITEM;
++ isl_val_free(c);
+ }
+ for (i = 0; i < isl_constraint_dim(constraint, isl_dim_div); ++i) {
+- isl_constraint_get_coefficient(constraint, isl_dim_div, i, &c);
+- if (isl_int_is_zero(c))
++ c = isl_constraint_get_coefficient_val(constraint, isl_dim_div, i);
++ if (isl_val_is_zero(c)){
++ isl_val_free(c);
+ continue;
+- if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
++ }
++ if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) ||
+ type != EQTYPE_NONE) {
+ type = EQTYPE_EXAFFINE;
++ isl_val_free(c);
+ break;
+ }
+ type = EQTYPE_PUREITEM;
++ isl_val_free(c);
+ }
+- isl_int_clear(c);
+
+ if (type == EQTYPE_NONE)
+ type = EQTYPE_CONSTANT;
+@@ -447,27 +499,31 @@ static struct clast_expr *div_expr(CloogConstraint *constraint, int pos,
+ {
+ int i, nb_elts;
+ unsigned dim = cloog_constraint_total_dimension(constraint);
+- cloog_int_t c;
++ isl_val *c;
+ struct clast_reduction *r;
+ struct clast_expr *e = NULL;
+ isl_aff *div;
++ cloog_int_t cint;
+
++ cloog_int_init(cint);
+ div = isl_constraint_get_div(cloog_constraint_to_isl(constraint), pos);
+
+- cloog_int_init(c);
+ for (i = 0, nb_elts = 0; i < dim; ++i) {
+ struct cloog_isl_dim dim;
+
+ dim = constraint_cloog_dim_to_isl_dim(constraint, i);
+ if (dim.type == isl_dim_set)
+ dim.type = isl_dim_in;
+- isl_aff_get_coefficient(div, dim.type, dim.pos, &c);
+- if (!cloog_int_is_zero(c))
++ c = isl_aff_get_coefficient_val(div, dim.type, dim.pos);
++ if (!isl_val_is_zero(c))
+ ++nb_elts;
++
++ isl_val_free(c);
+ }
+- isl_aff_get_constant(div, &c);
+- if (!cloog_int_is_zero(c))
++ c = isl_aff_get_constant_val(div);
++ if (!isl_val_is_zero(c))
+ ++nb_elts;
++ isl_val_free(c);
+
+ r = new_clast_reduction(clast_red_sum, nb_elts);
+ for (i = 0, nb_elts = 0; i < dim; ++i) {
+@@ -477,22 +533,35 @@ static struct clast_expr *div_expr(CloogConstraint *constraint, int pos,
+ dim = constraint_cloog_dim_to_isl_dim(constraint, i);
+ if (dim.type == isl_dim_set)
+ dim.type = isl_dim_in;
+- isl_aff_get_coefficient(div, dim.type, dim.pos, &c);
+- if (cloog_int_is_zero(c))
++ c = isl_aff_get_coefficient_val(div, dim.type, dim.pos);
++ if (isl_val_is_zero(c)){
++ isl_val_free(c);
+ continue;
++ }
+
+ v = cloog_constraint_variable_expr(constraint, 1 + i, names);
+
+- r->elts[nb_elts++] = &new_clast_term(c, v)->expr;
++ /* We are interested only in the numerator */
++ cloog_int_set_si(cint, isl_val_get_num_si(c));
++ r->elts[nb_elts++] = &new_clast_term(cint, v)->expr;
++
++ isl_val_free(c);
++ }
++
++ c = isl_aff_get_constant_val(div);
++ if (!isl_val_is_zero(c)) {
++ /* We are interested only in the numerator */
++ cloog_int_set_si(cint, isl_val_get_num_si(c));
++ r->elts[nb_elts++] = &new_clast_term(cint, NULL)->expr;
+ }
+- isl_aff_get_constant(div, &c);
+- if (!cloog_int_is_zero(c))
+- r->elts[nb_elts++] = &new_clast_term(c, NULL)->expr;
++ isl_val_free(c);
+
+- isl_aff_get_denominator(div, &c);
+- e = &new_clast_binary(clast_bin_fdiv, &r->expr, c)->expr;
++ c = isl_aff_get_denominator_val(div);
++ isl_val_to_cloog_int(c, &cint);
++ isl_val_free(c);
++ e = &new_clast_binary(clast_bin_fdiv, &r->expr, cint)->expr;
+
+- cloog_int_clear(c);
++ cloog_int_clear(cint);
+
+ isl_aff_free(div);
+
+@@ -529,37 +598,34 @@ struct clast_expr *cloog_constraint_variable_expr(CloogConstraint *constraint,
+ */
+ int cloog_constraint_involves(CloogConstraint *constraint, int v)
+ {
+- isl_int c;
++ isl_val *c;
+ int res;
+
+- isl_int_init(c);
+- cloog_constraint_coefficient_get(constraint, v, &c);
+- res = !isl_int_is_zero(c);
+- isl_int_clear(c);
++ c = cloog_constraint_coefficient_get_val(constraint, v);
++ res = !isl_val_is_zero(c);
++ isl_val_free(c);
+ return res;
+ }
+
+ int cloog_constraint_is_lower_bound(CloogConstraint *constraint, int v)
+ {
+- isl_int c;
++ isl_val *c;
+ int res;
+
+- isl_int_init(c);
+- cloog_constraint_coefficient_get(constraint, v, &c);
+- res = isl_int_is_pos(c);
+- isl_int_clear(c);
++ c = cloog_constraint_coefficient_get_val(constraint, v);
++ res = isl_val_is_pos(c);
++ isl_val_free(c);
+ return res;
+ }
+
+ int cloog_constraint_is_upper_bound(CloogConstraint *constraint, int v)
+ {
+- isl_int c;
++ isl_val *c;
+ int res;
+
+- isl_int_init(c);
+- cloog_constraint_coefficient_get(constraint, v, &c);
+- res = isl_int_is_neg(c);
+- isl_int_clear(c);
++ c = cloog_constraint_coefficient_get_val(constraint, v);
++ res = isl_val_is_neg(c);
++ isl_val_free(c);
+ return res;
+ }
+
+@@ -585,15 +651,37 @@ void cloog_constraint_coefficient_get(CloogConstraint *constraint,
+ {
+ struct cloog_isl_dim dim;
+ isl_constraint *c;
++ isl_val *ival;
++
++ if (!constraint)
++ val = NULL;
++
++ dim = constraint_cloog_dim_to_isl_dim(constraint, var);
++ c = cloog_constraint_to_isl(constraint);
++ ival = isl_constraint_get_coefficient_val(c, dim.type, dim.pos);
++
++ isl_val_to_cloog_int(ival, val);
++ isl_val_free(ival);
++}
++
++isl_val *cloog_constraint_coefficient_get_val(CloogConstraint *constraint,
++ int var)
++{
++ struct cloog_isl_dim dim;
++ isl_constraint *c;
++ isl_val *val;
+
+ if (!constraint)
+- return;
++ return NULL;
+
+ dim = constraint_cloog_dim_to_isl_dim(constraint, var);
+ c = cloog_constraint_to_isl(constraint);
+- isl_constraint_get_coefficient(c, dim.type, dim.pos, val);
++ val = isl_constraint_get_coefficient_val(c, dim.type, dim.pos);
++ return val;
+ }
+
++
++
+ void cloog_constraint_coefficient_set(CloogConstraint *constraint,
+ int var, cloog_int_t val)
+ {
+@@ -604,14 +692,26 @@ void cloog_constraint_coefficient_set(CloogConstraint *constraint,
+
+ dim = constraint_cloog_dim_to_isl_dim(constraint, var);
+ c = cloog_constraint_to_isl(constraint);
+- isl_constraint_set_coefficient(c, dim.type, dim.pos, val);
++ isl_constraint_set_coefficient_val(c, dim.type, dim.pos,
++ cloog_int_to_isl_val(isl_constraint_get_ctx(c), val));
+ }
+
+ void cloog_constraint_constant_get(CloogConstraint *constraint, cloog_int_t *val)
+ {
+- isl_constraint_get_constant(cloog_constraint_to_isl(constraint), val);
++ isl_val *ival;
++ ival = isl_constraint_get_constant_val(cloog_constraint_to_isl(constraint));
++ isl_val_to_cloog_int(ival, val);
++ isl_val_free(ival);
+ }
+
++
++__isl_give isl_val *cloog_constraint_constant_get_val(CloogConstraint *constraint)
++{
++ return isl_constraint_get_constant_val(cloog_constraint_to_isl(constraint));
++}
++
++
++
+ /**
+ * Copy the coefficient of constraint c into dst in PolyLib order,
+ * i.e., first the coefficients of the variables, then the coefficients
+@@ -700,15 +800,11 @@ CloogConstraintSet *cloog_constraint_set_for_reduction(CloogConstraint *upper,
+
+ static int add_constant_term(CloogConstraint *c, void *user)
+ {
+- isl_int *bound = (isl_int *)user;
+- isl_int v;
+-
+- isl_int_init(v);
+-
+- cloog_constraint_constant_get(c, &v);
+- isl_int_add(*bound, *bound, v);
++ isl_val **bound = (isl_val **)user;
++ isl_val *v;
+
+- isl_int_clear(v);
++ v = cloog_constraint_constant_get_val(c);
++ *bound = isl_val_add(*bound, v);
+
+ return 0;
+ }
+@@ -822,11 +918,14 @@ CloogConstraintSet *cloog_constraint_set_reduce(CloogConstraintSet *constraints,
+ c = isl_constraint_set_coefficient_si(c, isl_dim_set, dim.pos, -1);
+ bset = isl_basic_set_add_constraint(bset, c);
+
+- isl_int_set_si(*bound, 0);
++ cloog_int_set_si(*bound, 0);
++ isl_val *v = cloog_int_to_isl_val(isl_basic_set_get_ctx(bset), *bound);
+ constraints = cloog_constraint_set_from_isl_basic_set(bset);
+ cloog_constraint_set_foreach_constraint(constraints,
+- add_constant_term, bound);
++ add_constant_term, &v);
++ isl_val_to_cloog_int(v, bound); //return the value to bound
+
++ isl_val_free(v);
+ isl_basic_set_free(orig);
+ return cloog_constraint_set_from_isl_basic_set(bset);
+ }
+@@ -896,31 +995,27 @@ static isl_aff *extract_stride_offset(__isl_keep isl_constraint *c,
+ isl_space *dim = isl_constraint_get_space(c);
+ isl_local_space *ls = isl_local_space_from_space(dim);
+ isl_aff *offset = isl_aff_zero_on_domain(ls);
+- isl_int u;
++ isl_val *u;
+ unsigned nparam, nvar;
+
+- isl_int_init(u);
+-
+ nparam = isl_constraint_dim(c, isl_dim_param);
+ nvar = isl_constraint_dim(c, isl_dim_set);
+
+ for (i = 0; i < nparam; ++i) {
+- isl_constraint_get_coefficient(c, isl_dim_param, i, &u);
+- isl_int_mul(u, u, stride->factor);
+- offset = isl_aff_set_coefficient(offset, isl_dim_param, i, u);
++ u = isl_constraint_get_coefficient_val(c, isl_dim_param, i);
++ u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor));
++ offset = isl_aff_set_coefficient_val(offset, isl_dim_param, i, u);
+ }
+ for (i = 0; i < nvar; ++i) {
+ if (i == level - 1)
+ continue;
+- isl_constraint_get_coefficient(c, isl_dim_set, i, &u);
+- isl_int_mul(u, u, stride->factor);
+- offset = isl_aff_set_coefficient(offset, isl_dim_in, i, u);
++ u = isl_constraint_get_coefficient_val(c, isl_dim_set, i);
++ u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor));
++ offset = isl_aff_set_coefficient_val(offset, isl_dim_in, i, u);
+ }
+- isl_constraint_get_constant(c, &u);
+- isl_int_mul(u, u, stride->factor);
+- offset = isl_aff_set_constant(offset, u);
+-
+- isl_int_clear(u);
++ u = isl_constraint_get_constant_val(c);
++ u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor));
++ offset = isl_aff_set_constant_val(offset, u);
+
+ return offset;
+ }
+@@ -953,9 +1048,9 @@ CloogConstraint *cloog_constraint_stride_lower_bound(CloogConstraint *c,
+ offset = extract_stride_offset(stride_c, level, stride);
+
+ lower = isl_aff_sub(lower, isl_aff_copy(offset));
+- lower = isl_aff_scale_down(lower, stride->stride);
++ lower = isl_aff_scale_down_val(lower, cloog_int_to_isl_val(isl_constraint_get_ctx(stride_c), stride->stride));
+ lower = isl_aff_ceil(lower);
+- lower = isl_aff_scale(lower, stride->stride);
++ lower = isl_aff_scale_val(lower, cloog_int_to_isl_val(isl_constraint_get_ctx(stride_c), stride->stride));
+ lower = isl_aff_add(lower, offset);
+ lower = isl_aff_neg(lower);
+ lower = isl_aff_add_coefficient_si(lower, isl_dim_in, level - 1, 1);
+diff --git a/source/isl/domain.c b/source/isl/domain.c
+index 620584d..dc81a96 100644
+--- a/source/isl/domain.c
++++ b/source/isl/domain.c
+@@ -7,7 +7,11 @@
+ #include <isl/list.h>
+ #include <isl/constraint.h>
+ #include <isl/ilp.h>
++#include <isl/lp.h>
+ #include <isl/aff.h>
++#include <isl/map.h>
++#include <isl/val.h>
++#include <isl/val_gmp.h>
+
+ #ifdef OSL_SUPPORT
+ #include <osl/macros.h>
+@@ -510,15 +514,18 @@ static struct isl_constraint *isl_constraint_read_from_matrix(
+ else
+ constraint = isl_inequality_alloc(ls);
+
+- for (j = 0; j < nvariables; ++j)
+- isl_constraint_set_coefficient(constraint, isl_dim_out, j,
+- row[1 + j]);
++ for (j = 0; j < nvariables; ++j) {
++ isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + j]);
++ isl_constraint_set_coefficient_val(constraint, isl_dim_out, j, val);
++ }
+
+- for (j = 0; j < nparam; ++j)
+- isl_constraint_set_coefficient(constraint, isl_dim_param, j,
+- row[1 + nvariables + j]);
++ for (j = 0; j < nparam; ++j) {
++ isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + nvariables + j]);
++ isl_constraint_set_coefficient_val(constraint, isl_dim_param, j, val);
++ }
+
+- isl_constraint_set_constant(constraint, row[1 + nvariables + nparam]);
++ isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + nvariables + nparam]);
++ isl_constraint_set_constant_val(constraint, val);
+
+ return constraint;
+ }
+@@ -631,7 +638,6 @@ CloogDomain *cloog_domain_from_osl_relation(CloogState *state,
+ return domain;
+ }
+
+-
+ /**
+ * Converts an openscop scattering relation to a CLooG scattering.
+ * \param[in,out] state CLooG state.
+@@ -779,10 +785,22 @@ int cloog_domain_is_otl(CloogDomain *domain, int level)
+ void cloog_domain_stride(CloogDomain *domain, int strided_level,
+ cloog_int_t *stride, cloog_int_t *offset)
+ {
++ int ret = -1;
+ isl_set *set = isl_set_from_cloog_domain(domain);
+- isl_set_dim_residue_class(set, strided_level - 1, stride, offset);
+- if (!isl_int_is_zero(*offset))
+- isl_int_sub(*offset, *stride, *offset);
++ isl_val *stride_val = NULL;
++ isl_val *offset_val = NULL;
++ ret = isl_set_dim_residue_class_val(set, strided_level - 1, &stride_val, &offset_val);
++ if (ret != 0)
++ cloog_die("failure to compute stride.\n");
++ isl_val_to_cloog_int(stride_val, stride);
++ isl_val_to_cloog_int(offset_val, offset);
++
++ if (!cloog_int_is_zero(*offset))
++ cloog_int_sub(*offset, *stride, *offset);
++
++ isl_val_free(stride_val);
++ isl_val_free(offset_val);
++
+ return;
+ }
+
+@@ -796,7 +814,7 @@ static int constraint_can_stride(__isl_take isl_constraint *c, void *user)
+ {
+ struct cloog_can_stride *ccs = (struct cloog_can_stride *)user;
+ int i;
+- isl_int v;
++ isl_val *v;
+ unsigned n_div;
+
+ if (isl_constraint_is_equality(c)) {
+@@ -804,21 +822,22 @@ static int constraint_can_stride(__isl_take isl_constraint *c, void *user)
+ return 0;
+ }
+
+- isl_int_init(v);
+- isl_constraint_get_coefficient(c, isl_dim_set, ccs->level - 1, &v);
+- if (isl_int_is_pos(v)) {
++ v = isl_constraint_get_coefficient_val(c, isl_dim_set, ccs->level - 1);
++ if (isl_val_is_pos(v)) {
+ n_div = isl_constraint_dim(c, isl_dim_div);
++
+ for (i = 0; i < n_div; ++i) {
+- isl_constraint_get_coefficient(c, isl_dim_div, i, &v);
+- if (!isl_int_is_zero(v))
++ isl_val_free(v);
++ v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);
++ if (!isl_val_is_zero(v))
+ break;
+ }
+ if (i < n_div)
+ ccs->can_stride = 0;
+ }
+- isl_int_clear(v);
+- isl_constraint_free(c);
++ isl_val_free(v);
+
++ isl_constraint_free(c);
+ return 0;
+ }
+
+@@ -903,7 +922,7 @@ struct cloog_stride_lower {
+ static int constraint_stride_lower(__isl_take isl_constraint *c, void *user)
+ {
+ struct cloog_stride_lower *csl = (struct cloog_stride_lower *)user;
+- isl_int v;
++ isl_val *v;
+ isl_constraint *bound;
+ isl_aff *b;
+
+@@ -912,31 +931,31 @@ static int constraint_stride_lower(__isl_take isl_constraint *c, void *user)
+ return 0;
+ }
+
+- isl_int_init(v);
+- isl_constraint_get_coefficient(c, isl_dim_set, csl->level - 1, &v);
+- if (!isl_int_is_pos(v)) {
+- isl_int_clear(v);
++ v = isl_constraint_get_coefficient_val(c, isl_dim_set, csl->level - 1);
++ if (!isl_val_is_pos(v)) {
++ isl_val_free(v);
+ isl_constraint_free(c);
+
+ return 0;
+ }
++ isl_val_free(v);
+
+ b = isl_constraint_get_bound(c, isl_dim_set, csl->level - 1);
+
+ b = isl_aff_neg(b);
+- b = isl_aff_add_constant(b, csl->stride->offset);
+- b = isl_aff_scale_down(b, csl->stride->stride);
++ b = isl_aff_add_constant_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->offset));
++ b = isl_aff_scale_down_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->stride));
+ b = isl_aff_floor(b);
+- b = isl_aff_scale(b, csl->stride->stride);
+- isl_int_neg(v, csl->stride->offset);
+- b = isl_aff_add_constant(b, v);
++ b = isl_aff_scale_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->stride));
++ v = cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->offset);
++ v = isl_val_neg(v);
++ b = isl_aff_add_constant_val(b, v);
+ b = isl_aff_add_coefficient_si(b, isl_dim_in, csl->level - 1, 1);
+
+ bound = isl_inequality_from_aff(b);
+
+ csl->bounds = isl_basic_set_add_constraint(csl->bounds, bound);
+
+- isl_int_clear(v);
+ isl_constraint_free(c);
+
+ return 0;
+@@ -960,7 +979,7 @@ static int constraint_stride_lower(__isl_take isl_constraint *c, void *user)
+ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user)
+ {
+ struct cloog_stride_lower *csl = (struct cloog_stride_lower *)user;
+- isl_int v;
++ isl_val *v;
+ isl_constraint *bound;
+ isl_constraint *csl_c;
+ isl_aff *d, *b;
+@@ -970,10 +989,9 @@ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user)
+ return 0;
+ }
+
+- isl_int_init(v);
+- isl_constraint_get_coefficient(c, isl_dim_set, csl->level - 1, &v);
+- if (!isl_int_is_pos(v)) {
+- isl_int_clear(v);
++ v = isl_constraint_get_coefficient_val(c, isl_dim_set, csl->level - 1);
++ if (!isl_val_is_pos(v)) {
++ isl_val_free(v);
+ isl_constraint_free(c);
+
+ return 0;
+@@ -984,15 +1002,15 @@ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user)
+ d = isl_constraint_get_aff(csl_c);
+ d = isl_aff_drop_dims(d, isl_dim_div, 0, isl_aff_dim(d, isl_dim_div));
+ d = isl_aff_set_coefficient_si(d, isl_dim_in, csl->level - 1, 0);
+- d = isl_aff_scale(d, csl->stride->factor);
++ d = isl_aff_scale_val(d, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->factor));
+
+ b = isl_constraint_get_bound(c, isl_dim_set, csl->level - 1);
+
+ b = isl_aff_neg(b);
+ b = isl_aff_add(b, isl_aff_copy(d));
+- b = isl_aff_scale_down(b, csl->stride->stride);
++ b = isl_aff_scale_down_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->stride));
+ b = isl_aff_floor(b);
+- b = isl_aff_scale(b, csl->stride->stride);
++ b = isl_aff_scale_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->stride));
+ b = isl_aff_sub(b, d);
+ b = isl_aff_add_coefficient_si(b, isl_dim_in, csl->level - 1, 1);
+
+@@ -1000,7 +1018,7 @@ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user)
+
+ csl->bounds = isl_basic_set_add_constraint(csl->bounds, bound);
+
+- isl_int_clear(v);
++ isl_val_free(v);
+ isl_constraint_free(c);
+
+ return 0;
+@@ -1090,28 +1108,30 @@ struct cloog_bound_split {
+ static int constraint_bound_split(__isl_take isl_constraint *c, void *user)
+ {
+ struct cloog_bound_split *cbs = (struct cloog_bound_split *)user;
+- isl_int v;
++ isl_val *v;
+ int i;
+ int handle = 0;
+
+- isl_int_init(v);
+- isl_constraint_get_coefficient(c, isl_dim_set, cbs->level - 1, &v);
+- if (!cbs->lower && isl_int_is_pos(v))
++ v = isl_constraint_get_coefficient_val(c, isl_dim_set, cbs->level - 1);
++ if (!cbs->lower && isl_val_is_pos(v))
+ cbs->lower = handle = 1;
+- else if (!cbs->upper && isl_int_is_neg(v))
++ else if (!cbs->upper && isl_val_is_neg(v))
+ cbs->upper = handle = 1;
++
+ if (handle) {
+ for (i = 0; i < isl_set_dim(cbs->set, isl_dim_param); ++i) {
+- isl_constraint_get_coefficient(c, isl_dim_param, i, &v);
+- if (isl_int_is_zero(v))
++ isl_val_free(v);
++ v = isl_constraint_get_coefficient_val(c, isl_dim_param, i);
++ if (isl_val_is_zero(v))
+ continue;
++
+ cbs->set = isl_set_split_dims(cbs->set,
+ isl_dim_param, i, 1);
+ }
+ }
+- isl_int_clear(v);
+- isl_constraint_free(c);
++ isl_val_free(v);
+
++ isl_constraint_free(c);
+ return (cbs->lower && cbs->upper) ? -1 : 0;
+ }
+
+@@ -1203,7 +1223,7 @@ static int injective_scattering(CloogScatteringList *list)
+ * - scattdims is the total number of scattering dimentions.
+ */
+ int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2,
+- CloogScatteringList *scattering, int scattdims)
++ CloogScatteringList *scattering, int scattdims)
+ {
+ int i;
+ struct isl_space *dim;
+@@ -1211,8 +1231,8 @@ int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2,
+ struct isl_set *delta;
+ isl_map *map1 = isl_map_from_cloog_scattering(s1);
+ isl_map *map2 = isl_map_from_cloog_scattering(s2);
+- int fixed, block;
+- isl_int cst;
++ int block;
++ isl_val *cst;
+ unsigned n_scat;
+
+ n_scat = isl_map_dim(map1, isl_dim_out);
+@@ -1225,22 +1245,33 @@ int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2,
+ rel = isl_map_apply_domain(rel, isl_map_copy(map1));
+ rel = isl_map_apply_range(rel, isl_map_copy(map2));
+ delta = isl_map_deltas(rel);
+- isl_int_init(cst);
++ cst = NULL;
+ for (i = 0; i < n_scat; ++i) {
+- fixed = isl_set_fast_dim_is_fixed(delta, i, &cst);
+- if (fixed != 1)
++ cst = isl_set_plain_get_val_if_fixed(delta, isl_dim_set, i);
++ if (!cst){
++ isl_val_free(cst);
+ break;
+- if (isl_int_is_zero(cst))
++ }
++ if (isl_val_is_zero(cst)){
++ isl_val_free(cst);
+ continue;
+- if (i + 1 < n_scat)
++ }
++ if (i + 1 < n_scat){
++ isl_val_free(cst);
+ break;
+- if (!isl_int_is_one(cst))
++ }
++ if (!isl_val_is_one(cst)){
++ isl_val_free(cst);
+ break;
+- if (!injective_scattering(scattering))
++ }
++ if (!injective_scattering(scattering)){
++ isl_val_free(cst);
+ break;
++ }
++
++ isl_val_free(cst);
+ }
+ block = i >= n_scat;
+- isl_int_clear(cst);
+ isl_set_free(delta);
+ return block;
+ }
+@@ -1345,10 +1376,25 @@ CloogDomain *cloog_domain_simplify_union(CloogDomain *domain)
+ * If value is not NULL, then it is set to the constant value of dimension.
+ */
+ int cloog_scattering_lazy_isscalar(CloogScattering *scatt, int dimension,
+- cloog_int_t *value)
++ cloog_int_t *value)
+ {
+ isl_map *map = isl_map_from_cloog_scattering(scatt);
+- return isl_map_fast_is_fixed(map, isl_dim_out, dimension, value);
++ isl_val *v = isl_map_plain_get_val_if_fixed(map, isl_dim_out, dimension);
++ if (v != NULL) {
++ if (!isl_val_is_nan(v)){
++ if (value != NULL)
++ isl_val_to_cloog_int(v, value);
++
++ isl_val_free(v);
++ return 1;
++ }
++ else {
++ isl_val_free(v);
++ return 0;
++ }
++ }
++
++ return 0;
+ }
+
+
+@@ -1362,7 +1408,22 @@ int cloog_domain_lazy_isconstant(CloogDomain *domain, int dimension,
+ cloog_int_t *value)
+ {
+ isl_set *set = isl_set_from_cloog_domain(domain);
+- return isl_set_fast_dim_is_fixed(set, dimension, value);
++ isl_val *cst = isl_set_plain_get_val_if_fixed(set, isl_dim_set, dimension);
++ if (cst != NULL) {
++ if (!isl_val_is_nan(cst)){
++ if (value != NULL)
++ isl_val_to_cloog_int(cst, value);
++
++ isl_val_free(cst);
++ return 1;
++ }
++ else {
++ isl_val_free(cst);
++ return 0;
++ }
++ }
++
++ return 0;
+ }
+
+
+@@ -1391,6 +1452,8 @@ CloogDomain *cloog_domain_cube(CloogState *state,
+ int i;
+ isl_space *space;
+ isl_set *cube;
++ isl_val *min_v;
++ isl_val *max_v;
+
+ if (dim == 0)
+ return cloog_domain_universe(state, dim);
+@@ -1398,8 +1461,10 @@ CloogDomain *cloog_domain_cube(CloogState *state,
+ space = isl_space_set_alloc(state->backend->ctx, 0, dim);
+ cube = isl_set_universe(space);
+ for (i = 0; i < dim; ++i) {
+- cube = isl_set_lower_bound(cube, isl_dim_set, i, min);
+- cube = isl_set_upper_bound(cube, isl_dim_set, i, max);
++ min_v = cloog_int_to_isl_val(isl_set_get_ctx(cube), min);
++ max_v = cloog_int_to_isl_val(isl_set_get_ctx(cube), max);
++ cube = isl_set_lower_bound_val(cube, isl_dim_set, i, min_v);
++ cube = isl_set_upper_bound_val(cube, isl_dim_set, i, max_v);
+ }
+
+ return cloog_domain_from_isl_set(cube);
+@@ -1595,7 +1660,7 @@ static void Euclid(cloog_int_t a, cloog_int_t b,
+ cloog_int_mul(tmp, tmp, d);
+ cloog_int_sub(c, c, tmp);
+ cloog_int_swap(c, d);
+- cloog_int_swap(e, f);
++ cloog_int_swap(e, f);
+ }
+ cloog_int_set(*g, c);
+ if (cloog_int_is_zero(a))
+@@ -1631,49 +1696,70 @@ static void Euclid(cloog_int_t a, cloog_int_t b,
+ static CloogStride *construct_stride(isl_constraint *c, int level)
+ {
+ int i, n, sign;
+- isl_int v, m, gcd, stride, factor;
++ isl_val *v, *m, *gcd, *stride;
++ isl_val *v_copy, *m_copy, *gcd_copy;
++ cloog_int_t c_v, c_m, c_gcd, c_stride, c_factor;
+ CloogStride *s;
++ isl_ctx *ctx = isl_constraint_get_ctx(c);;
+
+ if (!c)
+ return NULL;
+
+- isl_int_init(v);
+- isl_int_init(m);
+- isl_int_init(gcd);
+- isl_int_init(factor);
+- isl_int_init(stride);
++ v = isl_constraint_get_coefficient_val(c, isl_dim_set, level - 1);
+
+- isl_constraint_get_coefficient(c, isl_dim_set, level - 1, &v);
+- sign = isl_int_sgn(v);
+- isl_int_abs(m, v);
++ sign = isl_val_sgn(v);
++ m = isl_val_abs(v); /* *takes* v. */
+
+- isl_int_set_si(gcd, 0);
++ gcd = isl_val_int_from_si(ctx, 0);
+ n = isl_constraint_dim(c, isl_dim_div);
+ for (i = 0; i < n; ++i) {
+- isl_constraint_get_coefficient(c, isl_dim_div, i, &v);
+- isl_int_gcd(gcd, gcd, v);
++ v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);
++ gcd = isl_val_gcd(gcd, v);
+ }
+
+- isl_int_gcd(v, m, gcd);
+- isl_int_divexact(stride, gcd, v);
++ m_copy = isl_val_copy(m);
++ gcd_copy = isl_val_copy(gcd);
+
+- if (isl_int_is_zero(stride) || isl_int_is_one(stride))
++ v = isl_val_gcd(m, gcd);
++
++ v_copy = isl_val_copy(v);
++ gcd = isl_val_copy(gcd_copy);
++ stride = isl_val_div(gcd, v);
++
++ if (isl_val_is_zero(stride) || isl_val_is_one(stride))
+ s = NULL;
+ else {
+- Euclid(m, stride, &factor, &v, &gcd);
++ cloog_int_init(c_m);
++ cloog_int_init(c_stride);
++ cloog_int_init(c_v);
++ cloog_int_init(c_gcd);
++ cloog_int_init(c_factor);
++
++ isl_val_to_cloog_int(m_copy, &c_m);
++ isl_val_to_cloog_int(stride, &c_stride);
++ isl_val_to_cloog_int(v_copy, &c_v);
++ isl_val_to_cloog_int(gcd_copy, &c_gcd);
++
++ Euclid(c_m, c_stride, &c_factor, &c_v, &c_gcd);
+ if (sign > 0)
+- isl_int_neg(factor, factor);
++ cloog_int_neg(c_factor, c_factor);
+
+ c = isl_constraint_copy(c);
+- s = cloog_stride_alloc_from_constraint(stride,
+- cloog_constraint_from_isl_constraint(c), factor);
++ s = cloog_stride_alloc_from_constraint(c_stride,
++ cloog_constraint_from_isl_constraint(c), c_factor);
++
++
++ cloog_int_clear(c_m);
++ cloog_int_clear(c_stride);
++ cloog_int_clear(c_v);
++ cloog_int_clear(c_gcd);
++ cloog_int_clear(c_factor);
+ }
+
+- isl_int_clear(stride);
+- isl_int_clear(factor);
+- isl_int_clear(gcd);
+- isl_int_clear(m);
+- isl_int_clear(v);
++ isl_val_free(stride);
++ isl_val_free(gcd_copy);
++ isl_val_free(m_copy);
++ isl_val_free(v_copy);
+
+ return s;
+ }
+@@ -1694,7 +1780,7 @@ static int find_stride(__isl_take isl_constraint *c, void *user)
+ {
+ struct cloog_isl_find_stride_data *data;
+ int n;
+- isl_int v;
++ isl_val *v;
+
+ if (!isl_constraint_is_equality(c)) {
+ isl_constraint_free(c);
+@@ -1714,13 +1800,11 @@ static int find_stride(__isl_take isl_constraint *c, void *user)
+ return 0;
+ }
+
+- isl_int_init(v);
+-
+- isl_constraint_get_coefficient(c, isl_dim_set, data->level - 1, &v);
+- if (!isl_int_is_zero(v))
++ v = isl_constraint_get_coefficient_val(c, isl_dim_set, data->level - 1);
++ if (!isl_val_is_zero(v))
+ data->stride = construct_stride(c, data->level);
+
+- isl_int_clear(v);
++ isl_val_free(v);
+
+ isl_constraint_free(c);
+
+@@ -1769,7 +1853,7 @@ struct cloog_can_unroll {
+ int level;
+ isl_constraint *c;
+ isl_set *set;
+- isl_int *n;
++ isl_val *n;
+ };
+
+
+@@ -1782,11 +1866,11 @@ struct cloog_can_unroll {
+ * with l the given lower bound and i the iterator identified by level.
+ */
+ static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu,
+- __isl_keep isl_constraint *c, isl_int *v)
++ __isl_keep isl_constraint *c, isl_val **v)
+ {
+ unsigned n_div;
+ isl_aff *aff;
+- enum isl_lp_result res;
++ enum isl_lp_result;
+
+ n_div = isl_constraint_dim(c, isl_dim_div);
+ if (isl_constraint_involves_dims(c, isl_dim_div, 0, n_div))
+@@ -1796,15 +1880,19 @@ static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu,
+ aff = isl_aff_ceil(aff);
+ aff = isl_aff_neg(aff);
+ aff = isl_aff_add_coefficient_si(aff, isl_dim_in, ccu->level - 1, 1);
+- res = isl_set_max(ccu->set, aff, v);
++ *v = isl_set_max_val(ccu->set, aff);
+ isl_aff_free(aff);
+
+- if (res == isl_lp_unbounded)
+- return 0;
++ if (!*v || isl_val_is_nan(*v))
++ cloog_die("Fail to decide about unrolling (cannot find max)");
+
+- assert(res == isl_lp_ok);
++ if (isl_val_is_infty(*v) || isl_val_is_neginfty(*v)){
++ isl_val_free(*v);
++ *v = NULL;
++ return 0;
++ }
+
+- cloog_int_add_ui(*v, *v, 1);
++ *v = isl_val_add_ui(*v, 1);
+
+ return 1;
+ }
+@@ -1818,21 +1906,21 @@ static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu,
+ static int constraint_can_unroll(__isl_take isl_constraint *c, void *user)
+ {
+ struct cloog_can_unroll *ccu = (struct cloog_can_unroll *)user;
+- isl_int v;
+- isl_int count;
+-
+- isl_int_init(v);
+- isl_int_init(count);
+- isl_constraint_get_coefficient(c, isl_dim_set, ccu->level - 1, &v);
+- if (isl_int_is_pos(v) &&
+- is_valid_unrolling_lower_bound(ccu, c, &count) &&
+- (!ccu->c || isl_int_lt(count, *ccu->n))) {
++ isl_val *v;
++ isl_val *count = NULL;
++
++ v = isl_constraint_get_coefficient_val(c, isl_dim_set, ccu->level - 1);
++ if (isl_val_is_pos(v) &&
++ is_valid_unrolling_lower_bound(ccu, c, &count) &&
++ (!ccu->c || (isl_val_lt(count, ccu->n))) ) {
+ isl_constraint_free(ccu->c);
+ ccu->c = isl_constraint_copy(c);
+- isl_int_set(*ccu->n, count);
++ if (ccu->n)
++ isl_val_free(ccu->n);
++ ccu->n = isl_val_copy(count);
+ }
+- isl_int_clear(count);
+- isl_int_clear(v);
++ isl_val_free(count);
++ isl_val_free(v);
+ isl_constraint_free(c);
+
+ return 0;
+@@ -1872,7 +1960,8 @@ int cloog_domain_can_unroll(CloogDomain *domain, int level, cloog_int_t *n,
+ CloogConstraint **lb)
+ {
+ isl_set *set = isl_set_from_cloog_domain(domain);
+- struct cloog_can_unroll ccu = { 1, level, NULL, set, n };
++ isl_val *v = cloog_int_to_isl_val(isl_set_get_ctx(set), *n);
++ struct cloog_can_unroll ccu = { 1, level, NULL, set, v };
+ int r;
+
+ *lb = NULL;
+@@ -1887,6 +1976,11 @@ int cloog_domain_can_unroll(CloogDomain *domain, int level, cloog_int_t *n,
+
+ *lb = cloog_constraint_from_isl_constraint(ccu.c);
+
++ isl_val_to_cloog_int(ccu.n, n);
++ /* Note: we have to free ccu.n and not v because v has been
++ * freed and replaced in ccu during isl_set_foreach_basic_set
++ */
++ isl_val_free(ccu.n);
+ return ccu.can_unroll;
+ }
+
+@@ -1904,6 +1998,7 @@ CloogDomain *cloog_domain_fixed_offset(CloogDomain *domain,
+ {
+ isl_aff *aff;
+ isl_set *set = isl_set_from_cloog_domain(domain);
++ isl_ctx *ctx = isl_set_get_ctx(set);
+ isl_constraint *c;
+ isl_constraint *eq;
+
+@@ -1911,7 +2006,7 @@ CloogDomain *cloog_domain_fixed_offset(CloogDomain *domain,
+ aff = isl_constraint_get_bound(c, isl_dim_set, level - 1);
+ aff = isl_aff_ceil(aff);
+ aff = isl_aff_add_coefficient_si(aff, isl_dim_in, level - 1, -1);
+- aff = isl_aff_add_constant(aff, offset);
++ aff = isl_aff_add_constant_val(aff, cloog_int_to_isl_val(ctx, offset));
+ eq = isl_equality_from_aff(aff);
+ set = isl_set_add_constraint(set, eq);
+
+--
+1.7.6.6.GIT
+
projects / packages / cloog-isl.git / commitdiff