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)
381 return isl_id_copy(get_id(dim, type, pos));
384 __isl_give isl_dim *isl_dim_set_tuple_name(__isl_take isl_dim *dim,
385 enum isl_dim_type type, const char *s)
393 return isl_dim_reset_tuple_id(dim, type);
395 if (!name_ok(dim->ctx, s))
398 id = isl_id_alloc(dim->ctx, s, NULL);
399 return isl_dim_set_tuple_id(dim, type, id);
405 const char *isl_dim_get_tuple_name(__isl_keep isl_dim *dim,
406 enum isl_dim_type type)
411 if (type != isl_dim_in && type != isl_dim_out)
413 id = dim->tuple_id[type - isl_dim_in];
414 return id ? id->name : NULL;
417 struct isl_dim *isl_dim_set_name(struct isl_dim *dim,
418 enum isl_dim_type type, unsigned pos,
425 if (!name_ok(dim->ctx, s))
427 id = isl_id_alloc(dim->ctx, s, NULL);
428 return isl_dim_set_dim_id(dim, type, pos, id);
434 const char *isl_dim_get_name(struct isl_dim *dim,
435 enum isl_dim_type type, unsigned pos)
437 isl_id *id = get_id(dim, type, pos);
438 return id ? id->name : NULL;
441 int isl_dim_find_dim_by_id(__isl_keep isl_dim *dim, enum isl_dim_type type,
442 __isl_keep isl_id *id)
451 offset = isl_dim_offset(dim, type);
452 n = isl_dim_size(dim, type);
453 for (i = 0; i < n && offset + i < dim->n_id; ++i)
454 if (dim->ids[offset + i] == id)
460 static __isl_keep isl_id *tuple_id(__isl_keep isl_dim *dim,
461 enum isl_dim_type type)
465 if (type == isl_dim_in)
466 return dim->tuple_id[0];
467 if (type == isl_dim_out)
468 return dim->tuple_id[1];
472 static __isl_keep isl_dim *nested(__isl_keep isl_dim *dim,
473 enum isl_dim_type type)
477 if (type == isl_dim_in)
478 return dim->nested[0];
479 if (type == isl_dim_out)
480 return dim->nested[1];
484 int isl_dim_tuple_match(__isl_keep isl_dim *dim1, enum isl_dim_type dim1_type,
485 __isl_keep isl_dim *dim2, enum isl_dim_type dim2_type)
488 isl_dim *nested1, *nested2;
493 if (n(dim1, dim1_type) != n(dim2, dim2_type))
495 id1 = tuple_id(dim1, dim1_type);
496 id2 = tuple_id(dim2, dim2_type);
499 if (id1 && id1 != id2)
501 nested1 = nested(dim1, dim1_type);
502 nested2 = nested(dim2, dim2_type);
503 if (!nested1 ^ !nested2)
505 if (nested1 && !isl_dim_equal(nested1, nested2))
510 static int match(struct isl_dim *dim1, enum isl_dim_type dim1_type,
511 struct isl_dim *dim2, enum isl_dim_type dim2_type)
515 if (!isl_dim_tuple_match(dim1, dim1_type, dim2, dim2_type))
518 if (!dim1->ids && !dim2->ids)
521 for (i = 0; i < n(dim1, dim1_type); ++i) {
522 if (get_id(dim1, dim1_type, i) != get_id(dim2, dim2_type, i))
528 int isl_dim_match(struct isl_dim *dim1, enum isl_dim_type dim1_type,
529 struct isl_dim *dim2, enum isl_dim_type dim2_type)
531 return match(dim1, dim1_type, dim2, dim2_type);
534 static void get_ids(struct isl_dim *dim, enum isl_dim_type type,
535 unsigned first, unsigned n, __isl_keep isl_id **ids)
539 for (i = 0; i < n ; ++i)
540 ids[i] = get_id(dim, type, first + i);
543 struct isl_dim *isl_dim_extend(struct isl_dim *dim,
544 unsigned nparam, unsigned n_in, unsigned n_out)
550 if (dim->nparam == nparam && dim->n_in == n_in && dim->n_out == n_out)
553 isl_assert(dim->ctx, dim->nparam <= nparam, goto error);
554 isl_assert(dim->ctx, dim->n_in <= n_in, goto error);
555 isl_assert(dim->ctx, dim->n_out <= n_out, goto error);
557 dim = isl_dim_cow(dim);
560 ids = isl_calloc_array(dim->ctx, isl_id *,
561 nparam + n_in + n_out);
564 get_ids(dim, isl_dim_param, 0, dim->nparam, ids);
565 get_ids(dim, isl_dim_in, 0, dim->n_in, ids + nparam);
566 get_ids(dim, isl_dim_out, 0, dim->n_out, ids + nparam + n_in);
569 dim->n_id = nparam + n_in + n_out;
571 dim->nparam = nparam;
582 struct isl_dim *isl_dim_add(struct isl_dim *dim, enum isl_dim_type type,
587 dim = isl_dim_reset(dim, type);
590 dim = isl_dim_extend(dim,
591 dim->nparam + n, dim->n_in, dim->n_out);
592 if (dim && dim->nested[0] &&
593 !(dim->nested[0] = isl_dim_add(dim->nested[0],
596 if (dim && dim->nested[1] &&
597 !(dim->nested[1] = isl_dim_add(dim->nested[1],
602 return isl_dim_extend(dim,
603 dim->nparam, dim->n_in + n, dim->n_out);
605 return isl_dim_extend(dim,
606 dim->nparam, dim->n_in, dim->n_out + n);
608 isl_die(dim->ctx, isl_error_invalid,
609 "cannot add dimensions of specified type", goto error);
616 static int valid_dim_type(enum isl_dim_type type)
628 __isl_give isl_dim *isl_dim_insert(__isl_take isl_dim *dim,
629 enum isl_dim_type type, unsigned pos, unsigned n)
636 return isl_dim_reset(dim, type);
638 if (!valid_dim_type(type))
639 isl_die(dim->ctx, isl_error_invalid,
640 "cannot insert dimensions of specified type",
643 isl_assert(dim->ctx, pos <= isl_dim_size(dim, type), goto error);
645 dim = isl_dim_cow(dim);
653 int *size = s - isl_dim_param;
654 ids = isl_calloc_array(dim->ctx, isl_id *,
655 dim->nparam + dim->n_in + dim->n_out + n);
659 size[isl_dim_param] = dim->nparam;
660 size[isl_dim_in] = dim->n_in;
661 size[isl_dim_out] = dim->n_out;
662 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
664 get_ids(dim, t, 0, size[t], ids + off);
667 get_ids(dim, t, 0, pos, ids + off);
669 get_ids(dim, t, pos, size[t] - pos, ids + off);
670 off += size[t] - pos;
675 dim->n_id = dim->nparam + dim->n_in + dim->n_out + n;
678 case isl_dim_param: dim->nparam += n; break;
679 case isl_dim_in: dim->n_in += n; break;
680 case isl_dim_out: dim->n_out += n; break;
683 dim = isl_dim_reset(dim, type);
691 __isl_give isl_dim *isl_dim_move(__isl_take isl_dim *dim,
692 enum isl_dim_type dst_type, unsigned dst_pos,
693 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
702 isl_assert(dim->ctx, src_pos + n <= isl_dim_size(dim, src_type),
705 if (dst_type == src_type && dst_pos == src_pos)
708 isl_assert(dim->ctx, dst_type != src_type, goto error);
710 dim = isl_dim_reset(dim, src_type);
711 dim = isl_dim_reset(dim, dst_type);
713 dim = isl_dim_cow(dim);
722 int *size = s - isl_dim_param;
723 ids = isl_calloc_array(dim->ctx, isl_id *,
724 dim->nparam + dim->n_in + dim->n_out);
728 size[isl_dim_param] = dim->nparam;
729 size[isl_dim_in] = dim->n_in;
730 size[isl_dim_out] = dim->n_out;
731 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
733 get_ids(dim, t, 0, dst_pos, ids + off);
735 get_ids(dim, src_type, src_pos, n, ids + off);
737 get_ids(dim, t, dst_pos, size[t] - dst_pos,
739 off += size[t] - dst_pos;
740 } else if (t == src_type) {
741 get_ids(dim, t, 0, src_pos, ids + off);
743 get_ids(dim, t, src_pos + n,
744 size[t] - src_pos - n, ids + off);
745 off += size[t] - src_pos - n;
747 get_ids(dim, t, 0, size[t], ids + off);
753 dim->n_id = dim->nparam + dim->n_in + dim->n_out;
757 case isl_dim_param: dim->nparam += n; break;
758 case isl_dim_in: dim->n_in += n; break;
759 case isl_dim_out: dim->n_out += n; break;
764 case isl_dim_param: dim->nparam -= n; break;
765 case isl_dim_in: dim->n_in -= n; break;
766 case isl_dim_out: dim->n_out -= n; break;
770 if (dst_type != isl_dim_param && src_type != isl_dim_param)
773 for (i = 0; i < 2; ++i) {
776 dim->nested[i] = isl_dim_replace(dim->nested[i],
788 struct isl_dim *isl_dim_join(struct isl_dim *left, struct isl_dim *right)
795 isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
797 isl_assert(left->ctx,
798 isl_dim_tuple_match(left, isl_dim_out, right, isl_dim_in),
801 dim = isl_dim_alloc(left->ctx, left->nparam, left->n_in, right->n_out);
805 dim = copy_ids(dim, isl_dim_param, 0, left, isl_dim_param);
806 dim = copy_ids(dim, isl_dim_in, 0, left, isl_dim_in);
807 dim = copy_ids(dim, isl_dim_out, 0, right, isl_dim_out);
809 if (dim && left->tuple_id[0] &&
810 !(dim->tuple_id[0] = isl_id_copy(left->tuple_id[0])))
812 if (dim && right->tuple_id[1] &&
813 !(dim->tuple_id[1] = isl_id_copy(right->tuple_id[1])))
815 if (dim && left->nested[0] &&
816 !(dim->nested[0] = isl_dim_copy(left->nested[0])))
818 if (dim && right->nested[1] &&
819 !(dim->nested[1] = isl_dim_copy(right->nested[1])))
832 struct isl_dim *isl_dim_product(struct isl_dim *left, struct isl_dim *right)
834 isl_dim *dom1, *dom2, *nest1, *nest2;
839 isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
842 dom1 = isl_dim_domain(isl_dim_copy(left));
843 dom2 = isl_dim_domain(isl_dim_copy(right));
844 nest1 = isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1), dom2));
846 dom1 = isl_dim_range(left);
847 dom2 = isl_dim_range(right);
848 nest2 = isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1), dom2));
850 return isl_dim_join(isl_dim_reverse(nest1), nest2);
857 __isl_give isl_dim *isl_dim_range_product(__isl_take isl_dim *left,
858 __isl_take isl_dim *right)
860 isl_dim *dom, *ran1, *ran2, *nest;
865 isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
867 if (!isl_dim_tuple_match(left, isl_dim_in, right, isl_dim_in))
868 isl_die(left->ctx, isl_error_invalid,
869 "domains need to match", goto error);
871 dom = isl_dim_domain(isl_dim_copy(left));
873 ran1 = isl_dim_range(left);
874 ran2 = isl_dim_range(right);
875 nest = isl_dim_wrap(isl_dim_join(isl_dim_reverse(ran1), ran2));
877 return isl_dim_join(isl_dim_reverse(dom), nest);
884 __isl_give isl_dim *isl_dim_map_from_set(__isl_take isl_dim *dim)
890 isl_assert(dim->ctx, dim->n_in == 0, goto error);
891 if (dim->n_out == 0 && !isl_dim_is_named_or_nested(dim, isl_dim_out))
893 dim = isl_dim_cow(dim);
897 ids = isl_calloc_array(dim->ctx, isl_id *,
898 dim->nparam + dim->n_out + dim->n_out);
901 get_ids(dim, isl_dim_param, 0, dim->nparam, ids);
902 get_ids(dim, isl_dim_out, 0, dim->n_out, ids + dim->nparam);
904 dim->n_in = dim->n_out;
908 dim->n_id = dim->nparam + dim->n_out + dim->n_out;
909 dim = copy_ids(dim, isl_dim_out, 0, dim, isl_dim_in);
911 isl_id_free(dim->tuple_id[0]);
912 dim->tuple_id[0] = isl_id_copy(dim->tuple_id[1]);
913 isl_dim_free(dim->nested[0]);
914 dim->nested[0] = isl_dim_copy(dim->nested[1]);
921 static __isl_give isl_dim *set_ids(struct isl_dim *dim, enum isl_dim_type type,
922 unsigned first, unsigned n, __isl_take isl_id **ids)
926 for (i = 0; i < n ; ++i)
927 dim = set_id(dim, type, first + i, ids[i]);
932 struct isl_dim *isl_dim_reverse(struct isl_dim *dim)
941 if (match(dim, isl_dim_in, dim, isl_dim_out))
944 dim = isl_dim_cow(dim);
948 id = dim->tuple_id[0];
949 dim->tuple_id[0] = dim->tuple_id[1];
950 dim->tuple_id[1] = id;
952 nested = dim->nested[0];
953 dim->nested[0] = dim->nested[1];
954 dim->nested[1] = nested;
957 ids = isl_alloc_array(dim->ctx, isl_id *,
958 dim->n_in + dim->n_out);
961 get_ids(dim, isl_dim_in, 0, dim->n_in, ids);
962 get_ids(dim, isl_dim_out, 0, dim->n_out, ids + dim->n_in);
966 dim->n_in = dim->n_out;
970 dim = set_ids(dim, isl_dim_out, 0, dim->n_out, ids);
971 dim = set_ids(dim, isl_dim_in, 0, dim->n_in, ids + dim->n_out);
982 struct isl_dim *isl_dim_drop(struct isl_dim *dim, enum isl_dim_type type,
983 unsigned first, unsigned num)
991 return isl_dim_reset(dim, type);
993 if (!valid_dim_type(type))
994 isl_die(dim->ctx, isl_error_invalid,
995 "cannot drop dimensions of specified type", goto error);
997 isl_assert(dim->ctx, first + num <= n(dim, type), goto error);
998 dim = isl_dim_cow(dim);
1002 dim = extend_ids(dim);
1005 for (i = 0; i < num; ++i)
1006 isl_id_free(get_id(dim, type, first + i));
1007 for (i = first+num; i < n(dim, type); ++i)
1008 set_id(dim, type, i - num, get_id(dim, type, i));
1011 get_ids(dim, isl_dim_in, 0, dim->n_in,
1012 dim->ids + offset(dim, isl_dim_in) - num);
1014 get_ids(dim, isl_dim_out, 0, dim->n_out,
1015 dim->ids + offset(dim, isl_dim_out) - num);
1022 case isl_dim_param: dim->nparam -= num; break;
1023 case isl_dim_in: dim->n_in -= num; break;
1024 case isl_dim_out: dim->n_out -= num; break;
1027 dim = isl_dim_reset(dim, type);
1028 if (type == isl_dim_param) {
1029 if (dim && dim->nested[0] &&
1030 !(dim->nested[0] = isl_dim_drop(dim->nested[0],
1031 isl_dim_param, first, num)))
1033 if (dim && dim->nested[1] &&
1034 !(dim->nested[1] = isl_dim_drop(dim->nested[1],
1035 isl_dim_param, first, num)))
1044 struct isl_dim *isl_dim_drop_inputs(struct isl_dim *dim,
1045 unsigned first, unsigned n)
1049 return isl_dim_drop(dim, isl_dim_in, first, n);
1052 struct isl_dim *isl_dim_drop_outputs(struct isl_dim *dim,
1053 unsigned first, unsigned n)
1057 return isl_dim_drop(dim, isl_dim_out, first, n);
1060 struct isl_dim *isl_dim_domain(struct isl_dim *dim)
1064 dim = isl_dim_drop_outputs(dim, 0, dim->n_out);
1065 return isl_dim_reverse(dim);
1068 __isl_give isl_dim *isl_dim_from_domain(__isl_take isl_dim *dim)
1070 return isl_dim_reverse(dim);
1073 struct isl_dim *isl_dim_range(struct isl_dim *dim)
1077 return isl_dim_drop_inputs(dim, 0, dim->n_in);
1080 __isl_give isl_dim *isl_dim_from_range(__isl_take isl_dim *dim)
1085 __isl_give isl_dim *isl_dim_as_set_dim(__isl_take isl_dim *dim)
1087 dim = isl_dim_cow(dim);
1091 dim->n_out += dim->n_in;
1093 dim = isl_dim_reset(dim, isl_dim_in);
1094 dim = isl_dim_reset(dim, isl_dim_out);
1099 struct isl_dim *isl_dim_underlying(struct isl_dim *dim, unsigned n_div)
1106 dim->nparam == 0 && dim->n_in == 0 && dim->n_id == 0)
1107 return isl_dim_reset(isl_dim_reset(dim, isl_dim_in), isl_dim_out);
1108 dim = isl_dim_cow(dim);
1111 dim->n_out += dim->nparam + dim->n_in + n_div;
1115 for (i = 0; i < dim->n_id; ++i)
1116 isl_id_free(get_id(dim, isl_dim_out, i));
1118 dim = isl_dim_reset(dim, isl_dim_in);
1119 dim = isl_dim_reset(dim, isl_dim_out);
1124 unsigned isl_dim_total(struct isl_dim *dim)
1126 return dim ? dim->nparam + dim->n_in + dim->n_out : 0;
1129 int isl_dim_equal(struct isl_dim *dim1, struct isl_dim *dim2)
1133 return match(dim1, isl_dim_param, dim2, isl_dim_param) &&
1134 isl_dim_tuple_match(dim1, isl_dim_in, dim2, isl_dim_in) &&
1135 isl_dim_tuple_match(dim1, isl_dim_out, dim2, isl_dim_out);
1138 int isl_dim_compatible(struct isl_dim *dim1, struct isl_dim *dim2)
1140 return dim1->nparam == dim2->nparam &&
1141 dim1->n_in + dim1->n_out == dim2->n_in + dim2->n_out;
1144 static uint32_t isl_hash_dim(uint32_t hash, __isl_keep isl_dim *dim)
1152 hash = isl_hash_builtin(hash, dim->nparam);
1153 hash = isl_hash_builtin(hash, dim->n_in);
1154 hash = isl_hash_builtin(hash, dim->n_out);
1156 for (i = 0; i < dim->nparam; ++i) {
1157 id = get_id(dim, isl_dim_param, i);
1158 hash = isl_hash_id(hash, id);
1161 id = tuple_id(dim, isl_dim_in);
1162 hash = isl_hash_id(hash, id);
1163 id = tuple_id(dim, isl_dim_out);
1164 hash = isl_hash_id(hash, id);
1166 hash = isl_hash_dim(hash, dim->nested[0]);
1167 hash = isl_hash_dim(hash, dim->nested[1]);
1172 uint32_t isl_dim_get_hash(__isl_keep isl_dim *dim)
1179 hash = isl_hash_init();
1180 hash = isl_hash_dim(hash, dim);
1185 int isl_dim_is_wrapping(__isl_keep isl_dim *dim)
1190 if (dim->n_in != 0 || dim->tuple_id[0] || dim->nested[0])
1193 return dim->nested[1] != NULL;
1196 __isl_give isl_dim *isl_dim_wrap(__isl_take isl_dim *dim)
1203 wrap = isl_dim_alloc(dim->ctx, dim->nparam, 0, dim->n_in + dim->n_out);
1205 wrap = copy_ids(wrap, isl_dim_param, 0, dim, isl_dim_param);
1206 wrap = copy_ids(wrap, isl_dim_set, 0, dim, isl_dim_in);
1207 wrap = copy_ids(wrap, isl_dim_set, dim->n_in, dim, isl_dim_out);
1212 wrap->nested[1] = dim;
1220 __isl_give isl_dim *isl_dim_unwrap(__isl_take isl_dim *dim)
1227 if (!isl_dim_is_wrapping(dim))
1228 isl_die(dim->ctx, isl_error_invalid, "not a wrapping dim",
1231 unwrap = isl_dim_copy(dim->nested[1]);
1240 int isl_dim_is_named_or_nested(__isl_keep isl_dim *dim, enum isl_dim_type type)
1242 if (type != isl_dim_in && type != isl_dim_out)
1246 if (dim->tuple_id[type - isl_dim_in])
1248 if (dim->nested[type - isl_dim_in])
1253 int isl_dim_may_be_set(__isl_keep isl_dim *dim)
1257 if (isl_dim_size(dim, isl_dim_in) != 0)
1259 if (isl_dim_is_named_or_nested(dim, isl_dim_in))
1264 __isl_give isl_dim *isl_dim_reset(__isl_take isl_dim *dim,
1265 enum isl_dim_type type)
1267 if (!isl_dim_is_named_or_nested(dim, type))
1270 dim = isl_dim_cow(dim);
1274 isl_id_free(dim->tuple_id[type - isl_dim_in]);
1275 dim->tuple_id[type - isl_dim_in] = NULL;
1276 isl_dim_free(dim->nested[type - isl_dim_in]);
1277 dim->nested[type - isl_dim_in] = NULL;
1282 __isl_give isl_dim *isl_dim_flatten(__isl_take isl_dim *dim)
1286 if (!dim->nested[0] && !dim->nested[1])
1290 dim = isl_dim_reset(dim, isl_dim_in);
1291 if (dim && dim->nested[1])
1292 dim = isl_dim_reset(dim, isl_dim_out);
1297 __isl_give isl_dim *isl_dim_flatten_range(__isl_take isl_dim *dim)
1301 if (!dim->nested[1])
1304 return isl_dim_reset(dim, isl_dim_out);
1307 /* Replace the dimensions of the given type of dst by those of src.
1309 __isl_give isl_dim *isl_dim_replace(__isl_take isl_dim *dst,
1310 enum isl_dim_type type, __isl_keep isl_dim *src)
1312 dst = isl_dim_cow(dst);
1317 dst = isl_dim_drop(dst, type, 0, isl_dim_size(dst, type));
1318 dst = isl_dim_add(dst, type, isl_dim_size(src, type));
1319 dst = copy_ids(dst, type, 0, src, type);
1321 if (dst && type == isl_dim_param) {
1323 for (i = 0; i <= 1; ++i) {
1324 if (!dst->nested[i])
1326 dst->nested[i] = isl_dim_replace(dst->nested[i],
1328 if (!dst->nested[i])
1339 /* Given a dimension specification "dim" of a set, create a dimension
1340 * specification for the lift of the set. In particular, the result
1341 * is of the form [dim -> local[..]], with n_local variables in the
1342 * range of the wrapped map.
1344 __isl_give isl_dim *isl_dim_lift(__isl_take isl_dim *dim, unsigned n_local)
1351 local_dim = isl_dim_dup(dim);
1352 local_dim = isl_dim_drop(local_dim, isl_dim_set, 0, dim->n_out);
1353 local_dim = isl_dim_add(local_dim, isl_dim_set, n_local);
1354 local_dim = isl_dim_set_tuple_name(local_dim, isl_dim_set, "local");
1355 dim = isl_dim_join(isl_dim_from_domain(dim),
1356 isl_dim_from_range(local_dim));
1357 dim = isl_dim_wrap(dim);
1358 dim = isl_dim_set_tuple_name(dim, isl_dim_set, "lifted");
1363 int isl_dim_can_zip(__isl_keep isl_dim *dim)
1368 return dim->nested[0] && dim->nested[1];
1371 __isl_give isl_dim *isl_dim_zip(__isl_take isl_dim *dim)
1374 isl_dim *dom_dom, *dom_ran, *ran_dom, *ran_ran;
1376 if (!isl_dim_can_zip(dim))
1377 isl_die(dim->ctx, isl_error_invalid, "dim cannot be zipped",
1382 dom = isl_dim_unwrap(isl_dim_domain(isl_dim_copy(dim)));
1383 ran = isl_dim_unwrap(isl_dim_range(dim));
1384 dom_dom = isl_dim_domain(isl_dim_copy(dom));
1385 dom_ran = isl_dim_range(dom);
1386 ran_dom = isl_dim_domain(isl_dim_copy(ran));
1387 ran_ran = isl_dim_range(ran);
1388 dom = isl_dim_join(isl_dim_from_domain(dom_dom),
1389 isl_dim_from_range(ran_dom));
1390 ran = isl_dim_join(isl_dim_from_domain(dom_ran),
1391 isl_dim_from_range(ran_ran));
1392 return isl_dim_join(isl_dim_from_domain(isl_dim_wrap(dom)),
1393 isl_dim_from_range(isl_dim_wrap(ran)));
1399 int isl_dim_has_named_params(__isl_keep isl_dim *dim)
1406 if (dim->nparam == 0)
1408 off = isl_dim_offset(dim, isl_dim_param);
1409 if (off + dim->nparam > dim->n_id)
1411 for (i = 0; i < dim->nparam; ++i)
1412 if (!dim->ids[off + i])
1417 /* Align the initial parameters of dim1 to match the order in dim2.
1419 __isl_give isl_dim *isl_dim_align_params(__isl_take isl_dim *dim1,
1420 __isl_take isl_dim *dim2)
1422 isl_reordering *exp;
1424 if (!isl_dim_has_named_params(dim1) || !isl_dim_has_named_params(dim2))
1425 isl_die(isl_dim_get_ctx(dim1), isl_error_invalid,
1426 "parameter alignment requires named parameters",
1429 exp = isl_parameter_alignment_reordering(dim1, dim2);
1434 dim1 = isl_dim_copy(exp->dim);
1435 isl_reordering_free(exp);