Date: Tue, 8 Jul 2014 01:21:18 +0000 (UTC) From: Danilo Egea Gondolfo <danilo@FreeBSD.org> To: ports-committers@freebsd.org, svn-ports-all@freebsd.org, svn-ports-head@freebsd.org Subject: svn commit: r361151 - in head/math/cloog: . files Message-ID: <201407080121.s681LITA024468@svn.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: danilo Date: Tue Jul 8 01:21:17 2014 New Revision: 361151 URL: http://svnweb.freebsd.org/changeset/ports/361151 QAT: https://qat.redports.org/buildarchive/r361151/ Log: - Add some patches from PkgSrc to enable cloog to builds with devel/isl - Fix a installation conflict between devel/isl and math/cloog - Notice that this commit breaks devel/gcc-arm-embedded, lev@ will take a look after (ports/191596) PR: ports/191598 Submitted by: Jan Beich <jbeich@vfemail.net> Added: head/math/cloog/files/ head/math/cloog/files/patch-include__cloog__isl__constraintset.h (contents, props changed) head/math/cloog/files/patch-source__isl__constraints.c (contents, props changed) head/math/cloog/files/patch-source__isl__domain.c (contents, props changed) Modified: head/math/cloog/Makefile head/math/cloog/pkg-plist Modified: head/math/cloog/Makefile ============================================================================== --- head/math/cloog/Makefile Tue Jul 8 00:58:59 2014 (r361150) +++ head/math/cloog/Makefile Tue Jul 8 01:21:17 2014 (r361151) @@ -3,7 +3,7 @@ PORTNAME= cloog PORTVERSION= 0.18.1 -PORTREVISION= 2 +PORTREVISION= 3 CATEGORIES= math MASTER_SITES= http://www.bastoul.net/cloog/pages/download/ @@ -12,14 +12,15 @@ COMMENT= Code generator in the polyhedra LICENSE= LGPL21 -LIB_DEPENDS= libgmp.so:${PORTSDIR}/math/gmp +LIB_DEPENDS= libgmp.so:${PORTSDIR}/math/gmp \ + libisl.so:${PORTSDIR}/devel/isl PORTSCOUT= ignore:0.18.2 USE_LDCONFIG= yes USES= libtool GNU_CONFIGURE= yes -CONFIGURE_ARGS+= --with-gmp-prefix=${LOCALBASE} +CONFIGURE_ARGS+= --with-gmp-prefix=${LOCALBASE} --with-isl-prefix=${LOCALBASE} CONFIGURE_ENV= pkgconfig_libdir=${PREFIX}/libdata/pkgconfig/ .include <bsd.port.mk> Added: head/math/cloog/files/patch-include__cloog__isl__constraintset.h ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/math/cloog/files/patch-include__cloog__isl__constraintset.h Tue Jul 8 01:21:17 2014 (r361151) @@ -0,0 +1,15 @@ +--- ./include/cloog/isl/constraintset.h.orig 2013-10-11 04:27:03.000000000 -0300 ++++ ./include/cloog/isl/constraintset.h 2014-07-07 20:50:52.000000000 -0300 +@@ -27,6 +27,12 @@ + 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 Added: head/math/cloog/files/patch-source__isl__constraints.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/math/cloog/files/patch-source__isl__constraints.c Tue Jul 8 01:21:17 2014 (r361151) @@ -0,0 +1,429 @@ +--- ./source/isl/constraints.c.orig 2013-10-11 04:27:03.000000000 -0300 ++++ ./source/isl/constraints.c 2014-07-07 20:50:52.000000000 -0300 +@@ -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 @@ + 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 @@ + { + 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 @@ + 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 @@ + */ + 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 @@ + { + 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 @@ + + 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 @@ + + 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 @@ + 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 @@ + 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 @@ + 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); Added: head/math/cloog/files/patch-source__isl__domain.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/math/cloog/files/patch-source__isl__domain.c Tue Jul 8 01:21:17 2014 (r361151) @@ -0,0 +1,619 @@ +--- ./source/isl/domain.c.orig 2013-10-11 04:27:03.000000000 -0300 ++++ ./source/isl/domain.c 2014-07-07 20:50:52.000000000 -0300 +@@ -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 @@ + 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 @@ + return domain; + } + +- + /** + * Converts an openscop scattering relation to a CLooG scattering. + * \param[in,out] state CLooG state. +@@ -779,10 +785,22 @@ + 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 @@ + { + 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 @@ + 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 @@ + 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 @@ + 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_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 @@ + 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 @@ + 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 @@ + + 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 @@ + 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 @@ + * - 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 @@ + 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 @@ + 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 @@ + * 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 @@ + 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 @@ + 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 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 +1776,7 @@ + { + 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 @@ + 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 @@ + int level; + isl_constraint *c; + isl_set *set; +- isl_int *n; ++ isl_val *n; + }; + + +@@ -1782,11 +1862,11 @@ + * 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; *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201407080121.s681LITA024468>