Thu Jun 12 03:35:06 UTC 2014

10 files changed, 1326 insertions, 27 deletions

diff --git a/core/binutils/PKGBUILD b/core/binutils/PKGBUILD
index 6ad6fe5e3..ba9f6327f 100644
--- a/core/binutils/PKGBUILD
+++ b/core/binutils/PKGBUILD
@@ -1,11 +1,11 @@
-# $Id: PKGBUILD 213325 2014-05-20 08:17:35Z allan $
+# $Id: PKGBUILD 214772 2014-06-10 10:35:54Z allan $
 # Maintainer: Allan McRae <allan@archlinux.org>
 
 # toolchain build order: linux-api-headers->glibc->binutils->gcc->binutils->glibc
 
 pkgname=binutils
 pkgver=2.24
-pkgrel=4
+pkgrel=5
 pkgdesc="A set of programs to assemble and manipulate binary and object files"
 arch=('i686' 'x86_64')
 url="http://www.gnu.org/software/binutils/"
@@ -24,6 +24,7 @@ md5sums=('e0f71a7b2ddab0f8612336ac81d9636b'
          'SKIP'
          'b16e895c24ff80acd98a21021eccefad'
          '4d2cf591560c3d25265778146bbe1941')
+validpgpkeys=('EAF1C276A747E9ED86210CBAC3126D3B4AE55E93')
 
 prepare() {
   cd ${srcdir}/binutils-${pkgver}
@@ -46,7 +47,7 @@ build() {
   ${srcdir}/binutils-${pkgver}/configure --prefix=/usr \
     --with-lib-path=/usr/lib:/usr/local/lib \
     --with-bugurl=https://bugs.archlinux.org/ \
-    --enable-threads --enable-shared \
+    --enable-threads --enable-shared --with-pic \
     --enable-ld=default --enable-gold --enable-plugins \
     --disable-werror
 
diff --git a/core/cloog/PKGBUILD b/core/cloog/PKGBUILD
index 4b3b730a9..cffcf28e3 100644
--- a/core/cloog/PKGBUILD
+++ b/core/cloog/PKGBUILD
@@ -1,16 +1,25 @@
-# $Id: PKGBUILD 197161 2013-10-23 13:04:58Z allan $
+# $Id: PKGBUILD 214994 2014-06-11 11:40:26Z allan $
 # Maintainer: Allan McRae <allan@archlinux.org>
 
 pkgname=cloog
 pkgver=0.18.1
-pkgrel=2
+pkgrel=3
 pkgdesc="Library that generates loops for scanning polyhedra"
 arch=('i686' 'x86_64')
 url="http://www.bastoul.net/cloog/"
 license=('GPL')
 depends=('isl')
-source=(http://www.bastoul.net/cloog/pages/download/$pkgname-$pkgver.tar.gz)
-md5sums=('e34fca0540d840e5d0f6427e98c92252')
+source=(http://www.bastoul.net/cloog/pages/download/$pkgname-$pkgver.tar.gz
+        cloog-0.18.1-isl-compat.patch)
+md5sums=('e34fca0540d840e5d0f6427e98c92252'
+         '976c999b44c6e364455a670d12523242')
+
+prepare() {
+  cd $srcdir/$pkgname-$pkgver
+  
+  # combination of upstream commits b561f860, 2d8b7c6b and 22643c94
+  patch -p1 -i $srcdir/cloog-0.18.1-isl-compat.patch
+}
 
 build() {
   cd $srcdir/$pkgname-$pkgver
diff --git a/core/cloog/cloog-0.18.1-isl-compat.patch b/core/cloog/cloog-0.18.1-isl-compat.patch
new file mode 100644
index 000000000..82e6bb07e
--- /dev/null
+++ b/core/cloog/cloog-0.18.1-isl-compat.patch
@@ -0,0 +1,1159 @@
+
+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);
+ }
+ 
+ 
+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);
+ 
+diff --git a/test/reservoir/QR.c b/test/reservoir/QR.c
+index 8818d9f..1a47f0a 100644
+--- a/test/reservoir/QR.c
++++ b/test/reservoir/QR.c
+@@ -1,6 +1,12 @@
+ /* Generated from ./reservoir/QR.cloog by CLooG 0.18.1-2-g43fc508 gmp bits in 0.07s. */
+ if (N >= 1) {
+   S1(0) ;
++  if ((M <= 0) && (N >= 2)) {
++    S3(0);
++    S10(0);
++    S1(1);
++    S5(0);
++  }
+   if ((M >= 1) && (N == 1)) {
+     for (c4=0;c4<=M-1;c4++) {
+       S2(0,c4) ;
+@@ -29,12 +35,6 @@ if (N >= 1) {
+     S1(1) ;
+     S5(0) ;
+   }
+-  if ((M <= 0) && (N >= 2)) {
+-    S3(0) ;
+-    S10(0) ;
+-    S1(1) ;
+-    S5(0) ;
+-  }
+   for (c2=2;c2<=min(M,N-1);c2++) {
+     for (c4=c2-1;c4<=N-1;c4++) {
+       S6((c2-2),c4);
+
diff --git a/core/gcc/PKGBUILD b/core/gcc/PKGBUILD
index 0870d296d..f67645362 100644
--- a/core/gcc/PKGBUILD
+++ b/core/gcc/PKGBUILD
@@ -1,4 +1,4 @@
-# $Id: PKGBUILD 213674 2014-05-28 05:17:31Z allan $
+# $Id: PKGBUILD 214996 2014-06-11 11:40:28Z allan $
 # Maintainer: Allan McRae <allan@archlinux.org>
 
 # toolchain build order: linux-api-headers->glibc->binutils->gcc->binutils->glibc
@@ -7,8 +7,8 @@
 pkgname=('gcc' 'gcc-libs' 'gcc-fortran' 'gcc-objc' 'gcc-ada' 'gcc-go')
 pkgver=4.9.0
 _pkgver=4.9
-pkgrel=3
-_snapshot=4.9-20140521
+pkgrel=4
+_snapshot=4.9-20140604
 pkgdesc="The GNU Compiler Collection"
 arch=('i686' 'x86_64')
 license=('GPL' 'LGPL' 'FDL' 'custom')
@@ -19,7 +19,7 @@ options=('!emptydirs')
 source=(#ftp://gcc.gnu.org/pub/gcc/releases/gcc-${pkgver}/gcc-${pkgver}.tar.bz2
         ftp://gcc.gnu.org/pub/gcc/snapshots/${_snapshot}/gcc-${_snapshot}.tar.bz2
         gcc-4.8-filename-output.patch)
-md5sums=('cd3cbe93ebc7207bf65d30e3c9a74a26'
+md5sums=('57aa4ff81c56262dc89994853c4d0149'
          '40cb437805e2f7a006aa0d0c3098ab0f')
 
 if [ -n "${_snapshot}" ]; then
diff --git a/core/isl/PKGBUILD b/core/isl/PKGBUILD
index 098205c04..5a49efc12 100644
--- a/core/isl/PKGBUILD
+++ b/core/isl/PKGBUILD
@@ -1,8 +1,8 @@
-# $Id: PKGBUILD 204392 2014-01-19 00:33:31Z allan $
+# $Id: PKGBUILD 214995 2014-06-11 11:40:27Z allan $
 # Maintainer: Allan McRae <allan@archlinux.org>
 
 pkgname=isl
-pkgver=0.12.2
+pkgver=0.13
 pkgrel=1
 pkgdesc="Library for manipulating sets and relations of integer points bounded by linear constraints"
 arch=('i686' 'x86_64')
@@ -10,7 +10,7 @@ url="http://freecode.com/projects/isl"
 depends=('gmp')
 license=('MIT')
 source=(http://isl.gforge.inria.fr/$pkgname-$pkgver.tar.bz2)
-md5sums=('e039bfcfb6c2ab039b8ee69bf883e824')
+md5sums=('e4cf20c4c10d5d613457558b1f46b5e2')
 
 
 build() {
@@ -29,7 +29,7 @@ package() {
   make DESTDIR="$pkgdir/" install
 
   install -dm755 $pkgdir/usr/share/gdb/auto-load/usr/lib/
-  mv $pkgdir/{,/usr/share/gdb/auto-load/}usr/lib/libisl.so.10.2.2-gdb.py
+  mv $pkgdir/usr/lib/libisl.so.*-gdb.py $pkgdir/usr/share/gdb/auto-load/usr/lib/
   
   install -Dm644 LICENSE $pkgdir/usr/share/licenses/isl/LICENSE
 }
diff --git a/core/systemd/0001-udev-always-close-lock-file-descriptor.patch b/core/systemd/0001-udev-always-close-lock-file-descriptor.patch
new file mode 100644
index 000000000..ed5deb556
--- /dev/null
+++ b/core/systemd/0001-udev-always-close-lock-file-descriptor.patch
@@ -0,0 +1,48 @@
+From 3d06f4183470d42361303086ed9dedd29c0ffc1b Mon Sep 17 00:00:00 2001
+From: Kay Sievers <kay@vrfy.org>
+Date: Tue, 3 Jun 2014 10:46:51 +0200
+Subject: [PATCH] udev: always close lock file descriptor
+
+https://bugs.freedesktop.org/show_bug.cgi?id=79576
+---
+ src/udev/udevd.c | 10 ++++------
+ 1 file changed, 4 insertions(+), 6 deletions(-)
+
+diff --git a/src/udev/udevd.c b/src/udev/udevd.c
+index 1c9488e..819ea3b 100644
+--- a/src/udev/udevd.c
++++ b/src/udev/udevd.c
+@@ -301,6 +301,7 @@ static void worker_new(struct event *event)
+                                         if (fd_lock >= 0 && flock(fd_lock, LOCK_SH|LOCK_NB) < 0) {
+                                                 log_debug("Unable to flock(%s), skipping event handling: %m", udev_device_get_devnode(d));
+                                                 err = -EWOULDBLOCK;
++                                                fd_lock = safe_close(fd_lock);
+                                                 goto skip;
+                                         }
+                                 }
+@@ -317,8 +318,7 @@ static void worker_new(struct event *event)
+                                 udev_device_update_db(dev);
+                         }
+ 
+-                        if (fd_lock >= 0)
+-                                close(fd_lock);
++                        safe_close(fd_lock);
+ 
+                         /* send processed event back to libudev listeners */
+                         udev_monitor_send_device(worker_monitor, NULL, dev);
+@@ -377,10 +377,8 @@ skip:
+                 }
+ out:
+                 udev_device_unref(dev);
+-                if (fd_signal >= 0)
+-                        close(fd_signal);
+-                if (fd_ep >= 0)
+-                        close(fd_ep);
++                safe_close(fd_signal);
++                safe_close(fd_ep);
+                 close(fd_inotify);
+                 close(worker_watch[WRITE_END]);
+                 udev_rules_unref(rules);
+-- 
+2.0.0
+
diff --git a/core/systemd/0001-udev-exclude-device-mapper-from-block-device-ownersh.patch b/core/systemd/0001-udev-exclude-device-mapper-from-block-device-ownersh.patch
new file mode 100644
index 000000000..533c88e53
--- /dev/null
+++ b/core/systemd/0001-udev-exclude-device-mapper-from-block-device-ownersh.patch
@@ -0,0 +1,38 @@
+From e918a1b5a94f270186dca59156354acd2a596494 Mon Sep 17 00:00:00 2001
+From: Kay Sievers <kay@vrfy.org>
+Date: Tue, 3 Jun 2014 16:49:38 +0200
+Subject: [PATCH] udev: exclude device-mapper from block device ownership event
+ locking
+
+---
+ src/udev/udevd.c | 14 +++++++++++++-
+ 1 file changed, 13 insertions(+), 1 deletion(-)
+
+diff --git a/src/udev/udevd.c b/src/udev/udevd.c
+index 819ea3b..6c05104 100644
+--- a/src/udev/udevd.c
++++ b/src/udev/udevd.c
+@@ -290,7 +290,19 @@ static void worker_new(struct event *event)
+                          * acquired the lock, the external process will block until
+                          * udev has finished its event handling.
+                          */
+-                        if (streq_ptr("block", udev_device_get_subsystem(dev))) {
++
++                        /*
++                         * <kabi_> since we make check - device seems unused - we try
++                         *         ioctl to deactivate - and device is found to be opened
++                         * <kay> sure, you try to take a write lock
++                         * <kay> if you get it udev is out
++                         * <kay> if you can't get it, udev is busy
++                         * <kabi_> we cannot deactivate openned device  (as it is in-use)
++                         * <kay> maybe we should just exclude dm from that thing entirely
++                         * <kabi_> IMHO this sounds like a good plan for this moment
++                         */
++                        if (streq_ptr("block", udev_device_get_subsystem(dev)) &&
++                            !startswith("dm-", udev_device_get_sysname(dev))) {
+                                 struct udev_device *d = dev;
+ 
+                                 if (streq_ptr("partition", udev_device_get_devtype(d)))
+-- 
+2.0.0
+
diff --git a/core/systemd/0001-udev-really-exclude-device-mapper-from-block-device-.patch b/core/systemd/0001-udev-really-exclude-device-mapper-from-block-device-.patch
new file mode 100644
index 000000000..10cf379e4
--- /dev/null
+++ b/core/systemd/0001-udev-really-exclude-device-mapper-from-block-device-.patch
@@ -0,0 +1,33 @@
+From 638ca89c53e2b897cfb3f627f4acbc7d09af2f4c Mon Sep 17 00:00:00 2001
+From: Christian Hesse <mail@eworm.de>
+Date: Tue, 10 Jun 2014 15:51:15 +0200
+Subject: [PATCH] udev: really exclude device-mapper from block device
+ ownership event locking
+
+Arguments were wrong order, no?
+This fixes commits:
+
+e918a1b5a94f270186dca59156354acd2a596494
+3d06f4183470d42361303086ed9dedd29c0ffc1b
+---
+* dreisner: avoid second hunk of patch which doesn't apply to v213
+
+ src/udev/udevd.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/src/udev/udevd.c b/src/udev/udevd.c
+index 0f3f3f0..160360e 100644
+--- a/src/udev/udevd.c
++++ b/src/udev/udevd.c
+@@ -304,7 +304,7 @@ static void worker_new(struct event *event)
+                          * <kabi_> IMHO this sounds like a good plan for this moment
+                          */
+                         if (streq_ptr("block", udev_device_get_subsystem(dev)) &&
+-                            !startswith("dm-", udev_device_get_sysname(dev))) {
++                            !startswith(udev_device_get_sysname(dev), "dm-")) {
+                                 struct udev_device *d = dev;
+ 
+                                 if (streq_ptr("partition", udev_device_get_devtype(d)))
+-- 
+2.0.0
+
diff --git a/core/systemd/PKGBUILD b/core/systemd/PKGBUILD
index 78ca21668..1e67f5839 100644
--- a/core/systemd/PKGBUILD
+++ b/core/systemd/PKGBUILD
@@ -4,7 +4,7 @@
 pkgbase=systemd
 pkgname=('systemd' 'libsystemd' 'systemd-sysvcompat')
 pkgver=213
-pkgrel=6
+pkgrel=9
 arch=('i686' 'x86_64')
 url="http://www.freedesktop.org/wiki/Software/systemd"
 makedepends=('acl' 'cryptsetup' 'docbook-xsl' 'gobject-introspection' 'gperf'
@@ -18,14 +18,20 @@ source=("http://www.freedesktop.org/software/$pkgname/$pkgname-$pkgver.tar.xz"
         'initcpio-install-udev'
         '0001-units-use-KillMode-mixed-for-systemd-nspawn-.service.patch'
         '0001-fsck-disable-l-option-for-now.patch'
-        '0001-networkd-link-intialize-mac-address.patch')
+        '0001-udev-exclude-device-mapper-from-block-device-ownersh.patch'
+        '0001-udev-always-close-lock-file-descriptor.patch'
+        '0001-networkd-link-intialize-mac-address.patch'
+        '0001-udev-really-exclude-device-mapper-from-block-device-.patch')
 md5sums=('06496edcf86ddf6d8c12d72ba78e735d'
          '29245f7a240bfba66e2b1783b63b6b40'
          '66cca7318e13eaf37c5b7db2efa69846'
          'bde43090d4ac0ef048e3eaee8202a407'
          '5f8ad7126970855614c7fa34b317728d'
          '888cf85a92dd28bcf80e18539fef3915'
-         '3d53d3bcd85ca0b2ff9f4e79d012808d')
+         'f26803dda8811196c0564f928bfe69d1'
+         '2a14fe9876fa48f01cca3c1d575e5771'
+         '3d53d3bcd85ca0b2ff9f4e79d012808d'
+         'ae060fc00eeced6554e70d9a9c0eb42f')
 
 prepare() {
   cd "$pkgname-$pkgver"
@@ -33,8 +39,12 @@ prepare() {
   patch -Np1 <"$srcdir/0001-units-use-KillMode-mixed-for-systemd-nspawn-.service.patch"
   patch -Np1 <"$srcdir/0001-networkd-link-intialize-mac-address.patch"
   patch -Np1 <"$srcdir/0001-fsck-disable-l-option-for-now.patch"
+  patch -Np1 <"$srcdir/0001-udev-always-close-lock-file-descriptor.patch"
+  patch -Np1 <"$srcdir/0001-udev-exclude-device-mapper-from-block-device-ownersh.patch"
+  patch -Np1 <"$srcdir/0001-udev-really-exclude-device-mapper-from-block-device-.patch"
 }
 
+
 build() {
   cd "$pkgname-$pkgver"
 
@@ -81,18 +91,22 @@ package_systemd() {
           etc/systemd/journald.conf
           etc/systemd/logind.conf
           etc/systemd/system.conf
+          etc/systemd/timesyncd.conf
+          etc/systemd/resolved.conf
           etc/systemd/user.conf
           etc/udev/udev.conf)
   install="systemd.install"
 
   make -C "$pkgname-$pkgver" DESTDIR="$pkgdir" install
 
-  # don't write units to /etc by default -- we'll enable the getty on
-  # post_install as a sane default.
-  rm "$pkgdir/etc/systemd/system/getty.target.wants/getty@tty1.service"
-  rm "$pkgdir/etc/systemd/system/multi-user.target.wants/systemd-networkd.service"
-  rm "$pkgdir/etc/systemd/system/multi-user.target.wants/systemd-resolved.service"
-  rmdir "$pkgdir/etc/systemd/system/getty.target.wants"
+  # don't write units to /etc by default. some of these will be re-enabled on
+  # post_install.
+  rm "$pkgdir/etc/systemd/system/getty.target.wants/getty@tty1.service" \
+      "$pkgdir/etc/systemd/system/multi-user.target.wants/systemd-networkd.service" \
+      "$pkgdir/etc/systemd/system/multi-user.target.wants/systemd-resolved.service" \
+      "$pkgdir/etc/systemd/system/network-online.target.wants/systemd-networkd-wait-online.service"
+  rmdir "$pkgdir/etc/systemd/system/getty.target.wants" \
+      "$pkgdir/etc/systemd/system/network-online.target.wants"
 
   # get rid of RPM macros
   rm -r "$pkgdir/usr/lib/rpm"
diff --git a/core/systemd/systemd.install b/core/systemd/systemd.install
index 5c370f7ae..cb47fe987 100644
--- a/core/systemd/systemd.install
+++ b/core/systemd/systemd.install
@@ -63,9 +63,6 @@ _206_1_changes() {
 }
 
 _208_1_changes() {
-  chown root:systemd-journal var/log/journal
-  chmod 2755 var/log/journal
-
   if [[ -e var/lib/backlight && ! -e var/lib/systemd/backlight ]]; then
     mv -T var/lib/backlight var/lib/systemd/backlight
   fi