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>
17 isl_ctx
*isl_dim_get_ctx(__isl_keep isl_dim
*dim
)
19 return dim
? dim
->ctx
: NULL
;
22 struct isl_dim
*isl_dim_alloc(struct isl_ctx
*ctx
,
23 unsigned nparam
, unsigned n_in
, unsigned n_out
)
27 dim
= isl_alloc_type(ctx
, struct isl_dim
);
38 dim
->tuple_name
[0] = NULL
;
39 dim
->tuple_name
[1] = NULL
;
41 dim
->nested
[0] = NULL
;
42 dim
->nested
[1] = NULL
;
50 struct isl_dim
*isl_dim_set_alloc(struct isl_ctx
*ctx
,
51 unsigned nparam
, unsigned dim
)
53 return isl_dim_alloc(ctx
, nparam
, 0, dim
);
56 static unsigned global_pos(struct isl_dim
*dim
,
57 enum isl_dim_type type
, unsigned pos
)
59 struct isl_ctx
*ctx
= dim
->ctx
;
63 isl_assert(ctx
, pos
< dim
->nparam
, return isl_dim_total(dim
));
66 isl_assert(ctx
, pos
< dim
->n_in
, return isl_dim_total(dim
));
67 return pos
+ dim
->nparam
;
69 isl_assert(ctx
, pos
< dim
->n_out
, return isl_dim_total(dim
));
70 return pos
+ dim
->nparam
+ dim
->n_in
;
72 isl_assert(ctx
, 0, return isl_dim_total(dim
));
74 return isl_dim_total(dim
);
77 /* Extend length of names array to the total number of dimensions.
79 static __isl_give isl_dim
*extend_names(__isl_take isl_dim
*dim
)
81 struct isl_name
**names
;
84 if (isl_dim_total(dim
) <= dim
->n_name
)
88 dim
->names
= isl_calloc_array(dim
->ctx
,
89 struct isl_name
*, isl_dim_total(dim
));
93 names
= isl_realloc_array(dim
->ctx
, dim
->names
,
94 struct isl_name
*, isl_dim_total(dim
));
98 for (i
= dim
->n_name
; i
< isl_dim_total(dim
); ++i
)
102 dim
->n_name
= isl_dim_total(dim
);
110 static struct isl_dim
*set_name(struct isl_dim
*dim
,
111 enum isl_dim_type type
, unsigned pos
,
112 struct isl_name
*name
)
114 struct isl_ctx
*ctx
= dim
->ctx
;
115 dim
= isl_dim_cow(dim
);
120 pos
= global_pos(dim
, type
, pos
);
121 isl_assert(ctx
, pos
!= isl_dim_total(dim
), goto error
);
123 if (pos
>= dim
->n_name
) {
126 dim
= extend_names(dim
);
131 dim
->names
[pos
] = name
;
135 isl_name_free(ctx
, name
);
140 static struct isl_name
*get_name(struct 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_name
)
151 return dim
->names
[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
;
174 unsigned isl_dim_size(struct isl_dim
*dim
, enum isl_dim_type type
)
181 unsigned isl_dim_offset(__isl_keep isl_dim
*dim
, enum isl_dim_type type
)
185 return offset(dim
, type
);
188 static struct isl_dim
*copy_names(struct isl_dim
*dst
,
189 enum isl_dim_type dst_type
, unsigned offset
, struct isl_dim
*src
,
190 enum isl_dim_type src_type
)
193 struct isl_name
*name
;
198 for (i
= 0; i
< n(src
, src_type
); ++i
) {
199 name
= get_name(src
, src_type
, i
);
202 dst
= set_name(dst
, dst_type
, offset
+ i
,
203 isl_name_copy(dst
->ctx
, name
));
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_name
[0] &&
217 !(dup
->tuple_name
[0] = isl_name_copy(dim
->ctx
, dim
->tuple_name
[0])))
219 if (dim
->tuple_name
[1] &&
220 !(dup
->tuple_name
[1] = isl_name_copy(dim
->ctx
, dim
->tuple_name
[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_names(dup
, isl_dim_param
, 0, dim
, isl_dim_param
);
229 dup
= copy_names(dup
, isl_dim_in
, 0, dim
, isl_dim_in
);
230 dup
= copy_names(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_name_free(dim
->ctx
, dim
->tuple_name
[0]);
268 isl_name_free(dim
->ctx
, dim
->tuple_name
[1]);
270 isl_dim_free(dim
->nested
[0]);
271 isl_dim_free(dim
->nested
[1]);
273 for (i
= 0; i
< dim
->n_name
; ++i
)
274 isl_name_free(dim
->ctx
, dim
->names
[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_dim
*isl_dim_set_tuple_name(__isl_take isl_dim
*dim
,
295 enum isl_dim_type type
, const char *s
)
297 struct isl_name
*name
;
299 dim
= isl_dim_cow(dim
);
302 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
303 isl_die(dim
->ctx
, isl_error_invalid
,
304 "only input, output and set tuples can have names",
309 if (!name_ok(dim
->ctx
, s
))
311 name
= isl_name_get(dim
->ctx
, s
);
316 isl_name_free(dim
->ctx
, dim
->tuple_name
[type
- isl_dim_in
]);
317 dim
->tuple_name
[type
- isl_dim_in
] = name
;
325 const char *isl_dim_get_tuple_name(__isl_keep isl_dim
*dim
,
326 enum isl_dim_type type
)
328 struct isl_name
*name
;
331 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
333 name
= dim
->tuple_name
[type
- isl_dim_in
];
334 return name
? name
->name
: NULL
;
337 struct isl_dim
*isl_dim_set_name(struct isl_dim
*dim
,
338 enum isl_dim_type type
, unsigned pos
,
341 struct isl_name
*name
;
345 if (!name_ok(dim
->ctx
, s
))
347 name
= isl_name_get(dim
->ctx
, s
);
350 return set_name(dim
, type
, pos
, name
);
356 const char *isl_dim_get_name(struct isl_dim
*dim
,
357 enum isl_dim_type type
, unsigned pos
)
359 struct isl_name
*name
= get_name(dim
, type
, pos
);
360 return name
? name
->name
: NULL
;
363 static struct isl_name
*tuple_name(__isl_keep isl_dim
*dim
,
364 enum isl_dim_type type
)
368 if (type
== isl_dim_in
)
369 return dim
->tuple_name
[0];
370 if (type
== isl_dim_out
)
371 return dim
->tuple_name
[1];
375 static __isl_keep isl_dim
*nested(__isl_keep isl_dim
*dim
,
376 enum isl_dim_type type
)
380 if (type
== isl_dim_in
)
381 return dim
->nested
[0];
382 if (type
== isl_dim_out
)
383 return dim
->nested
[1];
387 int isl_dim_tuple_match(__isl_keep isl_dim
*dim1
, enum isl_dim_type dim1_type
,
388 __isl_keep isl_dim
*dim2
, enum isl_dim_type dim2_type
)
390 struct isl_name
*name1
, *name2
;
391 isl_dim
*nested1
, *nested2
;
393 if (n(dim1
, dim1_type
) != n(dim2
, dim2_type
))
395 name1
= tuple_name(dim1
, dim1_type
);
396 name2
= tuple_name(dim2
, dim2_type
);
399 if (name1
&& name1
->name
!= name2
->name
)
401 nested1
= nested(dim1
, dim1_type
);
402 nested2
= nested(dim2
, dim2_type
);
403 if (!nested1
^ !nested2
)
405 if (nested1
&& !isl_dim_equal(nested1
, nested2
))
410 static int match(struct isl_dim
*dim1
, enum isl_dim_type dim1_type
,
411 struct isl_dim
*dim2
, enum isl_dim_type dim2_type
)
415 if (!isl_dim_tuple_match(dim1
, dim1_type
, dim2
, dim2_type
))
418 if (!dim1
->names
&& !dim2
->names
)
421 for (i
= 0; i
< n(dim1
, dim1_type
); ++i
) {
422 if (get_name(dim1
, dim1_type
, i
) !=
423 get_name(dim2
, dim2_type
, i
))
429 int isl_dim_match(struct isl_dim
*dim1
, enum isl_dim_type dim1_type
,
430 struct isl_dim
*dim2
, enum isl_dim_type dim2_type
)
432 return match(dim1
, dim1_type
, dim2
, dim2_type
);
435 static void get_names(struct isl_dim
*dim
, enum isl_dim_type type
,
436 unsigned first
, unsigned n
, struct isl_name
**names
)
440 for (i
= 0; i
< n
; ++i
)
441 names
[i
] = get_name(dim
, type
, first
+i
);
444 struct isl_dim
*isl_dim_extend(struct isl_dim
*dim
,
445 unsigned nparam
, unsigned n_in
, unsigned n_out
)
447 struct isl_name
**names
= NULL
;
451 if (dim
->nparam
== nparam
&& dim
->n_in
== n_in
&& dim
->n_out
== n_out
)
454 isl_assert(dim
->ctx
, dim
->nparam
<= nparam
, goto error
);
455 isl_assert(dim
->ctx
, dim
->n_in
<= n_in
, goto error
);
456 isl_assert(dim
->ctx
, dim
->n_out
<= n_out
, goto error
);
458 dim
= isl_dim_cow(dim
);
461 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
462 nparam
+ n_in
+ n_out
);
465 get_names(dim
, isl_dim_param
, 0, dim
->nparam
, names
);
466 get_names(dim
, isl_dim_in
, 0, dim
->n_in
, names
+ nparam
);
467 get_names(dim
, isl_dim_out
, 0, dim
->n_out
,
468 names
+ nparam
+ n_in
);
471 dim
->n_name
= nparam
+ n_in
+ n_out
;
473 dim
->nparam
= nparam
;
484 struct isl_dim
*isl_dim_add(struct isl_dim
*dim
, enum isl_dim_type type
,
489 dim
= isl_dim_reset(dim
, type
);
492 dim
= isl_dim_extend(dim
,
493 dim
->nparam
+ n
, dim
->n_in
, dim
->n_out
);
494 if (dim
&& dim
->nested
[0] &&
495 !(dim
->nested
[0] = isl_dim_add(dim
->nested
[0],
498 if (dim
&& dim
->nested
[1] &&
499 !(dim
->nested
[1] = isl_dim_add(dim
->nested
[1],
504 return isl_dim_extend(dim
,
505 dim
->nparam
, dim
->n_in
+ n
, dim
->n_out
);
507 return isl_dim_extend(dim
,
508 dim
->nparam
, dim
->n_in
, dim
->n_out
+ n
);
516 __isl_give isl_dim
*isl_dim_insert(__isl_take isl_dim
*dim
,
517 enum isl_dim_type type
, unsigned pos
, unsigned n
)
519 struct isl_name
**names
= NULL
;
524 return isl_dim_reset(dim
, type
);
526 isl_assert(dim
->ctx
, pos
<= isl_dim_size(dim
, type
), goto error
);
528 dim
= isl_dim_cow(dim
);
536 int *size
= s
- isl_dim_param
;
537 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
538 dim
->nparam
+ dim
->n_in
+ dim
->n_out
+ n
);
542 size
[isl_dim_param
] = dim
->nparam
;
543 size
[isl_dim_in
] = dim
->n_in
;
544 size
[isl_dim_out
] = dim
->n_out
;
545 for (t
= isl_dim_param
; t
<= isl_dim_out
; ++t
) {
547 get_names(dim
, t
, 0, size
[t
], names
+ off
);
550 get_names(dim
, t
, 0, pos
, names
+ off
);
552 get_names(dim
, t
, pos
, size
[t
]-pos
, names
+off
);
553 off
+= size
[t
] - pos
;
558 dim
->n_name
= dim
->nparam
+ dim
->n_in
+ dim
->n_out
+ n
;
561 case isl_dim_param
: dim
->nparam
+= n
; break;
562 case isl_dim_in
: dim
->n_in
+= n
; break;
563 case isl_dim_out
: dim
->n_out
+= n
; break;
565 dim
= isl_dim_reset(dim
, type
);
573 __isl_give isl_dim
*isl_dim_move(__isl_take isl_dim
*dim
,
574 enum isl_dim_type dst_type
, unsigned dst_pos
,
575 enum isl_dim_type src_type
, unsigned src_pos
, unsigned n
)
582 isl_assert(dim
->ctx
, src_pos
+ n
<= isl_dim_size(dim
, src_type
),
585 if (dst_type
== src_type
&& dst_pos
== src_pos
)
588 isl_assert(dim
->ctx
, dst_type
!= src_type
, goto error
);
590 dim
= isl_dim_reset(dim
, src_type
);
591 dim
= isl_dim_reset(dim
, dst_type
);
593 dim
= isl_dim_cow(dim
);
598 struct isl_name
**names
;
602 int *size
= s
- isl_dim_param
;
603 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
604 dim
->nparam
+ dim
->n_in
+ dim
->n_out
);
608 size
[isl_dim_param
] = dim
->nparam
;
609 size
[isl_dim_in
] = dim
->n_in
;
610 size
[isl_dim_out
] = dim
->n_out
;
611 for (t
= isl_dim_param
; t
<= isl_dim_out
; ++t
) {
613 get_names(dim
, t
, 0, dst_pos
, names
+ off
);
615 get_names(dim
, src_type
, src_pos
, n
, names
+off
);
617 get_names(dim
, t
, dst_pos
, size
[t
] - dst_pos
,
619 off
+= size
[t
] - dst_pos
;
620 } else if (t
== src_type
) {
621 get_names(dim
, t
, 0, src_pos
, names
+ off
);
623 get_names(dim
, t
, src_pos
+ n
,
624 size
[t
] - src_pos
- n
, names
+ off
);
625 off
+= size
[t
] - src_pos
- n
;
627 get_names(dim
, t
, 0, size
[t
], names
+ off
);
633 dim
->n_name
= dim
->nparam
+ dim
->n_in
+ dim
->n_out
;
637 case isl_dim_param
: dim
->nparam
+= n
; break;
638 case isl_dim_in
: dim
->n_in
+= n
; break;
639 case isl_dim_out
: dim
->n_out
+= n
; break;
643 case isl_dim_param
: dim
->nparam
-= n
; break;
644 case isl_dim_in
: dim
->n_in
-= n
; break;
645 case isl_dim_out
: dim
->n_out
-= n
; break;
654 struct isl_dim
*isl_dim_join(struct isl_dim
*left
, struct isl_dim
*right
)
661 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
663 isl_assert(left
->ctx
,
664 isl_dim_tuple_match(left
, isl_dim_out
, right
, isl_dim_in
),
667 dim
= isl_dim_alloc(left
->ctx
, left
->nparam
, left
->n_in
, right
->n_out
);
671 dim
= copy_names(dim
, isl_dim_param
, 0, left
, isl_dim_param
);
672 dim
= copy_names(dim
, isl_dim_in
, 0, left
, isl_dim_in
);
673 dim
= copy_names(dim
, isl_dim_out
, 0, right
, isl_dim_out
);
675 if (dim
&& left
->tuple_name
[0] &&
676 !(dim
->tuple_name
[0] = isl_name_copy(dim
->ctx
, left
->tuple_name
[0])))
678 if (dim
&& right
->tuple_name
[1] &&
679 !(dim
->tuple_name
[1] = isl_name_copy(dim
->ctx
, right
->tuple_name
[1])))
681 if (dim
&& left
->nested
[0] &&
682 !(dim
->nested
[0] = isl_dim_copy(left
->nested
[0])))
684 if (dim
&& right
->nested
[1] &&
685 !(dim
->nested
[1] = isl_dim_copy(right
->nested
[1])))
698 struct isl_dim
*isl_dim_product(struct isl_dim
*left
, struct isl_dim
*right
)
700 isl_dim
*dom1
, *dom2
, *nest1
, *nest2
;
705 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
708 dom1
= isl_dim_domain(isl_dim_copy(left
));
709 dom2
= isl_dim_domain(isl_dim_copy(right
));
710 nest1
= isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1
), dom2
));
712 dom1
= isl_dim_range(left
);
713 dom2
= isl_dim_range(right
);
714 nest2
= isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1
), dom2
));
716 return isl_dim_join(isl_dim_reverse(nest1
), nest2
);
723 struct isl_dim
*isl_dim_map(struct isl_dim
*dim
)
725 struct isl_name
**names
= NULL
;
729 isl_assert(dim
->ctx
, dim
->n_in
== 0, goto error
);
730 if (dim
->n_out
== 0 && !isl_dim_is_named_or_nested(dim
, isl_dim_out
))
732 dim
= isl_dim_cow(dim
);
736 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
737 dim
->nparam
+ dim
->n_out
+ dim
->n_out
);
740 get_names(dim
, isl_dim_param
, 0, dim
->nparam
, names
);
741 get_names(dim
, isl_dim_out
, 0, dim
->n_out
, names
+ dim
->nparam
);
743 dim
->n_in
= dim
->n_out
;
747 dim
->n_name
= dim
->nparam
+ dim
->n_out
+ dim
->n_out
;
748 dim
= copy_names(dim
, isl_dim_out
, 0, dim
, isl_dim_in
);
750 isl_name_free(dim
->ctx
, dim
->tuple_name
[0]);
751 dim
->tuple_name
[0] = isl_name_copy(dim
->ctx
, dim
->tuple_name
[1]);
752 isl_dim_free(dim
->nested
[0]);
753 dim
->nested
[0] = isl_dim_copy(dim
->nested
[1]);
760 static struct isl_dim
*set_names(struct isl_dim
*dim
, enum isl_dim_type type
,
761 unsigned first
, unsigned n
, struct isl_name
**names
)
765 for (i
= 0; i
< n
; ++i
)
766 dim
= set_name(dim
, type
, first
+i
, names
[i
]);
771 struct isl_dim
*isl_dim_reverse(struct isl_dim
*dim
)
775 struct isl_name
**names
= NULL
;
776 struct isl_name
*name
;
780 if (match(dim
, isl_dim_in
, dim
, isl_dim_out
))
783 dim
= isl_dim_cow(dim
);
787 name
= dim
->tuple_name
[0];
788 dim
->tuple_name
[0] = dim
->tuple_name
[1];
789 dim
->tuple_name
[1] = name
;
791 nested
= dim
->nested
[0];
792 dim
->nested
[0] = dim
->nested
[1];
793 dim
->nested
[1] = nested
;
796 names
= isl_alloc_array(dim
->ctx
, struct isl_name
*,
797 dim
->n_in
+ dim
->n_out
);
800 get_names(dim
, isl_dim_in
, 0, dim
->n_in
, names
);
801 get_names(dim
, isl_dim_out
, 0, dim
->n_out
, names
+ dim
->n_in
);
805 dim
->n_in
= dim
->n_out
;
809 dim
= set_names(dim
, isl_dim_out
, 0, dim
->n_out
, names
);
810 dim
= set_names(dim
, isl_dim_in
, 0, dim
->n_in
, names
+ dim
->n_out
);
821 struct isl_dim
*isl_dim_drop(struct isl_dim
*dim
, enum isl_dim_type type
,
822 unsigned first
, unsigned num
)
830 return isl_dim_reset(dim
, type
);
832 isl_assert(dim
->ctx
, first
+ num
<= n(dim
, type
), goto error
);
833 dim
= isl_dim_cow(dim
);
837 dim
= extend_names(dim
);
840 for (i
= 0; i
< num
; ++i
)
841 isl_name_free(dim
->ctx
, get_name(dim
, type
, first
+i
));
842 for (i
= first
+num
; i
< n(dim
, type
); ++i
)
843 set_name(dim
, type
, i
- num
, get_name(dim
, type
, i
));
846 get_names(dim
, isl_dim_in
, 0, dim
->n_in
,
847 dim
->names
+ offset(dim
, isl_dim_in
) - num
);
849 get_names(dim
, isl_dim_out
, 0, dim
->n_out
,
850 dim
->names
+ offset(dim
, isl_dim_out
) - num
);
857 case isl_dim_param
: dim
->nparam
-= num
; break;
858 case isl_dim_in
: dim
->n_in
-= num
; break;
859 case isl_dim_out
: dim
->n_out
-= num
; break;
861 dim
= isl_dim_reset(dim
, type
);
862 if (type
== isl_dim_param
) {
863 if (dim
&& dim
->nested
[0] &&
864 !(dim
->nested
[0] = isl_dim_drop(dim
->nested
[0],
865 isl_dim_param
, first
, num
)))
867 if (dim
&& dim
->nested
[1] &&
868 !(dim
->nested
[1] = isl_dim_drop(dim
->nested
[1],
869 isl_dim_param
, first
, num
)))
878 struct isl_dim
*isl_dim_drop_inputs(struct isl_dim
*dim
,
879 unsigned first
, unsigned n
)
883 return isl_dim_drop(dim
, isl_dim_in
, first
, n
);
886 struct isl_dim
*isl_dim_drop_outputs(struct isl_dim
*dim
,
887 unsigned first
, unsigned n
)
891 return isl_dim_drop(dim
, isl_dim_out
, first
, n
);
894 struct isl_dim
*isl_dim_domain(struct isl_dim
*dim
)
898 dim
= isl_dim_drop_outputs(dim
, 0, dim
->n_out
);
899 return isl_dim_reverse(dim
);
902 __isl_give isl_dim
*isl_dim_from_domain(__isl_take isl_dim
*dim
)
904 return isl_dim_reverse(dim
);
907 struct isl_dim
*isl_dim_range(struct isl_dim
*dim
)
911 return isl_dim_drop_inputs(dim
, 0, dim
->n_in
);
914 __isl_give isl_dim
*isl_dim_from_range(__isl_take isl_dim
*dim
)
919 __isl_give isl_dim
*isl_dim_as_set_dim(__isl_take isl_dim
*dim
)
921 dim
= isl_dim_cow(dim
);
925 dim
->n_out
+= dim
->n_in
;
927 dim
= isl_dim_reset(dim
, isl_dim_in
);
928 dim
= isl_dim_reset(dim
, isl_dim_out
);
933 struct isl_dim
*isl_dim_underlying(struct isl_dim
*dim
, unsigned n_div
)
940 dim
->nparam
== 0 && dim
->n_in
== 0 && dim
->n_name
== 0)
941 return isl_dim_reset(isl_dim_reset(dim
, isl_dim_in
), isl_dim_out
);
942 dim
= isl_dim_cow(dim
);
945 dim
->n_out
+= dim
->nparam
+ dim
->n_in
+ n_div
;
949 for (i
= 0; i
< dim
->n_name
; ++i
)
950 isl_name_free(dim
->ctx
, get_name(dim
, isl_dim_out
, i
));
952 dim
= isl_dim_reset(dim
, isl_dim_in
);
953 dim
= isl_dim_reset(dim
, isl_dim_out
);
958 unsigned isl_dim_total(struct isl_dim
*dim
)
960 return dim
? dim
->nparam
+ dim
->n_in
+ dim
->n_out
: 0;
963 int isl_dim_equal(struct isl_dim
*dim1
, struct isl_dim
*dim2
)
965 return match(dim1
, isl_dim_param
, dim2
, isl_dim_param
) &&
966 isl_dim_tuple_match(dim1
, isl_dim_in
, dim2
, isl_dim_in
) &&
967 isl_dim_tuple_match(dim1
, isl_dim_out
, dim2
, isl_dim_out
);
970 int isl_dim_compatible(struct isl_dim
*dim1
, struct isl_dim
*dim2
)
972 return dim1
->nparam
== dim2
->nparam
&&
973 dim1
->n_in
+ dim1
->n_out
== dim2
->n_in
+ dim2
->n_out
;
976 static uint32_t isl_hash_dim(uint32_t hash
, __isl_keep isl_dim
*dim
)
979 struct isl_name
*name
;
984 hash
= isl_hash_builtin(hash
, dim
->nparam
);
985 hash
= isl_hash_builtin(hash
, dim
->n_in
);
986 hash
= isl_hash_builtin(hash
, dim
->n_out
);
988 for (i
= 0; i
< dim
->nparam
; ++i
) {
989 name
= get_name(dim
, isl_dim_param
, i
);
990 hash
= isl_hash_builtin(hash
, name
);
993 name
= tuple_name(dim
, isl_dim_in
);
994 hash
= isl_hash_builtin(hash
, name
);
995 name
= tuple_name(dim
, isl_dim_out
);
996 hash
= isl_hash_builtin(hash
, name
);
998 hash
= isl_hash_dim(hash
, dim
->nested
[0]);
999 hash
= isl_hash_dim(hash
, dim
->nested
[1]);
1004 uint32_t isl_dim_get_hash(__isl_keep isl_dim
*dim
)
1011 hash
= isl_hash_init();
1012 hash
= isl_hash_dim(hash
, dim
);
1017 int isl_dim_is_wrapping(__isl_keep isl_dim
*dim
)
1022 if (dim
->n_in
!= 0 || dim
->tuple_name
[0] || dim
->nested
[0])
1025 return dim
->nested
[1] != NULL
;
1028 __isl_give isl_dim
*isl_dim_wrap(__isl_take isl_dim
*dim
)
1035 wrap
= isl_dim_alloc(dim
->ctx
, dim
->nparam
, 0, dim
->n_in
+ dim
->n_out
);
1037 wrap
= copy_names(wrap
, isl_dim_param
, 0, dim
, isl_dim_param
);
1038 wrap
= copy_names(wrap
, isl_dim_set
, 0, dim
, isl_dim_in
);
1039 wrap
= copy_names(wrap
, isl_dim_set
, dim
->n_in
, dim
, isl_dim_out
);
1044 wrap
->nested
[1] = dim
;
1052 __isl_give isl_dim
*isl_dim_unwrap(__isl_take isl_dim
*dim
)
1059 if (!isl_dim_is_wrapping(dim
))
1060 isl_die(dim
->ctx
, isl_error_invalid
, "not a wrapping dim",
1063 unwrap
= isl_dim_copy(dim
->nested
[1]);
1072 int isl_dim_is_named_or_nested(__isl_keep isl_dim
*dim
, enum isl_dim_type type
)
1074 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
1078 if (dim
->tuple_name
[type
- isl_dim_in
])
1080 if (dim
->nested
[type
- isl_dim_in
])
1085 __isl_give isl_dim
*isl_dim_reset(__isl_take isl_dim
*dim
,
1086 enum isl_dim_type type
)
1088 if (!isl_dim_is_named_or_nested(dim
, type
))
1091 dim
= isl_dim_cow(dim
);
1095 isl_name_free(dim
->ctx
, dim
->tuple_name
[type
- isl_dim_in
]);
1096 dim
->tuple_name
[type
- isl_dim_in
] = NULL
;
1097 isl_dim_free(dim
->nested
[type
- isl_dim_in
]);
1098 dim
->nested
[type
- isl_dim_in
] = NULL
;
1103 __isl_give isl_dim
*isl_dim_flatten(__isl_take isl_dim
*dim
)
1107 if (!dim
->nested
[0] && !dim
->nested
[1])
1111 dim
= isl_dim_reset(dim
, isl_dim_in
);
1112 if (dim
&& dim
->nested
[1])
1113 dim
= isl_dim_reset(dim
, isl_dim_out
);
1118 /* Replace the dimensions of the given type of dst by those of src.
1120 __isl_give isl_dim
*isl_dim_replace(__isl_take isl_dim
*dst
,
1121 enum isl_dim_type type
, __isl_keep isl_dim
*src
)
1123 dst
= isl_dim_cow(dst
);
1128 dst
= isl_dim_drop(dst
, type
, 0, isl_dim_size(dst
, type
));
1129 dst
= isl_dim_add(dst
, type
, isl_dim_size(src
, type
));
1130 dst
= copy_names(dst
, type
, 0, src
, type
);
1132 if (dst
&& type
== isl_dim_param
) {
1134 for (i
= 0; i
<= 1; ++i
) {
1135 if (!dst
->nested
[i
])
1137 dst
->nested
[i
] = isl_dim_replace(dst
->nested
[i
],
1139 if (!dst
->nested
[i
])