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 int isl_dim_has_tuple_id(__isl_keep isl_dim *dim, enum isl_dim_type type)
298 if (type != isl_dim_in && type != isl_dim_out)
299 isl_die(dim->ctx, isl_error_invalid,
300 "only input, output and set tuples can have ids",
302 return dim->tuple_id[type - isl_dim_in] != NULL;
305 __isl_give isl_id *isl_dim_get_tuple_id(__isl_keep isl_dim *dim,
306 enum isl_dim_type type)
310 if (type != isl_dim_in && type != isl_dim_out)
312 return isl_id_copy(dim->tuple_id[type - isl_dim_in]);
315 __isl_give isl_dim *isl_dim_set_tuple_id(__isl_take isl_dim *dim,
316 enum isl_dim_type type, __isl_take isl_id *id)
318 dim = isl_dim_cow(dim);
321 if (type != isl_dim_in && type != isl_dim_out)
322 isl_die(dim->ctx, isl_error_invalid,
323 "only input, output and set tuples can have names",
326 isl_id_free(dim->tuple_id[type - isl_dim_in]);
327 dim->tuple_id[type - isl_dim_in] = id;
336 __isl_give isl_dim *isl_dim_reset_tuple_id(__isl_take isl_dim *dim,
337 enum isl_dim_type type)
339 dim = isl_dim_cow(dim);
342 if (type != isl_dim_in && type != isl_dim_out)
343 isl_die(dim->ctx, isl_error_invalid,
344 "only input, output and set tuples can have names",
347 isl_id_free(dim->tuple_id[type - isl_dim_in]);
348 dim->tuple_id[type - isl_dim_in] = NULL;
356 __isl_give isl_dim *isl_dim_set_dim_id(__isl_take isl_dim *dim,
357 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
359 dim = isl_dim_cow(dim);
362 isl_id_free(get_id(dim, type, pos));
363 return set_id(dim, type, pos, id);
370 int isl_dim_has_dim_id(__isl_keep isl_dim *dim,
371 enum isl_dim_type type, unsigned pos)
375 return get_id(dim, type, pos) != NULL;
378 __isl_give isl_id *isl_dim_get_dim_id(__isl_keep isl_dim *dim,
379 enum isl_dim_type type, unsigned pos)
383 if (!get_id(dim, type, pos))
384 isl_die(dim->ctx, isl_error_invalid,
385 "dim has no id", return NULL);
386 return isl_id_copy(get_id(dim, type, pos));
389 __isl_give isl_dim *isl_dim_set_tuple_name(__isl_take isl_dim *dim,
390 enum isl_dim_type type, const char *s)
398 return isl_dim_reset_tuple_id(dim, type);
400 if (!name_ok(dim->ctx, s))
403 id = isl_id_alloc(dim->ctx, s, NULL);
404 return isl_dim_set_tuple_id(dim, type, id);
410 const char *isl_dim_get_tuple_name(__isl_keep isl_dim *dim,
411 enum isl_dim_type type)
416 if (type != isl_dim_in && type != isl_dim_out)
418 id = dim->tuple_id[type - isl_dim_in];
419 return id ? id->name : NULL;
422 struct isl_dim *isl_dim_set_name(struct isl_dim *dim,
423 enum isl_dim_type type, unsigned pos,
430 if (!name_ok(dim->ctx, s))
432 id = isl_id_alloc(dim->ctx, s, NULL);
433 return isl_dim_set_dim_id(dim, type, pos, id);
439 const char *isl_dim_get_name(struct isl_dim *dim,
440 enum isl_dim_type type, unsigned pos)
442 isl_id *id = get_id(dim, type, pos);
443 return id ? id->name : NULL;
446 int isl_dim_find_dim_by_id(__isl_keep isl_dim *dim, enum isl_dim_type type,
447 __isl_keep isl_id *id)
456 offset = isl_dim_offset(dim, type);
457 n = isl_dim_size(dim, type);
458 for (i = 0; i < n && offset + i < dim->n_id; ++i)
459 if (dim->ids[offset + i] == id)
465 static __isl_keep isl_id *tuple_id(__isl_keep isl_dim *dim,
466 enum isl_dim_type type)
470 if (type == isl_dim_in)
471 return dim->tuple_id[0];
472 if (type == isl_dim_out)
473 return dim->tuple_id[1];
477 static __isl_keep isl_dim *nested(__isl_keep isl_dim *dim,
478 enum isl_dim_type type)
482 if (type == isl_dim_in)
483 return dim->nested[0];
484 if (type == isl_dim_out)
485 return dim->nested[1];
489 int isl_dim_tuple_match(__isl_keep isl_dim *dim1, enum isl_dim_type dim1_type,
490 __isl_keep isl_dim *dim2, enum isl_dim_type dim2_type)
493 isl_dim *nested1, *nested2;
498 if (n(dim1, dim1_type) != n(dim2, dim2_type))
500 id1 = tuple_id(dim1, dim1_type);
501 id2 = tuple_id(dim2, dim2_type);
504 if (id1 && id1 != id2)
506 nested1 = nested(dim1, dim1_type);
507 nested2 = nested(dim2, dim2_type);
508 if (!nested1 ^ !nested2)
510 if (nested1 && !isl_dim_equal(nested1, nested2))
515 static int match(struct isl_dim *dim1, enum isl_dim_type dim1_type,
516 struct isl_dim *dim2, enum isl_dim_type dim2_type)
520 if (!isl_dim_tuple_match(dim1, dim1_type, dim2, dim2_type))
523 if (!dim1->ids && !dim2->ids)
526 for (i = 0; i < n(dim1, dim1_type); ++i) {
527 if (get_id(dim1, dim1_type, i) != get_id(dim2, dim2_type, i))
533 int isl_dim_match(struct isl_dim *dim1, enum isl_dim_type dim1_type,
534 struct isl_dim *dim2, enum isl_dim_type dim2_type)
536 return match(dim1, dim1_type, dim2, dim2_type);
539 static void get_ids(struct isl_dim *dim, enum isl_dim_type type,
540 unsigned first, unsigned n, __isl_keep isl_id **ids)
544 for (i = 0; i < n ; ++i)
545 ids[i] = get_id(dim, type, first + i);
548 struct isl_dim *isl_dim_extend(struct isl_dim *dim,
549 unsigned nparam, unsigned n_in, unsigned n_out)
555 if (dim->nparam == nparam && dim->n_in == n_in && dim->n_out == n_out)
558 isl_assert(dim->ctx, dim->nparam <= nparam, goto error);
559 isl_assert(dim->ctx, dim->n_in <= n_in, goto error);
560 isl_assert(dim->ctx, dim->n_out <= n_out, goto error);
562 dim = isl_dim_cow(dim);
565 ids = isl_calloc_array(dim->ctx, isl_id *,
566 nparam + n_in + n_out);
569 get_ids(dim, isl_dim_param, 0, dim->nparam, ids);
570 get_ids(dim, isl_dim_in, 0, dim->n_in, ids + nparam);
571 get_ids(dim, isl_dim_out, 0, dim->n_out, ids + nparam + n_in);
574 dim->n_id = nparam + n_in + n_out;
576 dim->nparam = nparam;
587 struct isl_dim *isl_dim_add(struct isl_dim *dim, enum isl_dim_type type,
592 dim = isl_dim_reset(dim, type);
595 dim = isl_dim_extend(dim,
596 dim->nparam + n, dim->n_in, dim->n_out);
597 if (dim && dim->nested[0] &&
598 !(dim->nested[0] = isl_dim_add(dim->nested[0],
601 if (dim && dim->nested[1] &&
602 !(dim->nested[1] = isl_dim_add(dim->nested[1],
607 return isl_dim_extend(dim,
608 dim->nparam, dim->n_in + n, dim->n_out);
610 return isl_dim_extend(dim,
611 dim->nparam, dim->n_in, dim->n_out + n);
613 isl_die(dim->ctx, isl_error_invalid,
614 "cannot add dimensions of specified type", goto error);
621 static int valid_dim_type(enum isl_dim_type type)
633 __isl_give isl_dim *isl_dim_insert(__isl_take isl_dim *dim,
634 enum isl_dim_type type, unsigned pos, unsigned n)
641 return isl_dim_reset(dim, type);
643 if (!valid_dim_type(type))
644 isl_die(dim->ctx, isl_error_invalid,
645 "cannot insert dimensions of specified type",
648 isl_assert(dim->ctx, pos <= isl_dim_size(dim, type), goto error);
650 dim = isl_dim_cow(dim);
658 int *size = s - isl_dim_param;
659 ids = isl_calloc_array(dim->ctx, isl_id *,
660 dim->nparam + dim->n_in + dim->n_out + n);
664 size[isl_dim_param] = dim->nparam;
665 size[isl_dim_in] = dim->n_in;
666 size[isl_dim_out] = dim->n_out;
667 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
669 get_ids(dim, t, 0, size[t], ids + off);
672 get_ids(dim, t, 0, pos, ids + off);
674 get_ids(dim, t, pos, size[t] - pos, ids + off);
675 off += size[t] - pos;
680 dim->n_id = dim->nparam + dim->n_in + dim->n_out + n;
683 case isl_dim_param: dim->nparam += n; break;
684 case isl_dim_in: dim->n_in += n; break;
685 case isl_dim_out: dim->n_out += n; break;
688 dim = isl_dim_reset(dim, type);
696 __isl_give isl_dim *isl_dim_move(__isl_take isl_dim *dim,
697 enum isl_dim_type dst_type, unsigned dst_pos,
698 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
707 isl_assert(dim->ctx, src_pos + n <= isl_dim_size(dim, src_type),
710 if (dst_type == src_type && dst_pos == src_pos)
713 isl_assert(dim->ctx, dst_type != src_type, goto error);
715 dim = isl_dim_reset(dim, src_type);
716 dim = isl_dim_reset(dim, dst_type);
718 dim = isl_dim_cow(dim);
727 int *size = s - isl_dim_param;
728 ids = isl_calloc_array(dim->ctx, isl_id *,
729 dim->nparam + dim->n_in + dim->n_out);
733 size[isl_dim_param] = dim->nparam;
734 size[isl_dim_in] = dim->n_in;
735 size[isl_dim_out] = dim->n_out;
736 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
738 get_ids(dim, t, 0, dst_pos, ids + off);
740 get_ids(dim, src_type, src_pos, n, ids + off);
742 get_ids(dim, t, dst_pos, size[t] - dst_pos,
744 off += size[t] - dst_pos;
745 } else if (t == src_type) {
746 get_ids(dim, t, 0, src_pos, ids + off);
748 get_ids(dim, t, src_pos + n,
749 size[t] - src_pos - n, ids + off);
750 off += size[t] - src_pos - n;
752 get_ids(dim, t, 0, size[t], ids + off);
758 dim->n_id = dim->nparam + dim->n_in + dim->n_out;
762 case isl_dim_param: dim->nparam += n; break;
763 case isl_dim_in: dim->n_in += n; break;
764 case isl_dim_out: dim->n_out += n; break;
769 case isl_dim_param: dim->nparam -= n; break;
770 case isl_dim_in: dim->n_in -= n; break;
771 case isl_dim_out: dim->n_out -= n; break;
775 if (dst_type != isl_dim_param && src_type != isl_dim_param)
778 for (i = 0; i < 2; ++i) {
781 dim->nested[i] = isl_dim_replace(dim->nested[i],
793 struct isl_dim *isl_dim_join(struct isl_dim *left, struct isl_dim *right)
800 isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
802 isl_assert(left->ctx,
803 isl_dim_tuple_match(left, isl_dim_out, right, isl_dim_in),
806 dim = isl_dim_alloc(left->ctx, left->nparam, left->n_in, right->n_out);
810 dim = copy_ids(dim, isl_dim_param, 0, left, isl_dim_param);
811 dim = copy_ids(dim, isl_dim_in, 0, left, isl_dim_in);
812 dim = copy_ids(dim, isl_dim_out, 0, right, isl_dim_out);
814 if (dim && left->tuple_id[0] &&
815 !(dim->tuple_id[0] = isl_id_copy(left->tuple_id[0])))
817 if (dim && right->tuple_id[1] &&
818 !(dim->tuple_id[1] = isl_id_copy(right->tuple_id[1])))
820 if (dim && left->nested[0] &&
821 !(dim->nested[0] = isl_dim_copy(left->nested[0])))
823 if (dim && right->nested[1] &&
824 !(dim->nested[1] = isl_dim_copy(right->nested[1])))
837 struct isl_dim *isl_dim_product(struct isl_dim *left, struct isl_dim *right)
839 isl_dim *dom1, *dom2, *nest1, *nest2;
844 isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
847 dom1 = isl_dim_domain(isl_dim_copy(left));
848 dom2 = isl_dim_domain(isl_dim_copy(right));
849 nest1 = isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1), dom2));
851 dom1 = isl_dim_range(left);
852 dom2 = isl_dim_range(right);
853 nest2 = isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1), dom2));
855 return isl_dim_join(isl_dim_reverse(nest1), nest2);
862 __isl_give isl_dim *isl_dim_range_product(__isl_take isl_dim *left,
863 __isl_take isl_dim *right)
865 isl_dim *dom, *ran1, *ran2, *nest;
870 isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
872 if (!isl_dim_tuple_match(left, isl_dim_in, right, isl_dim_in))
873 isl_die(left->ctx, isl_error_invalid,
874 "domains need to match", goto error);
876 dom = isl_dim_domain(isl_dim_copy(left));
878 ran1 = isl_dim_range(left);
879 ran2 = isl_dim_range(right);
880 nest = isl_dim_wrap(isl_dim_join(isl_dim_reverse(ran1), ran2));
882 return isl_dim_join(isl_dim_reverse(dom), nest);
889 __isl_give isl_dim *isl_dim_map_from_set(__isl_take isl_dim *dim)
895 isl_assert(dim->ctx, dim->n_in == 0, goto error);
896 if (dim->n_out == 0 && !isl_dim_is_named_or_nested(dim, isl_dim_out))
898 dim = isl_dim_cow(dim);
902 ids = isl_calloc_array(dim->ctx, isl_id *,
903 dim->nparam + dim->n_out + dim->n_out);
906 get_ids(dim, isl_dim_param, 0, dim->nparam, ids);
907 get_ids(dim, isl_dim_out, 0, dim->n_out, ids + dim->nparam);
909 dim->n_in = dim->n_out;
913 dim->n_id = dim->nparam + dim->n_out + dim->n_out;
914 dim = copy_ids(dim, isl_dim_out, 0, dim, isl_dim_in);
916 isl_id_free(dim->tuple_id[0]);
917 dim->tuple_id[0] = isl_id_copy(dim->tuple_id[1]);
918 isl_dim_free(dim->nested[0]);
919 dim->nested[0] = isl_dim_copy(dim->nested[1]);
926 static __isl_give isl_dim *set_ids(struct isl_dim *dim, enum isl_dim_type type,
927 unsigned first, unsigned n, __isl_take isl_id **ids)
931 for (i = 0; i < n ; ++i)
932 dim = set_id(dim, type, first + i, ids[i]);
937 struct isl_dim *isl_dim_reverse(struct isl_dim *dim)
946 if (match(dim, isl_dim_in, dim, isl_dim_out))
949 dim = isl_dim_cow(dim);
953 id = dim->tuple_id[0];
954 dim->tuple_id[0] = dim->tuple_id[1];
955 dim->tuple_id[1] = id;
957 nested = dim->nested[0];
958 dim->nested[0] = dim->nested[1];
959 dim->nested[1] = nested;
962 ids = isl_alloc_array(dim->ctx, isl_id *,
963 dim->n_in + dim->n_out);
966 get_ids(dim, isl_dim_in, 0, dim->n_in, ids);
967 get_ids(dim, isl_dim_out, 0, dim->n_out, ids + dim->n_in);
971 dim->n_in = dim->n_out;
975 dim = set_ids(dim, isl_dim_out, 0, dim->n_out, ids);
976 dim = set_ids(dim, isl_dim_in, 0, dim->n_in, ids + dim->n_out);
987 struct isl_dim *isl_dim_drop(struct isl_dim *dim, enum isl_dim_type type,
988 unsigned first, unsigned num)
996 return isl_dim_reset(dim, type);
998 if (!valid_dim_type(type))
999 isl_die(dim->ctx, isl_error_invalid,
1000 "cannot drop dimensions of specified type", goto error);
1002 isl_assert(dim->ctx, first + num <= n(dim, type), goto error);
1003 dim = isl_dim_cow(dim);
1007 dim = extend_ids(dim);
1010 for (i = 0; i < num; ++i)
1011 isl_id_free(get_id(dim, type, first + i));
1012 for (i = first+num; i < n(dim, type); ++i)
1013 set_id(dim, type, i - num, get_id(dim, type, i));
1016 get_ids(dim, isl_dim_in, 0, dim->n_in,
1017 dim->ids + offset(dim, isl_dim_in) - num);
1019 get_ids(dim, isl_dim_out, 0, dim->n_out,
1020 dim->ids + offset(dim, isl_dim_out) - num);
1027 case isl_dim_param: dim->nparam -= num; break;
1028 case isl_dim_in: dim->n_in -= num; break;
1029 case isl_dim_out: dim->n_out -= num; break;
1032 dim = isl_dim_reset(dim, type);
1033 if (type == isl_dim_param) {
1034 if (dim && dim->nested[0] &&
1035 !(dim->nested[0] = isl_dim_drop(dim->nested[0],
1036 isl_dim_param, first, num)))
1038 if (dim && dim->nested[1] &&
1039 !(dim->nested[1] = isl_dim_drop(dim->nested[1],
1040 isl_dim_param, first, num)))
1049 struct isl_dim *isl_dim_drop_inputs(struct isl_dim *dim,
1050 unsigned first, unsigned n)
1054 return isl_dim_drop(dim, isl_dim_in, first, n);
1057 struct isl_dim *isl_dim_drop_outputs(struct isl_dim *dim,
1058 unsigned first, unsigned n)
1062 return isl_dim_drop(dim, isl_dim_out, first, n);
1065 struct isl_dim *isl_dim_domain(struct isl_dim *dim)
1069 dim = isl_dim_drop_outputs(dim, 0, dim->n_out);
1070 return isl_dim_reverse(dim);
1073 __isl_give isl_dim *isl_dim_from_domain(__isl_take isl_dim *dim)
1075 return isl_dim_reverse(dim);
1078 struct isl_dim *isl_dim_range(struct isl_dim *dim)
1082 return isl_dim_drop_inputs(dim, 0, dim->n_in);
1085 __isl_give isl_dim *isl_dim_from_range(__isl_take isl_dim *dim)
1090 __isl_give isl_dim *isl_dim_as_set_dim(__isl_take isl_dim *dim)
1092 dim = isl_dim_cow(dim);
1096 dim->n_out += dim->n_in;
1098 dim = isl_dim_reset(dim, isl_dim_in);
1099 dim = isl_dim_reset(dim, isl_dim_out);
1104 struct isl_dim *isl_dim_underlying(struct isl_dim *dim, unsigned n_div)
1111 dim->nparam == 0 && dim->n_in == 0 && dim->n_id == 0)
1112 return isl_dim_reset(isl_dim_reset(dim, isl_dim_in), isl_dim_out);
1113 dim = isl_dim_cow(dim);
1116 dim->n_out += dim->nparam + dim->n_in + n_div;
1120 for (i = 0; i < dim->n_id; ++i)
1121 isl_id_free(get_id(dim, isl_dim_out, i));
1123 dim = isl_dim_reset(dim, isl_dim_in);
1124 dim = isl_dim_reset(dim, isl_dim_out);
1129 unsigned isl_dim_total(struct isl_dim *dim)
1131 return dim ? dim->nparam + dim->n_in + dim->n_out : 0;
1134 int isl_dim_equal(struct isl_dim *dim1, struct isl_dim *dim2)
1138 return match(dim1, isl_dim_param, dim2, isl_dim_param) &&
1139 isl_dim_tuple_match(dim1, isl_dim_in, dim2, isl_dim_in) &&
1140 isl_dim_tuple_match(dim1, isl_dim_out, dim2, isl_dim_out);
1143 int isl_dim_compatible(struct isl_dim *dim1, struct isl_dim *dim2)
1145 return dim1->nparam == dim2->nparam &&
1146 dim1->n_in + dim1->n_out == dim2->n_in + dim2->n_out;
1149 static uint32_t isl_hash_dim(uint32_t hash, __isl_keep isl_dim *dim)
1157 hash = isl_hash_builtin(hash, dim->nparam);
1158 hash = isl_hash_builtin(hash, dim->n_in);
1159 hash = isl_hash_builtin(hash, dim->n_out);
1161 for (i = 0; i < dim->nparam; ++i) {
1162 id = get_id(dim, isl_dim_param, i);
1163 hash = isl_hash_id(hash, id);
1166 id = tuple_id(dim, isl_dim_in);
1167 hash = isl_hash_id(hash, id);
1168 id = tuple_id(dim, isl_dim_out);
1169 hash = isl_hash_id(hash, id);
1171 hash = isl_hash_dim(hash, dim->nested[0]);
1172 hash = isl_hash_dim(hash, dim->nested[1]);
1177 uint32_t isl_dim_get_hash(__isl_keep isl_dim *dim)
1184 hash = isl_hash_init();
1185 hash = isl_hash_dim(hash, dim);
1190 int isl_dim_is_wrapping(__isl_keep isl_dim *dim)
1195 if (dim->n_in != 0 || dim->tuple_id[0] || dim->nested[0])
1198 return dim->nested[1] != NULL;
1201 __isl_give isl_dim *isl_dim_wrap(__isl_take isl_dim *dim)
1208 wrap = isl_dim_alloc(dim->ctx, dim->nparam, 0, dim->n_in + dim->n_out);
1210 wrap = copy_ids(wrap, isl_dim_param, 0, dim, isl_dim_param);
1211 wrap = copy_ids(wrap, isl_dim_set, 0, dim, isl_dim_in);
1212 wrap = copy_ids(wrap, isl_dim_set, dim->n_in, dim, isl_dim_out);
1217 wrap->nested[1] = dim;
1225 __isl_give isl_dim *isl_dim_unwrap(__isl_take isl_dim *dim)
1232 if (!isl_dim_is_wrapping(dim))
1233 isl_die(dim->ctx, isl_error_invalid, "not a wrapping dim",
1236 unwrap = isl_dim_copy(dim->nested[1]);
1245 int isl_dim_is_named_or_nested(__isl_keep isl_dim *dim, enum isl_dim_type type)
1247 if (type != isl_dim_in && type != isl_dim_out)
1251 if (dim->tuple_id[type - isl_dim_in])
1253 if (dim->nested[type - isl_dim_in])
1258 int isl_dim_may_be_set(__isl_keep isl_dim *dim)
1262 if (isl_dim_size(dim, isl_dim_in) != 0)
1264 if (isl_dim_is_named_or_nested(dim, isl_dim_in))
1269 __isl_give isl_dim *isl_dim_reset(__isl_take isl_dim *dim,
1270 enum isl_dim_type type)
1272 if (!isl_dim_is_named_or_nested(dim, type))
1275 dim = isl_dim_cow(dim);
1279 isl_id_free(dim->tuple_id[type - isl_dim_in]);
1280 dim->tuple_id[type - isl_dim_in] = NULL;
1281 isl_dim_free(dim->nested[type - isl_dim_in]);
1282 dim->nested[type - isl_dim_in] = NULL;
1287 __isl_give isl_dim *isl_dim_flatten(__isl_take isl_dim *dim)
1291 if (!dim->nested[0] && !dim->nested[1])
1295 dim = isl_dim_reset(dim, isl_dim_in);
1296 if (dim && dim->nested[1])
1297 dim = isl_dim_reset(dim, isl_dim_out);
1302 __isl_give isl_dim *isl_dim_flatten_range(__isl_take isl_dim *dim)
1306 if (!dim->nested[1])
1309 return isl_dim_reset(dim, isl_dim_out);
1312 /* Replace the dimensions of the given type of dst by those of src.
1314 __isl_give isl_dim *isl_dim_replace(__isl_take isl_dim *dst,
1315 enum isl_dim_type type, __isl_keep isl_dim *src)
1317 dst = isl_dim_cow(dst);
1322 dst = isl_dim_drop(dst, type, 0, isl_dim_size(dst, type));
1323 dst = isl_dim_add(dst, type, isl_dim_size(src, type));
1324 dst = copy_ids(dst, type, 0, src, type);
1326 if (dst && type == isl_dim_param) {
1328 for (i = 0; i <= 1; ++i) {
1329 if (!dst->nested[i])
1331 dst->nested[i] = isl_dim_replace(dst->nested[i],
1333 if (!dst->nested[i])
1344 /* Given a dimension specification "dim" of a set, create a dimension
1345 * specification for the lift of the set. In particular, the result
1346 * is of the form [dim -> local[..]], with n_local variables in the
1347 * range of the wrapped map.
1349 __isl_give isl_dim *isl_dim_lift(__isl_take isl_dim *dim, unsigned n_local)
1356 local_dim = isl_dim_dup(dim);
1357 local_dim = isl_dim_drop(local_dim, isl_dim_set, 0, dim->n_out);
1358 local_dim = isl_dim_add(local_dim, isl_dim_set, n_local);
1359 local_dim = isl_dim_set_tuple_name(local_dim, isl_dim_set, "local");
1360 dim = isl_dim_join(isl_dim_from_domain(dim),
1361 isl_dim_from_range(local_dim));
1362 dim = isl_dim_wrap(dim);
1363 dim = isl_dim_set_tuple_name(dim, isl_dim_set, "lifted");
1368 int isl_dim_can_zip(__isl_keep isl_dim *dim)
1373 return dim->nested[0] && dim->nested[1];
1376 __isl_give isl_dim *isl_dim_zip(__isl_take isl_dim *dim)
1379 isl_dim *dom_dom, *dom_ran, *ran_dom, *ran_ran;
1381 if (!isl_dim_can_zip(dim))
1382 isl_die(dim->ctx, isl_error_invalid, "dim cannot be zipped",
1387 dom = isl_dim_unwrap(isl_dim_domain(isl_dim_copy(dim)));
1388 ran = isl_dim_unwrap(isl_dim_range(dim));
1389 dom_dom = isl_dim_domain(isl_dim_copy(dom));
1390 dom_ran = isl_dim_range(dom);
1391 ran_dom = isl_dim_domain(isl_dim_copy(ran));
1392 ran_ran = isl_dim_range(ran);
1393 dom = isl_dim_join(isl_dim_from_domain(dom_dom),
1394 isl_dim_from_range(ran_dom));
1395 ran = isl_dim_join(isl_dim_from_domain(dom_ran),
1396 isl_dim_from_range(ran_ran));
1397 return isl_dim_join(isl_dim_from_domain(isl_dim_wrap(dom)),
1398 isl_dim_from_range(isl_dim_wrap(ran)));
1404 int isl_dim_has_named_params(__isl_keep isl_dim *dim)
1411 if (dim->nparam == 0)
1413 off = isl_dim_offset(dim, isl_dim_param);
1414 if (off + dim->nparam > dim->n_id)
1416 for (i = 0; i < dim->nparam; ++i)
1417 if (!dim->ids[off + i])
1422 /* Align the initial parameters of dim1 to match the order in dim2.
1424 __isl_give isl_dim *isl_dim_align_params(__isl_take isl_dim *dim1,
1425 __isl_take isl_dim *dim2)
1427 isl_reordering *exp;
1429 if (!isl_dim_has_named_params(dim1) || !isl_dim_has_named_params(dim2))
1430 isl_die(isl_dim_get_ctx(dim1), isl_error_invalid,
1431 "parameter alignment requires named parameters",
1434 exp = isl_parameter_alignment_reordering(dim1, dim2);
1439 dim1 = isl_dim_copy(exp->dim);
1440 isl_reordering_free(exp);