2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 * Copyright 2010 INRIA Saclay
5 * Use of this software is governed by the GNU LGPLv2.1 license
7 * Written by Sven Verdoolaege, K.U.Leuven, Departement
8 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
9 * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
10 * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
14 #include <isl_dim_private.h>
15 #include <isl_id_private.h>
16 #include <isl_reordering.h>
18 isl_ctx *isl_dim_get_ctx(__isl_keep isl_dim *dim)
20 return dim ? dim->ctx : NULL;
23 struct isl_dim *isl_dim_alloc(struct isl_ctx *ctx,
24 unsigned nparam, unsigned n_in, unsigned n_out)
28 dim = isl_alloc_type(ctx, struct isl_dim);
39 dim->tuple_id[0] = NULL;
40 dim->tuple_id[1] = NULL;
42 dim->nested[0] = NULL;
43 dim->nested[1] = NULL;
51 struct isl_dim *isl_dim_set_alloc(struct isl_ctx *ctx,
52 unsigned nparam, unsigned dim)
54 return isl_dim_alloc(ctx, nparam, 0, dim);
57 static unsigned global_pos(struct isl_dim *dim,
58 enum isl_dim_type type, unsigned pos)
60 struct isl_ctx *ctx = dim->ctx;
64 isl_assert(ctx, pos < dim->nparam, return isl_dim_total(dim));
67 isl_assert(ctx, pos < dim->n_in, return isl_dim_total(dim));
68 return pos + dim->nparam;
70 isl_assert(ctx, pos < dim->n_out, return isl_dim_total(dim));
71 return pos + dim->nparam + dim->n_in;
73 isl_assert(ctx, 0, return isl_dim_total(dim));
75 return isl_dim_total(dim);
78 /* Extend length of ids array to the total number of dimensions.
80 static __isl_give isl_dim *extend_ids(__isl_take isl_dim *dim)
85 if (isl_dim_total(dim) <= dim->n_id)
89 dim->ids = isl_calloc_array(dim->ctx,
90 isl_id *, isl_dim_total(dim));
94 ids = isl_realloc_array(dim->ctx, dim->ids,
95 isl_id *, isl_dim_total(dim));
99 for (i = dim->n_id; i < isl_dim_total(dim); ++i)
103 dim->n_id = isl_dim_total(dim);
111 static __isl_give isl_dim *set_id(__isl_take isl_dim *dim,
112 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
114 dim = isl_dim_cow(dim);
119 pos = global_pos(dim, type, pos);
120 if (pos == isl_dim_total(dim))
123 if (pos >= dim->n_id) {
126 dim = extend_ids(dim);
140 static __isl_keep isl_id *get_id(__isl_keep isl_dim *dim,
141 enum isl_dim_type type, unsigned pos)
146 pos = global_pos(dim, type, pos);
147 if (pos == isl_dim_total(dim))
149 if (pos >= dim->n_id)
151 return dim->ids[pos];
154 static unsigned offset(struct isl_dim *dim, enum isl_dim_type type)
157 case isl_dim_param: return 0;
158 case isl_dim_in: return dim->nparam;
159 case isl_dim_out: return dim->nparam + dim->n_in;
164 static unsigned n(struct isl_dim *dim, enum isl_dim_type type)
167 case isl_dim_param: return dim->nparam;
168 case isl_dim_in: return dim->n_in;
169 case isl_dim_out: return dim->n_out;
170 case isl_dim_all: return dim->nparam + dim->n_in + dim->n_out;
175 unsigned isl_dim_size(struct isl_dim *dim, enum isl_dim_type type)
182 unsigned isl_dim_offset(__isl_keep isl_dim *dim, enum isl_dim_type type)
186 return offset(dim, type);
189 static __isl_give isl_dim *copy_ids(__isl_take isl_dim *dst,
190 enum isl_dim_type dst_type, unsigned offset, __isl_keep isl_dim *src,
191 enum isl_dim_type src_type)
199 for (i = 0; i < n(src, src_type); ++i) {
200 id = get_id(src, src_type, i);
203 dst = set_id(dst, dst_type, offset + i, isl_id_copy(id));
210 struct isl_dim *isl_dim_dup(struct isl_dim *dim)
215 dup = isl_dim_alloc(dim->ctx, dim->nparam, dim->n_in, dim->n_out);
216 if (dim->tuple_id[0] &&
217 !(dup->tuple_id[0] = isl_id_copy(dim->tuple_id[0])))
219 if (dim->tuple_id[1] &&
220 !(dup->tuple_id[1] = isl_id_copy(dim->tuple_id[1])))
222 if (dim->nested[0] && !(dup->nested[0] = isl_dim_copy(dim->nested[0])))
224 if (dim->nested[1] && !(dup->nested[1] = isl_dim_copy(dim->nested[1])))
228 dup = copy_ids(dup, isl_dim_param, 0, dim, isl_dim_param);
229 dup = copy_ids(dup, isl_dim_in, 0, dim, isl_dim_in);
230 dup = copy_ids(dup, isl_dim_out, 0, dim, isl_dim_out);
237 struct isl_dim *isl_dim_cow(struct isl_dim *dim)
245 return isl_dim_dup(dim);
248 struct isl_dim *isl_dim_copy(struct isl_dim *dim)
257 void isl_dim_free(struct isl_dim *dim)
267 isl_id_free(dim->tuple_id[0]);
268 isl_id_free(dim->tuple_id[1]);
270 isl_dim_free(dim->nested[0]);
271 isl_dim_free(dim->nested[1]);
273 for (i = 0; i < dim->n_id; ++i)
274 isl_id_free(dim->ids[i]);
276 isl_ctx_deref(dim->ctx);
281 static int name_ok(isl_ctx *ctx, const char *s)
286 dummy = strtol(s, &p, 0);
288 isl_die(ctx, isl_error_invalid, "name looks like a number",
294 __isl_give isl_id *isl_dim_get_tuple_id(__isl_keep isl_dim *dim,
295 enum isl_dim_type type)
299 if (type != isl_dim_in && type != isl_dim_out)
301 return isl_id_copy(dim->tuple_id[type - isl_dim_in]);
304 __isl_give isl_dim *isl_dim_set_tuple_id(__isl_take isl_dim *dim,
305 enum isl_dim_type type, __isl_take isl_id *id)
307 dim = isl_dim_cow(dim);
310 if (type != isl_dim_in && type != isl_dim_out)
311 isl_die(dim->ctx, isl_error_invalid,
312 "only input, output and set tuples can have names",
315 isl_id_free(dim->tuple_id[type - isl_dim_in]);
316 dim->tuple_id[type - isl_dim_in] = id;
325 __isl_give isl_dim *isl_dim_reset_tuple_id(__isl_take isl_dim *dim,
326 enum isl_dim_type type)
328 dim = isl_dim_cow(dim);
331 if (type != isl_dim_in && type != isl_dim_out)
332 isl_die(dim->ctx, isl_error_invalid,
333 "only input, output and set tuples can have names",
336 isl_id_free(dim->tuple_id[type - isl_dim_in]);
337 dim->tuple_id[type - isl_dim_in] = NULL;
345 __isl_give isl_dim *isl_dim_set_dim_id(__isl_take isl_dim *dim,
346 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
348 dim = isl_dim_cow(dim);
351 isl_id_free(get_id(dim, type, pos));
352 return set_id(dim, type, pos, id);
359 __isl_give isl_id *isl_dim_get_dim_id(__isl_keep isl_dim *dim,
360 enum isl_dim_type type, unsigned pos)
362 return isl_id_copy(get_id(dim, type, pos));
365 __isl_give isl_dim *isl_dim_set_tuple_name(__isl_take isl_dim *dim,
366 enum isl_dim_type type, const char *s)
374 return isl_dim_reset_tuple_id(dim, type);
376 if (!name_ok(dim->ctx, s))
379 id = isl_id_alloc(dim->ctx, s, NULL);
380 return isl_dim_set_tuple_id(dim, type, id);
386 const char *isl_dim_get_tuple_name(__isl_keep isl_dim *dim,
387 enum isl_dim_type type)
392 if (type != isl_dim_in && type != isl_dim_out)
394 id = dim->tuple_id[type - isl_dim_in];
395 return id ? id->name : NULL;
398 struct isl_dim *isl_dim_set_name(struct isl_dim *dim,
399 enum isl_dim_type type, unsigned pos,
406 if (!name_ok(dim->ctx, s))
408 id = isl_id_alloc(dim->ctx, s, NULL);
409 return isl_dim_set_dim_id(dim, type, pos, id);
415 const char *isl_dim_get_name(struct isl_dim *dim,
416 enum isl_dim_type type, unsigned pos)
418 isl_id *id = get_id(dim, type, pos);
419 return id ? id->name : NULL;
422 int isl_dim_find_dim_by_id(__isl_keep isl_dim *dim, enum isl_dim_type type,
423 __isl_keep isl_id *id)
432 offset = isl_dim_offset(dim, type);
433 n = isl_dim_size(dim, type);
434 for (i = 0; i < n && offset + i < dim->n_id; ++i)
435 if (dim->ids[offset + i] == id)
441 static __isl_keep isl_id *tuple_id(__isl_keep isl_dim *dim,
442 enum isl_dim_type type)
446 if (type == isl_dim_in)
447 return dim->tuple_id[0];
448 if (type == isl_dim_out)
449 return dim->tuple_id[1];
453 static __isl_keep isl_dim *nested(__isl_keep isl_dim *dim,
454 enum isl_dim_type type)
458 if (type == isl_dim_in)
459 return dim->nested[0];
460 if (type == isl_dim_out)
461 return dim->nested[1];
465 int isl_dim_tuple_match(__isl_keep isl_dim *dim1, enum isl_dim_type dim1_type,
466 __isl_keep isl_dim *dim2, enum isl_dim_type dim2_type)
469 isl_dim *nested1, *nested2;
474 if (n(dim1, dim1_type) != n(dim2, dim2_type))
476 id1 = tuple_id(dim1, dim1_type);
477 id2 = tuple_id(dim2, dim2_type);
480 if (id1 && id1 != id2)
482 nested1 = nested(dim1, dim1_type);
483 nested2 = nested(dim2, dim2_type);
484 if (!nested1 ^ !nested2)
486 if (nested1 && !isl_dim_equal(nested1, nested2))
491 static int match(struct isl_dim *dim1, enum isl_dim_type dim1_type,
492 struct isl_dim *dim2, enum isl_dim_type dim2_type)
496 if (!isl_dim_tuple_match(dim1, dim1_type, dim2, dim2_type))
499 if (!dim1->ids && !dim2->ids)
502 for (i = 0; i < n(dim1, dim1_type); ++i) {
503 if (get_id(dim1, dim1_type, i) != get_id(dim2, dim2_type, i))
509 int isl_dim_match(struct isl_dim *dim1, enum isl_dim_type dim1_type,
510 struct isl_dim *dim2, enum isl_dim_type dim2_type)
512 return match(dim1, dim1_type, dim2, dim2_type);
515 static void get_ids(struct isl_dim *dim, enum isl_dim_type type,
516 unsigned first, unsigned n, __isl_keep isl_id **ids)
520 for (i = 0; i < n ; ++i)
521 ids[i] = get_id(dim, type, first + i);
524 struct isl_dim *isl_dim_extend(struct isl_dim *dim,
525 unsigned nparam, unsigned n_in, unsigned n_out)
531 if (dim->nparam == nparam && dim->n_in == n_in && dim->n_out == n_out)
534 isl_assert(dim->ctx, dim->nparam <= nparam, goto error);
535 isl_assert(dim->ctx, dim->n_in <= n_in, goto error);
536 isl_assert(dim->ctx, dim->n_out <= n_out, goto error);
538 dim = isl_dim_cow(dim);
541 ids = isl_calloc_array(dim->ctx, isl_id *,
542 nparam + n_in + n_out);
545 get_ids(dim, isl_dim_param, 0, dim->nparam, ids);
546 get_ids(dim, isl_dim_in, 0, dim->n_in, ids + nparam);
547 get_ids(dim, isl_dim_out, 0, dim->n_out, ids + nparam + n_in);
550 dim->n_id = nparam + n_in + n_out;
552 dim->nparam = nparam;
563 struct isl_dim *isl_dim_add(struct isl_dim *dim, enum isl_dim_type type,
568 dim = isl_dim_reset(dim, type);
571 dim = isl_dim_extend(dim,
572 dim->nparam + n, dim->n_in, dim->n_out);
573 if (dim && dim->nested[0] &&
574 !(dim->nested[0] = isl_dim_add(dim->nested[0],
577 if (dim && dim->nested[1] &&
578 !(dim->nested[1] = isl_dim_add(dim->nested[1],
583 return isl_dim_extend(dim,
584 dim->nparam, dim->n_in + n, dim->n_out);
586 return isl_dim_extend(dim,
587 dim->nparam, dim->n_in, dim->n_out + n);
589 isl_die(dim->ctx, isl_error_invalid,
590 "cannot add dimensions of specified type", goto error);
597 static int valid_dim_type(enum isl_dim_type type)
609 __isl_give isl_dim *isl_dim_insert(__isl_take isl_dim *dim,
610 enum isl_dim_type type, unsigned pos, unsigned n)
617 return isl_dim_reset(dim, type);
619 if (!valid_dim_type(type))
620 isl_die(dim->ctx, isl_error_invalid,
621 "cannot insert dimensions of specified type",
624 isl_assert(dim->ctx, pos <= isl_dim_size(dim, type), goto error);
626 dim = isl_dim_cow(dim);
634 int *size = s - isl_dim_param;
635 ids = isl_calloc_array(dim->ctx, isl_id *,
636 dim->nparam + dim->n_in + dim->n_out + n);
640 size[isl_dim_param] = dim->nparam;
641 size[isl_dim_in] = dim->n_in;
642 size[isl_dim_out] = dim->n_out;
643 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
645 get_ids(dim, t, 0, size[t], ids + off);
648 get_ids(dim, t, 0, pos, ids + off);
650 get_ids(dim, t, pos, size[t] - pos, ids + off);
651 off += size[t] - pos;
656 dim->n_id = dim->nparam + dim->n_in + dim->n_out + n;
659 case isl_dim_param: dim->nparam += n; break;
660 case isl_dim_in: dim->n_in += n; break;
661 case isl_dim_out: dim->n_out += n; break;
664 dim = isl_dim_reset(dim, type);
672 __isl_give isl_dim *isl_dim_move(__isl_take isl_dim *dim,
673 enum isl_dim_type dst_type, unsigned dst_pos,
674 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
683 isl_assert(dim->ctx, src_pos + n <= isl_dim_size(dim, src_type),
686 if (dst_type == src_type && dst_pos == src_pos)
689 isl_assert(dim->ctx, dst_type != src_type, goto error);
691 dim = isl_dim_reset(dim, src_type);
692 dim = isl_dim_reset(dim, dst_type);
694 dim = isl_dim_cow(dim);
703 int *size = s - isl_dim_param;
704 ids = isl_calloc_array(dim->ctx, isl_id *,
705 dim->nparam + dim->n_in + dim->n_out);
709 size[isl_dim_param] = dim->nparam;
710 size[isl_dim_in] = dim->n_in;
711 size[isl_dim_out] = dim->n_out;
712 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
714 get_ids(dim, t, 0, dst_pos, ids + off);
716 get_ids(dim, src_type, src_pos, n, ids + off);
718 get_ids(dim, t, dst_pos, size[t] - dst_pos,
720 off += size[t] - dst_pos;
721 } else if (t == src_type) {
722 get_ids(dim, t, 0, src_pos, ids + off);
724 get_ids(dim, t, src_pos + n,
725 size[t] - src_pos - n, ids + off);
726 off += size[t] - src_pos - n;
728 get_ids(dim, t, 0, size[t], ids + off);
734 dim->n_id = dim->nparam + dim->n_in + dim->n_out;
738 case isl_dim_param: dim->nparam += n; break;
739 case isl_dim_in: dim->n_in += n; break;
740 case isl_dim_out: dim->n_out += n; break;
745 case isl_dim_param: dim->nparam -= n; break;
746 case isl_dim_in: dim->n_in -= n; break;
747 case isl_dim_out: dim->n_out -= n; break;
751 if (dst_type != isl_dim_param && src_type != isl_dim_param)
754 for (i = 0; i < 2; ++i) {
757 dim->nested[i] = isl_dim_replace(dim->nested[i],
769 struct isl_dim *isl_dim_join(struct isl_dim *left, struct isl_dim *right)
776 isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
778 isl_assert(left->ctx,
779 isl_dim_tuple_match(left, isl_dim_out, right, isl_dim_in),
782 dim = isl_dim_alloc(left->ctx, left->nparam, left->n_in, right->n_out);
786 dim = copy_ids(dim, isl_dim_param, 0, left, isl_dim_param);
787 dim = copy_ids(dim, isl_dim_in, 0, left, isl_dim_in);
788 dim = copy_ids(dim, isl_dim_out, 0, right, isl_dim_out);
790 if (dim && left->tuple_id[0] &&
791 !(dim->tuple_id[0] = isl_id_copy(left->tuple_id[0])))
793 if (dim && right->tuple_id[1] &&
794 !(dim->tuple_id[1] = isl_id_copy(right->tuple_id[1])))
796 if (dim && left->nested[0] &&
797 !(dim->nested[0] = isl_dim_copy(left->nested[0])))
799 if (dim && right->nested[1] &&
800 !(dim->nested[1] = isl_dim_copy(right->nested[1])))
813 struct isl_dim *isl_dim_product(struct isl_dim *left, struct isl_dim *right)
815 isl_dim *dom1, *dom2, *nest1, *nest2;
820 isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
823 dom1 = isl_dim_domain(isl_dim_copy(left));
824 dom2 = isl_dim_domain(isl_dim_copy(right));
825 nest1 = isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1), dom2));
827 dom1 = isl_dim_range(left);
828 dom2 = isl_dim_range(right);
829 nest2 = isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1), dom2));
831 return isl_dim_join(isl_dim_reverse(nest1), nest2);
838 __isl_give isl_dim *isl_dim_range_product(__isl_take isl_dim *left,
839 __isl_take isl_dim *right)
841 isl_dim *dom, *ran1, *ran2, *nest;
846 isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
848 if (!isl_dim_tuple_match(left, isl_dim_in, right, isl_dim_in))
849 isl_die(left->ctx, isl_error_invalid,
850 "domains need to match", goto error);
852 dom = isl_dim_domain(isl_dim_copy(left));
854 ran1 = isl_dim_range(left);
855 ran2 = isl_dim_range(right);
856 nest = isl_dim_wrap(isl_dim_join(isl_dim_reverse(ran1), ran2));
858 return isl_dim_join(isl_dim_reverse(dom), nest);
865 __isl_give isl_dim *isl_dim_map_from_set(__isl_take isl_dim *dim)
871 isl_assert(dim->ctx, dim->n_in == 0, goto error);
872 if (dim->n_out == 0 && !isl_dim_is_named_or_nested(dim, isl_dim_out))
874 dim = isl_dim_cow(dim);
878 ids = isl_calloc_array(dim->ctx, isl_id *,
879 dim->nparam + dim->n_out + dim->n_out);
882 get_ids(dim, isl_dim_param, 0, dim->nparam, ids);
883 get_ids(dim, isl_dim_out, 0, dim->n_out, ids + dim->nparam);
885 dim->n_in = dim->n_out;
889 dim->n_id = dim->nparam + dim->n_out + dim->n_out;
890 dim = copy_ids(dim, isl_dim_out, 0, dim, isl_dim_in);
892 isl_id_free(dim->tuple_id[0]);
893 dim->tuple_id[0] = isl_id_copy(dim->tuple_id[1]);
894 isl_dim_free(dim->nested[0]);
895 dim->nested[0] = isl_dim_copy(dim->nested[1]);
902 static __isl_give isl_dim *set_ids(struct isl_dim *dim, enum isl_dim_type type,
903 unsigned first, unsigned n, __isl_take isl_id **ids)
907 for (i = 0; i < n ; ++i)
908 dim = set_id(dim, type, first + i, ids[i]);
913 struct isl_dim *isl_dim_reverse(struct isl_dim *dim)
922 if (match(dim, isl_dim_in, dim, isl_dim_out))
925 dim = isl_dim_cow(dim);
929 id = dim->tuple_id[0];
930 dim->tuple_id[0] = dim->tuple_id[1];
931 dim->tuple_id[1] = id;
933 nested = dim->nested[0];
934 dim->nested[0] = dim->nested[1];
935 dim->nested[1] = nested;
938 ids = isl_alloc_array(dim->ctx, isl_id *,
939 dim->n_in + dim->n_out);
942 get_ids(dim, isl_dim_in, 0, dim->n_in, ids);
943 get_ids(dim, isl_dim_out, 0, dim->n_out, ids + dim->n_in);
947 dim->n_in = dim->n_out;
951 dim = set_ids(dim, isl_dim_out, 0, dim->n_out, ids);
952 dim = set_ids(dim, isl_dim_in, 0, dim->n_in, ids + dim->n_out);
963 struct isl_dim *isl_dim_drop(struct isl_dim *dim, enum isl_dim_type type,
964 unsigned first, unsigned num)
972 return isl_dim_reset(dim, type);
974 if (!valid_dim_type(type))
975 isl_die(dim->ctx, isl_error_invalid,
976 "cannot drop dimensions of specified type", goto error);
978 isl_assert(dim->ctx, first + num <= n(dim, type), goto error);
979 dim = isl_dim_cow(dim);
983 dim = extend_ids(dim);
986 for (i = 0; i < num; ++i)
987 isl_id_free(get_id(dim, type, first + i));
988 for (i = first+num; i < n(dim, type); ++i)
989 set_id(dim, type, i - num, get_id(dim, type, i));
992 get_ids(dim, isl_dim_in, 0, dim->n_in,
993 dim->ids + offset(dim, isl_dim_in) - num);
995 get_ids(dim, isl_dim_out, 0, dim->n_out,
996 dim->ids + offset(dim, isl_dim_out) - num);
1003 case isl_dim_param: dim->nparam -= num; break;
1004 case isl_dim_in: dim->n_in -= num; break;
1005 case isl_dim_out: dim->n_out -= num; break;
1008 dim = isl_dim_reset(dim, type);
1009 if (type == isl_dim_param) {
1010 if (dim && dim->nested[0] &&
1011 !(dim->nested[0] = isl_dim_drop(dim->nested[0],
1012 isl_dim_param, first, num)))
1014 if (dim && dim->nested[1] &&
1015 !(dim->nested[1] = isl_dim_drop(dim->nested[1],
1016 isl_dim_param, first, num)))
1025 struct isl_dim *isl_dim_drop_inputs(struct isl_dim *dim,
1026 unsigned first, unsigned n)
1030 return isl_dim_drop(dim, isl_dim_in, first, n);
1033 struct isl_dim *isl_dim_drop_outputs(struct isl_dim *dim,
1034 unsigned first, unsigned n)
1038 return isl_dim_drop(dim, isl_dim_out, first, n);
1041 struct isl_dim *isl_dim_domain(struct isl_dim *dim)
1045 dim = isl_dim_drop_outputs(dim, 0, dim->n_out);
1046 return isl_dim_reverse(dim);
1049 __isl_give isl_dim *isl_dim_from_domain(__isl_take isl_dim *dim)
1051 return isl_dim_reverse(dim);
1054 struct isl_dim *isl_dim_range(struct isl_dim *dim)
1058 return isl_dim_drop_inputs(dim, 0, dim->n_in);
1061 __isl_give isl_dim *isl_dim_from_range(__isl_take isl_dim *dim)
1066 __isl_give isl_dim *isl_dim_as_set_dim(__isl_take isl_dim *dim)
1068 dim = isl_dim_cow(dim);
1072 dim->n_out += dim->n_in;
1074 dim = isl_dim_reset(dim, isl_dim_in);
1075 dim = isl_dim_reset(dim, isl_dim_out);
1080 struct isl_dim *isl_dim_underlying(struct isl_dim *dim, unsigned n_div)
1087 dim->nparam == 0 && dim->n_in == 0 && dim->n_id == 0)
1088 return isl_dim_reset(isl_dim_reset(dim, isl_dim_in), isl_dim_out);
1089 dim = isl_dim_cow(dim);
1092 dim->n_out += dim->nparam + dim->n_in + n_div;
1096 for (i = 0; i < dim->n_id; ++i)
1097 isl_id_free(get_id(dim, isl_dim_out, i));
1099 dim = isl_dim_reset(dim, isl_dim_in);
1100 dim = isl_dim_reset(dim, isl_dim_out);
1105 unsigned isl_dim_total(struct isl_dim *dim)
1107 return dim ? dim->nparam + dim->n_in + dim->n_out : 0;
1110 int isl_dim_equal(struct isl_dim *dim1, struct isl_dim *dim2)
1114 return match(dim1, isl_dim_param, dim2, isl_dim_param) &&
1115 isl_dim_tuple_match(dim1, isl_dim_in, dim2, isl_dim_in) &&
1116 isl_dim_tuple_match(dim1, isl_dim_out, dim2, isl_dim_out);
1119 int isl_dim_compatible(struct isl_dim *dim1, struct isl_dim *dim2)
1121 return dim1->nparam == dim2->nparam &&
1122 dim1->n_in + dim1->n_out == dim2->n_in + dim2->n_out;
1125 static uint32_t isl_hash_dim(uint32_t hash, __isl_keep isl_dim *dim)
1133 hash = isl_hash_builtin(hash, dim->nparam);
1134 hash = isl_hash_builtin(hash, dim->n_in);
1135 hash = isl_hash_builtin(hash, dim->n_out);
1137 for (i = 0; i < dim->nparam; ++i) {
1138 id = get_id(dim, isl_dim_param, i);
1139 hash = isl_hash_id(hash, id);
1142 id = tuple_id(dim, isl_dim_in);
1143 hash = isl_hash_id(hash, id);
1144 id = tuple_id(dim, isl_dim_out);
1145 hash = isl_hash_id(hash, id);
1147 hash = isl_hash_dim(hash, dim->nested[0]);
1148 hash = isl_hash_dim(hash, dim->nested[1]);
1153 uint32_t isl_dim_get_hash(__isl_keep isl_dim *dim)
1160 hash = isl_hash_init();
1161 hash = isl_hash_dim(hash, dim);
1166 int isl_dim_is_wrapping(__isl_keep isl_dim *dim)
1171 if (dim->n_in != 0 || dim->tuple_id[0] || dim->nested[0])
1174 return dim->nested[1] != NULL;
1177 __isl_give isl_dim *isl_dim_wrap(__isl_take isl_dim *dim)
1184 wrap = isl_dim_alloc(dim->ctx, dim->nparam, 0, dim->n_in + dim->n_out);
1186 wrap = copy_ids(wrap, isl_dim_param, 0, dim, isl_dim_param);
1187 wrap = copy_ids(wrap, isl_dim_set, 0, dim, isl_dim_in);
1188 wrap = copy_ids(wrap, isl_dim_set, dim->n_in, dim, isl_dim_out);
1193 wrap->nested[1] = dim;
1201 __isl_give isl_dim *isl_dim_unwrap(__isl_take isl_dim *dim)
1208 if (!isl_dim_is_wrapping(dim))
1209 isl_die(dim->ctx, isl_error_invalid, "not a wrapping dim",
1212 unwrap = isl_dim_copy(dim->nested[1]);
1221 int isl_dim_is_named_or_nested(__isl_keep isl_dim *dim, enum isl_dim_type type)
1223 if (type != isl_dim_in && type != isl_dim_out)
1227 if (dim->tuple_id[type - isl_dim_in])
1229 if (dim->nested[type - isl_dim_in])
1234 int isl_dim_may_be_set(__isl_keep isl_dim *dim)
1238 if (isl_dim_size(dim, isl_dim_in) != 0)
1240 if (isl_dim_is_named_or_nested(dim, isl_dim_in))
1245 __isl_give isl_dim *isl_dim_reset(__isl_take isl_dim *dim,
1246 enum isl_dim_type type)
1248 if (!isl_dim_is_named_or_nested(dim, type))
1251 dim = isl_dim_cow(dim);
1255 isl_id_free(dim->tuple_id[type - isl_dim_in]);
1256 dim->tuple_id[type - isl_dim_in] = NULL;
1257 isl_dim_free(dim->nested[type - isl_dim_in]);
1258 dim->nested[type - isl_dim_in] = NULL;
1263 __isl_give isl_dim *isl_dim_flatten(__isl_take isl_dim *dim)
1267 if (!dim->nested[0] && !dim->nested[1])
1271 dim = isl_dim_reset(dim, isl_dim_in);
1272 if (dim && dim->nested[1])
1273 dim = isl_dim_reset(dim, isl_dim_out);
1278 __isl_give isl_dim *isl_dim_flatten_range(__isl_take isl_dim *dim)
1282 if (!dim->nested[1])
1285 return isl_dim_reset(dim, isl_dim_out);
1288 /* Replace the dimensions of the given type of dst by those of src.
1290 __isl_give isl_dim *isl_dim_replace(__isl_take isl_dim *dst,
1291 enum isl_dim_type type, __isl_keep isl_dim *src)
1293 dst = isl_dim_cow(dst);
1298 dst = isl_dim_drop(dst, type, 0, isl_dim_size(dst, type));
1299 dst = isl_dim_add(dst, type, isl_dim_size(src, type));
1300 dst = copy_ids(dst, type, 0, src, type);
1302 if (dst && type == isl_dim_param) {
1304 for (i = 0; i <= 1; ++i) {
1305 if (!dst->nested[i])
1307 dst->nested[i] = isl_dim_replace(dst->nested[i],
1309 if (!dst->nested[i])
1320 /* Given a dimension specification "dim" of a set, create a dimension
1321 * specification for the lift of the set. In particular, the result
1322 * is of the form [dim -> local[..]], with n_local variables in the
1323 * range of the wrapped map.
1325 __isl_give isl_dim *isl_dim_lift(__isl_take isl_dim *dim, unsigned n_local)
1332 local_dim = isl_dim_dup(dim);
1333 local_dim = isl_dim_drop(local_dim, isl_dim_set, 0, dim->n_out);
1334 local_dim = isl_dim_add(local_dim, isl_dim_set, n_local);
1335 local_dim = isl_dim_set_tuple_name(local_dim, isl_dim_set, "local");
1336 dim = isl_dim_join(isl_dim_from_domain(dim),
1337 isl_dim_from_range(local_dim));
1338 dim = isl_dim_wrap(dim);
1339 dim = isl_dim_set_tuple_name(dim, isl_dim_set, "lifted");
1344 int isl_dim_can_zip(__isl_keep isl_dim *dim)
1349 return dim->nested[0] && dim->nested[1];
1352 __isl_give isl_dim *isl_dim_zip(__isl_take isl_dim *dim)
1355 isl_dim *dom_dom, *dom_ran, *ran_dom, *ran_ran;
1357 if (!isl_dim_can_zip(dim))
1358 isl_die(dim->ctx, isl_error_invalid, "dim cannot be zipped",
1363 dom = isl_dim_unwrap(isl_dim_domain(isl_dim_copy(dim)));
1364 ran = isl_dim_unwrap(isl_dim_range(dim));
1365 dom_dom = isl_dim_domain(isl_dim_copy(dom));
1366 dom_ran = isl_dim_range(dom);
1367 ran_dom = isl_dim_domain(isl_dim_copy(ran));
1368 ran_ran = isl_dim_range(ran);
1369 dom = isl_dim_join(isl_dim_from_domain(dom_dom),
1370 isl_dim_from_range(ran_dom));
1371 ran = isl_dim_join(isl_dim_from_domain(dom_ran),
1372 isl_dim_from_range(ran_ran));
1373 return isl_dim_join(isl_dim_from_domain(isl_dim_wrap(dom)),
1374 isl_dim_from_range(isl_dim_wrap(ran)));
1380 int isl_dim_has_named_params(__isl_keep isl_dim *dim)
1387 if (dim->nparam == 0)
1389 off = isl_dim_offset(dim, isl_dim_param);
1390 if (off + dim->nparam > dim->n_id)
1392 for (i = 0; i < dim->nparam; ++i)
1393 if (!dim->ids[off + i])
1398 /* Align the initial parameters of dim1 to match the order in dim2.
1400 __isl_give isl_dim *isl_dim_align_params(__isl_take isl_dim *dim1,
1401 __isl_take isl_dim *dim2)
1403 isl_reordering *exp;
1405 if (!isl_dim_has_named_params(dim1) || !isl_dim_has_named_params(dim2))
1406 isl_die(isl_dim_get_ctx(dim1), isl_error_invalid,
1407 "parameter alignment requires named parameters",
1410 exp = isl_parameter_alignment_reordering(dim1, dim2);
1415 dim1 = isl_dim_copy(exp->dim);
1416 isl_reordering_free(exp);