X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=isl_pw_templ.c;h=da4b53e5ec2a13445b4b7bb170a66f18ca7775e9;hb=78b3cfae0a9cad8fbca88a9b5ce79337c2ba01c3;hp=3ebfb9257c561d247fb8b3630abef2403f5b5669;hpb=8b647cf4baa947a8a7f5b76dcff98c4d8592b042;p=platform%2Fupstream%2Fisl.git

diff --git a/isl_pw_templ.c b/isl_pw_templ.c
index 3ebfb92..da4b53e 100644
--- a/isl_pw_templ.c
+++ b/isl_pw_templ.c
@@ -3,7 +3,12 @@
 #define xS(TYPE,NAME) struct TYPE ## _ ## NAME
 #define S(TYPE,NAME) xS(TYPE,NAME)
 
+#ifdef HAS_TYPE
+static __isl_give PW *FN(PW,alloc_)(__isl_take isl_dim *dim,
+	enum isl_fold type, int n)
+#else
 static __isl_give PW *FN(PW,alloc_)(__isl_take isl_dim *dim, int n)
+#endif
 {
 	struct PW *pw;
 
@@ -16,6 +21,9 @@ static __isl_give PW *FN(PW,alloc_)(__isl_take isl_dim *dim, int n)
 		goto error;
 
 	pw->ref = 1;
+#ifdef HAS_TYPE
+	pw->type = type;
+#endif
 	pw->size = n;
 	pw->n = 0;
 	pw->dim = dim;
@@ -25,10 +33,17 @@ error:
 	return NULL;
 }
 
+#ifdef HAS_TYPE
+__isl_give PW *FN(PW,zero)(__isl_take isl_dim *dim, enum isl_fold type)
+{
+	return FN(PW,alloc_)(dim, type, 0);
+}
+#else
 __isl_give PW *FN(PW,zero)(__isl_take isl_dim *dim)
 {
 	return FN(PW,alloc_)(dim, 0);
 }
+#endif
 
 __isl_give PW *FN(PW,add_piece)(__isl_take PW *pw,
 	__isl_take isl_set *set, __isl_take EL *el)
@@ -42,6 +57,11 @@ __isl_give PW *FN(PW,add_piece)(__isl_take PW *pw,
 		return pw;
 	}
 
+#ifdef HAS_TYPE
+	if (pw->type != el->type)
+		isl_die(set->ctx, isl_error_invalid, "fold types don't match",
+			goto error);
+#endif
 	isl_assert(set->ctx, isl_dim_equal(pw->dim, el->dim), goto error);
 	isl_assert(set->ctx, pw->n < pw->size, goto error);
 
@@ -57,14 +77,23 @@ error:
 	return NULL;
 }
 
+#ifdef HAS_TYPE
+__isl_give PW *FN(PW,alloc)(enum isl_fold type,
+	__isl_take isl_set *set, __isl_take EL *el)
+#else
 __isl_give PW *FN(PW,alloc)(__isl_take isl_set *set, __isl_take EL *el)
+#endif
 {
 	PW *pw;
 
 	if (!set || !el)
 		goto error;
 
+#ifdef HAS_TYPE
+	pw = FN(PW,alloc_)(isl_set_get_dim(set), type, 1);
+#else
 	pw = FN(PW,alloc_)(isl_set_get_dim(set), 1);
+#endif
 
 	return FN(PW,add_piece)(pw, set, el);
 error:
@@ -81,7 +110,11 @@ __isl_give PW *FN(PW,dup)(__isl_keep PW *pw)
 	if (!pw)
 		return NULL;
 
+#ifdef HAS_TYPE
+	dup = FN(PW,alloc_)(isl_dim_copy(pw->dim), pw->type, pw->n);
+#else
 	dup = FN(PW,alloc_)(isl_dim_copy(pw->dim), pw->n);
+#endif
 	if (!dup)
 		return NULL;
 
@@ -149,6 +182,11 @@ __isl_give PW *FN(PW,add)(__isl_take PW *pw1, __isl_take PW *pw2)
 	if (!pw1 || !pw2)
 		goto error;
 
+#ifdef HAS_TYPE
+	if (pw1->type != pw2->type)
+		isl_die(pw1->dim->ctx, isl_error_invalid,
+			"fold types don't match", goto error);
+#endif
 	isl_assert(pw1->dim->ctx, isl_dim_equal(pw1->dim, pw2->dim), goto error);
 
 	if (FN(PW,is_zero)(pw1)) {
@@ -162,7 +200,11 @@ __isl_give PW *FN(PW,add)(__isl_take PW *pw1, __isl_take PW *pw2)
 	}
 
 	n = (pw1->n + 1) * (pw2->n + 1);
+#ifdef HAS_TYPE
+	res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), pw1->type, n);
+#else
 	res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), n);
+#endif
 
 	for (i = 0; i < pw1->n; ++i) {
 		set = isl_set_copy(pw1->p[i].set);
@@ -178,8 +220,9 @@ __isl_give PW *FN(PW,add)(__isl_take PW *pw1, __isl_take PW *pw2)
 				continue;
 			}
 
-			sum = ADD(common, FN(EL,copy)(pw1->p[i].FIELD),
-					  FN(EL,copy)(pw2->p[j].FIELD));
+			sum = FN(EL,add_on_domain)(common,
+						   FN(EL,copy)(pw1->p[i].FIELD),
+						   FN(EL,copy)(pw2->p[j].FIELD));
 
 			res = FN(PW,add_piece)(res, common, sum);
 		}
@@ -212,6 +255,11 @@ __isl_give PW *FN(PW,add_disjoint)(__isl_take PW *pw1, __isl_take PW *pw2)
 	if (!pw1 || !pw2)
 		goto error;
 
+#ifdef HAS_TYPE
+	if (pw1->type != pw2->type)
+		isl_die(pw1->dim->ctx, isl_error_invalid,
+			"fold types don't match", goto error);
+#endif
 	isl_assert(pw1->dim->ctx, isl_dim_equal(pw1->dim, pw2->dim), goto error);
 
 	if (FN(PW,is_zero)(pw1)) {
@@ -224,7 +272,11 @@ __isl_give PW *FN(PW,add_disjoint)(__isl_take PW *pw1, __isl_take PW *pw2)
 		return pw1;
 	}
 
+#ifdef HAS_TYPE
+	res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), pw1->type, pw1->n + pw2->n);
+#else
 	res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), pw1->n + pw2->n);
+#endif
 
 	for (i = 0; i < pw1->n; ++i)
 		res = FN(PW,add_piece)(res,
@@ -250,7 +302,7 @@ __isl_give isl_qpolynomial *FN(PW,eval)(__isl_take PW *pw,
 	__isl_take isl_point *pnt)
 {
 	int i;
-	int found;
+	int found = 0;
 	isl_qpolynomial *qp;
 
 	if (!pw || !pnt)
@@ -311,10 +363,21 @@ __isl_give PW *FN(PW,intersect_domain)(__isl_take PW *pw, __isl_take isl_set *se
 	if (!pw)
 		goto error;
 
-	for (i = 0; i < pw->n; ++i) {
+	for (i = pw->n - 1; i >= 0; --i) {
+		isl_basic_set *aff;
 		pw->p[i].set = isl_set_intersect(pw->p[i].set, isl_set_copy(set));
 		if (!pw->p[i].set)
 			goto error;
+		aff = isl_set_affine_hull(isl_set_copy(pw->p[i].set));
+		pw->p[i].FIELD = FN(EL,substitute_equalities)(pw->p[i].FIELD,
+								aff);
+		if (isl_set_fast_is_empty(pw->p[i].set)) {
+			isl_set_free(pw->p[i].set);
+			FN(EL,free)(pw->p[i].FIELD);
+			if (i != pw->n - 1)
+				pw->p[i] = pw->p[pw->n - 1];
+			pw->n--;
+		}
 	}
 	
 	isl_set_free(set);
@@ -338,17 +401,31 @@ __isl_give PW *FN(PW,gist)(__isl_take PW *pw, __isl_take isl_set *context)
 		return pw;
 	}
 
-	hull = isl_set_convex_hull(isl_set_copy(context));
+	context = isl_set_compute_divs(context);
+	hull = isl_set_simple_hull(isl_set_copy(context));
 
 	pw = FN(PW,cow)(pw);
 	if (!pw)
 		goto error;
 
-	for (i = 0; i < pw->n; ++i) {
-		pw->p[i].set = isl_set_gist(pw->p[i].set,
+	for (i = pw->n - 1; i >= 0; --i) {
+		pw->p[i].set = isl_set_intersect(pw->p[i].set,
+						 isl_set_copy(context));
+		if (!pw->p[i].set)
+			goto error;
+		pw->p[i].FIELD = FN(EL,gist)(pw->p[i].FIELD,
+					     isl_set_copy(pw->p[i].set));
+		pw->p[i].set = isl_set_gist_basic_set(pw->p[i].set,
 						isl_basic_set_copy(hull));
 		if (!pw->p[i].set)
 			goto error;
+		if (isl_set_fast_is_empty(pw->p[i].set)) {
+			isl_set_free(pw->p[i].set);
+			FN(EL,free)(pw->p[i].FIELD);
+			if (i != pw->n - 1)
+				pw->p[i] = pw->p[pw->n - 1];
+			pw->n--;
+		}
 	}
 
 	isl_basic_set_free(hull);
@@ -419,6 +496,34 @@ int FN(PW,involves_dims)(__isl_keep PW *pw, enum isl_dim_type type,
 	return 0;
 }
 
+__isl_give PW *FN(PW,set_dim_name)(__isl_take PW *pw,
+	enum isl_dim_type type, unsigned pos, const char *s)
+{
+	int i;
+
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		return NULL;
+
+	pw->dim = isl_dim_set_name(pw->dim, type, pos, s);
+	if (!pw->dim)
+		goto error;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->p[i].set = isl_set_set_dim_name(pw->p[i].set, type, pos, s);
+		if (!pw->p[i].set)
+			goto error;
+		pw->p[i].FIELD = FN(EL,set_dim_name)(pw->p[i].FIELD, type, pos, s);
+		if (!pw->p[i].FIELD)
+			goto error;
+	}
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	return NULL;
+}
+
 __isl_give PW *FN(PW,drop_dims)(__isl_take PW *pw,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
@@ -426,7 +531,7 @@ __isl_give PW *FN(PW,drop_dims)(__isl_take PW *pw,
 
 	if (!pw)
 		return NULL;
-	if (n == 0)
+	if (n == 0 && !isl_dim_get_tuple_name(pw->dim, type))
 		return pw;
 
 	pw = FN(PW,cow)(pw);
@@ -450,6 +555,40 @@ error:
 	return NULL;
 }
 
+__isl_give PW *FN(PW,insert_dims)(__isl_take PW *pw, enum isl_dim_type type,
+	unsigned first, unsigned n)
+{
+	int i;
+
+	if (!pw)
+		return NULL;
+	if (n == 0 && !isl_dim_is_named_or_nested(pw->dim, type))
+		return pw;
+
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		return NULL;
+
+	pw->dim = isl_dim_insert(pw->dim, type, first, n);
+	if (!pw->dim)
+		goto error;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->p[i].set = isl_set_insert(pw->p[i].set, type, first, n);
+		if (!pw->p[i].set)
+			goto error;
+		pw->p[i].FIELD = FN(EL,insert_dims)(pw->p[i].FIELD,
+								type, first, n);
+		if (!pw->p[i].FIELD)
+			goto error;
+	}
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	return NULL;
+}
+
 __isl_give PW *FN(PW,fix_dim)(__isl_take PW *pw,
 	enum isl_dim_type type, unsigned pos, isl_int v)
 {
@@ -549,3 +688,272 @@ __isl_give isl_qpolynomial *FN(PW,min)(__isl_take PW *pw)
 {
 	return FN(PW,opt)(pw, 0);
 }
+
+__isl_give isl_dim *FN(PW,get_dim)(__isl_keep PW *pw)
+{
+	return pw ? isl_dim_copy(pw->dim) : NULL;
+}
+
+__isl_give PW *FN(PW,reset_dim)(__isl_take PW *pw, __isl_take isl_dim *dim)
+{
+	int i;
+
+	pw = FN(PW,cow)(pw);
+	if (!pw || !dim)
+		goto error;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->p[i].set = isl_set_reset_dim(pw->p[i].set,
+						 isl_dim_copy(dim));
+		if (!pw->p[i].set)
+			goto error;
+		pw->p[i].FIELD = FN(EL,reset_dim)(pw->p[i].FIELD,
+						  isl_dim_copy(dim));
+		if (!pw->p[i].FIELD)
+			goto error;
+	}
+	isl_dim_free(pw->dim);
+	pw->dim = dim;
+
+	return pw;
+error:
+	isl_dim_free(dim);
+	FN(PW,free)(pw);
+	return NULL;
+}
+
+int FN(PW,has_equal_dim)(__isl_keep PW *pw1, __isl_keep PW *pw2)
+{
+	if (!pw1 || !pw2)
+		return -1;
+
+	return isl_dim_equal(pw1->dim, pw2->dim);
+}
+
+__isl_give PW *FN(PW,morph)(__isl_take PW *pw, __isl_take isl_morph *morph)
+{
+	int i;
+
+	if (!pw || !morph)
+		goto error;
+
+	isl_assert(pw->dim->ctx, isl_dim_equal(pw->dim, morph->dom->dim),
+		goto error);
+
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		goto error;
+	isl_dim_free(pw->dim);
+	pw->dim = isl_dim_copy(morph->ran->dim);
+	if (!pw->dim)
+		goto error;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->p[i].set = isl_morph_set(isl_morph_copy(morph), pw->p[i].set);
+		if (!pw->p[i].set)
+			goto error;
+		pw->p[i].FIELD = FN(EL,morph)(pw->p[i].FIELD,
+						isl_morph_copy(morph));
+		if (!pw->p[i].FIELD)
+			goto error;
+	}
+
+	isl_morph_free(morph);
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	isl_morph_free(morph);
+	return NULL;
+}
+
+int FN(PW,foreach_piece)(__isl_keep PW *pw,
+	int (*fn)(__isl_take isl_set *set, __isl_take EL *el, void *user),
+	void *user)
+{
+	int i;
+
+	if (!pw)
+		return -1;
+
+	for (i = 0; i < pw->n; ++i)
+		if (fn(isl_set_copy(pw->p[i].set),
+				FN(EL,copy)(pw->p[i].FIELD), user) < 0)
+			return -1;
+
+	return 0;
+}
+
+static int any_divs(__isl_keep isl_set *set)
+{
+	int i;
+
+	if (!set)
+		return -1;
+
+	for (i = 0; i < set->n; ++i)
+		if (set->p[i]->n_div > 0)
+			return 1;
+
+	return 0;
+}
+
+static int foreach_lifted_subset(__isl_take isl_set *set, __isl_take EL *el,
+	int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
+		    void *user), void *user)
+{
+	int i;
+
+	if (!set || !el)
+		goto error;
+
+	for (i = 0; i < set->n; ++i) {
+		isl_set *lift;
+		EL *copy;
+
+		lift = isl_set_from_basic_set(isl_basic_set_copy(set->p[i]));
+		lift = isl_set_lift(lift);
+
+		copy = FN(EL,copy)(el);
+		copy = FN(EL,lift)(copy, isl_set_get_dim(lift));
+
+		if (fn(lift, copy, user) < 0)
+			goto error;
+	}
+
+	isl_set_free(set);
+	FN(EL,free)(el);
+
+	return 0;
+error:
+	isl_set_free(set);
+	FN(EL,free)(el);
+	return -1;
+}
+
+int FN(PW,foreach_lifted_piece)(__isl_keep PW *pw,
+	int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
+		    void *user), void *user)
+{
+	int i;
+
+	if (!pw)
+		return -1;
+
+	for (i = 0; i < pw->n; ++i) {
+		isl_set *set;
+		EL *el;
+
+		set = isl_set_copy(pw->p[i].set);
+		el = FN(EL,copy)(pw->p[i].FIELD);
+		if (!any_divs(set)) {
+			if (fn(set, el, user) < 0)
+				return -1;
+			continue;
+		}
+		if (foreach_lifted_subset(set, el, fn, user) < 0)
+			return -1;
+	}
+
+	return 0;
+}
+
+__isl_give PW *FN(PW,move_dims)(__isl_take PW *pw,
+	enum isl_dim_type dst_type, unsigned dst_pos,
+	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
+{
+	int i;
+
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		return NULL;
+
+	pw->dim = isl_dim_move(pw->dim, dst_type, dst_pos, src_type, src_pos, n);
+	if (!pw->dim)
+		goto error;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->p[i].set = isl_set_move_dims(pw->p[i].set,
+						dst_type, dst_pos,
+						src_type, src_pos, n);
+		if (!pw->p[i].set)
+			goto error;
+		pw->p[i].FIELD = FN(EL,move_dims)(pw->p[i].FIELD,
+					dst_type, dst_pos, src_type, src_pos, n);
+		if (!pw->p[i].FIELD)
+			goto error;
+	}
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	return NULL;
+}
+
+__isl_give PW *FN(PW,realign)(__isl_take PW *pw, __isl_take isl_reordering *exp)
+{
+	int i;
+
+	pw = FN(PW,cow)(pw);
+	if (!pw || !exp)
+		return NULL;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->p[i].set = isl_set_realign(pw->p[i].set,
+						    isl_reordering_copy(exp));
+		if (!pw->p[i].set)
+			goto error;
+		pw->p[i].FIELD = FN(EL,realign)(pw->p[i].FIELD,
+						    isl_reordering_copy(exp));
+		if (!pw->p[i].FIELD)
+			goto error;
+	}
+
+	pw = FN(PW,reset_dim)(pw, isl_dim_copy(exp->dim));
+
+	isl_reordering_free(exp);
+	return pw;
+error:
+	isl_reordering_free(exp);
+	FN(PW,free)(pw);
+	return NULL;
+}
+
+__isl_give PW *FN(PW,mul_isl_int)(__isl_take PW *pw, isl_int v)
+{
+	int i;
+
+	if (isl_int_is_one(v))
+		return pw;
+	if (pw && isl_int_is_zero(v)) {
+		PW *zero;
+		isl_dim *dim = FN(PW,get_dim)(pw);
+#ifdef HAS_TYPE
+		zero = FN(PW,zero)(dim, pw->type);
+#else
+		zero = FN(PW,zero)(dim);
+#endif
+		FN(PW,free)(pw);
+		return zero;
+	}
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		return NULL;
+	if (pw->n == 0)
+		return pw;
+
+#ifdef HAS_TYPE
+	if (isl_int_is_neg(v))
+		pw->type = isl_fold_type_negate(pw->type);
+#endif
+	for (i = 0; i < pw->n; ++i) {
+		pw->p[i].FIELD = FN(EL,mul_isl_int)(pw->p[i].FIELD, v);
+		if (!pw->p[i].FIELD)
+			goto error;
+	}
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	return NULL;
+}