$NetBSD: patch-include_cloog_isl_constraintset.h,v 1.1 2014/04/25 21:01:27 wiz Exp $

$NetBSD: patch-source_isl_constraints.c,v 1.1 2014/04/25 21:01:27 wiz Exp $

$NetBSD: patch-source_isl_domain.c,v 1.1 2014/04/25 21:01:27 wiz Exp $

From: Taj Muhammad Khan <taj.khan@lri.fr>

Date: Thu, 5 Dec 2013 02:25:16 +0000 (+0530)

Subject: Use isl_val instead of isl_int

X-Git-Url: http://repo.or.cz/w/cloog.git/commitdiff_plain/2d8b7c6

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.orig	2013-10-11 07:27:03.000000000 +0000

+++ include/cloog/isl/constraintset.h

@@ -27,6 +27,12 @@ CloogConstraintSet *cloog_constraint_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 

--- source/isl/constraints.c.orig	2013-10-11 07:27:03.000000000 +0000

+++ 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 *e

 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(Cloog

 {

 	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(Cloog

 		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);

 	}

-	isl_aff_get_constant(div, &c);

-	if (!cloog_int_is_zero(c))

-		r->elts[nb_elts++] = &new_clast_term(c, NULL)->expr;

-	isl_aff_get_denominator(div, &c);

-	e = &new_clast_binary(clast_bin_fdiv, &r->expr, c)->expr;

+	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_val_free(c);

-	cloog_int_clear(c);

+	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(cint);

 	isl_aff_free(div);

@@ -529,37 +598,34 @@ struct clast_expr *cloog_constraint_vari

  */

 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(Cl

 {

 	struct cloog_isl_dim dim;

 	isl_constraint *c;

+	isl_val *ival;

 	if (!constraint)

-		return;

+		val = 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);

+	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 NULL;

+

+	dim = constraint_cloog_dim_to_isl_dim(constraint, var);

+	c = cloog_constraint_to_isl(constraint);

+	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(Cl

 	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

 static int add_constant_term(CloogConstraint *c, void *user)

 {

-	isl_int *bound = (isl_int *)user;

-	isl_int v;

-

-	isl_int_init(v);

+	isl_val **bound = (isl_val **)user;

+	isl_val *v;

-	cloog_constraint_constant_get(c, &v);

-	isl_int_add(*bound, *bound, 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

 	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_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);

-	}

-	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_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);

+	}

+	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

 	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);

--- source/isl/domain.c.orig	2013-10-11 07:27:03.000000000 +0000

+++ 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_constr

 	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 < nparam; ++j)

-		isl_constraint_set_coefficient(constraint, isl_dim_param, j,

-					       row[1 + nvariables + 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_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_relat

   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 *dom

 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_t

 {

 	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_t

 		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

 		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

 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(__i

 		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(__i

 	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(__i

 	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(CloogSca

  * - 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(CloogSca

 	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(CloogSca

 	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

  * 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(CloogDo

 	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;

 }

@@ -1595,7 +1656,7 @@ static void Euclid(cloog_int_t a, cloog_

 		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 +1692,70 @@ static void Euclid(cloog_int_t a, cloog_

 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);

-

-	isl_constraint_get_coefficient(c, isl_dim_set, level - 1, &v);

-	sign = isl_int_sgn(v);

-	isl_int_abs(m, v);

+	v = isl_constraint_get_coefficient_val(c, isl_dim_set, level - 1);

-	isl_int_set_si(gcd, 0);

+	sign = isl_val_sgn(v);

+	m = isl_val_abs(v); /* *takes* v. */

+

+	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);

+

+	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_int_is_zero(stride) || isl_int_is_one(stride))

+	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 +1776,7 @@ static int find_stride(__isl_take isl_co

 {

 	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 +1796,11 @@ static int find_stride(__isl_take isl_co

 		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 +1849,7 @@ struct cloog_can_unroll {

 	int level;

 	isl_constraint *c;

 	isl_set *set;

-	isl_int *n;

+	isl_val *n;

 };

@@ -1782,11 +1862,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 +1876,19 @@ static int is_valid_unrolling_lower_boun

 	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 +1902,21 @@ static int is_valid_unrolling_lower_boun

 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_val *v;

+	isl_val *count = NULL;

-	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))) {

+	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 +1956,8 @@ int cloog_domain_can_unroll(CloogDomain 

 	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 +1972,11 @@ int cloog_domain_can_unroll(CloogDomain 

 	*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 +1994,7 @@ CloogDomain *cloog_domain_fixed_offset(C

 {

 	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 +2002,7 @@ CloogDomain *cloog_domain_fixed_offset(C

 	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);