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 if (pos
== isl_dim_total(dim
))
124 if (pos
>= dim
->n_name
) {
127 dim
= extend_names(dim
);
132 dim
->names
[pos
] = name
;
136 isl_name_free(ctx
, name
);
141 static struct isl_name
*get_name(struct isl_dim
*dim
,
142 enum isl_dim_type type
, unsigned pos
)
147 pos
= global_pos(dim
, type
, pos
);
148 if (pos
== isl_dim_total(dim
))
150 if (pos
>= dim
->n_name
)
152 return dim
->names
[pos
];
155 static unsigned offset(struct isl_dim
*dim
, enum isl_dim_type type
)
158 case isl_dim_param
: return 0;
159 case isl_dim_in
: return dim
->nparam
;
160 case isl_dim_out
: return dim
->nparam
+ dim
->n_in
;
165 static unsigned n(struct isl_dim
*dim
, enum isl_dim_type type
)
168 case isl_dim_param
: return dim
->nparam
;
169 case isl_dim_in
: return dim
->n_in
;
170 case isl_dim_out
: return dim
->n_out
;
171 case isl_dim_all
: return dim
->nparam
+ dim
->n_in
+ dim
->n_out
;
176 unsigned isl_dim_size(struct isl_dim
*dim
, enum isl_dim_type type
)
183 unsigned isl_dim_offset(__isl_keep isl_dim
*dim
, enum isl_dim_type type
)
187 return offset(dim
, type
);
190 static struct isl_dim
*copy_names(struct isl_dim
*dst
,
191 enum isl_dim_type dst_type
, unsigned offset
, struct isl_dim
*src
,
192 enum isl_dim_type src_type
)
195 struct isl_name
*name
;
200 for (i
= 0; i
< n(src
, src_type
); ++i
) {
201 name
= get_name(src
, src_type
, i
);
204 dst
= set_name(dst
, dst_type
, offset
+ i
,
205 isl_name_copy(dst
->ctx
, name
));
212 struct isl_dim
*isl_dim_dup(struct isl_dim
*dim
)
217 dup
= isl_dim_alloc(dim
->ctx
, dim
->nparam
, dim
->n_in
, dim
->n_out
);
218 if (dim
->tuple_name
[0] &&
219 !(dup
->tuple_name
[0] = isl_name_copy(dim
->ctx
, dim
->tuple_name
[0])))
221 if (dim
->tuple_name
[1] &&
222 !(dup
->tuple_name
[1] = isl_name_copy(dim
->ctx
, dim
->tuple_name
[1])))
224 if (dim
->nested
[0] && !(dup
->nested
[0] = isl_dim_copy(dim
->nested
[0])))
226 if (dim
->nested
[1] && !(dup
->nested
[1] = isl_dim_copy(dim
->nested
[1])))
230 dup
= copy_names(dup
, isl_dim_param
, 0, dim
, isl_dim_param
);
231 dup
= copy_names(dup
, isl_dim_in
, 0, dim
, isl_dim_in
);
232 dup
= copy_names(dup
, isl_dim_out
, 0, dim
, isl_dim_out
);
239 struct isl_dim
*isl_dim_cow(struct isl_dim
*dim
)
247 return isl_dim_dup(dim
);
250 struct isl_dim
*isl_dim_copy(struct isl_dim
*dim
)
259 void isl_dim_free(struct isl_dim
*dim
)
269 isl_name_free(dim
->ctx
, dim
->tuple_name
[0]);
270 isl_name_free(dim
->ctx
, dim
->tuple_name
[1]);
272 isl_dim_free(dim
->nested
[0]);
273 isl_dim_free(dim
->nested
[1]);
275 for (i
= 0; i
< dim
->n_name
; ++i
)
276 isl_name_free(dim
->ctx
, dim
->names
[i
]);
278 isl_ctx_deref(dim
->ctx
);
283 static int name_ok(isl_ctx
*ctx
, const char *s
)
288 dummy
= strtol(s
, &p
, 0);
290 isl_die(ctx
, isl_error_invalid
, "name looks like a number",
296 __isl_give isl_dim
*isl_dim_set_tuple_name(__isl_take isl_dim
*dim
,
297 enum isl_dim_type type
, const char *s
)
299 struct isl_name
*name
;
301 dim
= isl_dim_cow(dim
);
304 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
305 isl_die(dim
->ctx
, isl_error_invalid
,
306 "only input, output and set tuples can have names",
311 if (!name_ok(dim
->ctx
, s
))
313 name
= isl_name_get(dim
->ctx
, s
);
318 isl_name_free(dim
->ctx
, dim
->tuple_name
[type
- isl_dim_in
]);
319 dim
->tuple_name
[type
- isl_dim_in
] = name
;
327 const char *isl_dim_get_tuple_name(__isl_keep isl_dim
*dim
,
328 enum isl_dim_type type
)
330 struct isl_name
*name
;
333 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
335 name
= dim
->tuple_name
[type
- isl_dim_in
];
336 return name
? name
->name
: NULL
;
339 struct isl_dim
*isl_dim_set_name(struct isl_dim
*dim
,
340 enum isl_dim_type type
, unsigned pos
,
343 struct isl_name
*name
;
347 if (!name_ok(dim
->ctx
, s
))
349 isl_name_free(dim
->ctx
, get_name(dim
, type
, pos
));
350 name
= isl_name_get(dim
->ctx
, s
);
353 return set_name(dim
, type
, pos
, name
);
359 const char *isl_dim_get_name(struct isl_dim
*dim
,
360 enum isl_dim_type type
, unsigned pos
)
362 struct isl_name
*name
= get_name(dim
, type
, pos
);
363 return name
? name
->name
: NULL
;
366 static struct isl_name
*tuple_name(__isl_keep isl_dim
*dim
,
367 enum isl_dim_type type
)
371 if (type
== isl_dim_in
)
372 return dim
->tuple_name
[0];
373 if (type
== isl_dim_out
)
374 return dim
->tuple_name
[1];
378 static __isl_keep isl_dim
*nested(__isl_keep isl_dim
*dim
,
379 enum isl_dim_type type
)
383 if (type
== isl_dim_in
)
384 return dim
->nested
[0];
385 if (type
== isl_dim_out
)
386 return dim
->nested
[1];
390 int isl_dim_tuple_match(__isl_keep isl_dim
*dim1
, enum isl_dim_type dim1_type
,
391 __isl_keep isl_dim
*dim2
, enum isl_dim_type dim2_type
)
393 struct isl_name
*name1
, *name2
;
394 isl_dim
*nested1
, *nested2
;
396 if (n(dim1
, dim1_type
) != n(dim2
, dim2_type
))
398 name1
= tuple_name(dim1
, dim1_type
);
399 name2
= tuple_name(dim2
, dim2_type
);
402 if (name1
&& name1
->name
!= name2
->name
)
404 nested1
= nested(dim1
, dim1_type
);
405 nested2
= nested(dim2
, dim2_type
);
406 if (!nested1
^ !nested2
)
408 if (nested1
&& !isl_dim_equal(nested1
, nested2
))
413 static int match(struct isl_dim
*dim1
, enum isl_dim_type dim1_type
,
414 struct isl_dim
*dim2
, enum isl_dim_type dim2_type
)
418 if (!isl_dim_tuple_match(dim1
, dim1_type
, dim2
, dim2_type
))
421 if (!dim1
->names
&& !dim2
->names
)
424 for (i
= 0; i
< n(dim1
, dim1_type
); ++i
) {
425 if (get_name(dim1
, dim1_type
, i
) !=
426 get_name(dim2
, dim2_type
, i
))
432 int isl_dim_match(struct isl_dim
*dim1
, enum isl_dim_type dim1_type
,
433 struct isl_dim
*dim2
, enum isl_dim_type dim2_type
)
435 return match(dim1
, dim1_type
, dim2
, dim2_type
);
438 static void get_names(struct isl_dim
*dim
, enum isl_dim_type type
,
439 unsigned first
, unsigned n
, struct isl_name
**names
)
443 for (i
= 0; i
< n
; ++i
)
444 names
[i
] = get_name(dim
, type
, first
+i
);
447 struct isl_dim
*isl_dim_extend(struct isl_dim
*dim
,
448 unsigned nparam
, unsigned n_in
, unsigned n_out
)
450 struct isl_name
**names
= NULL
;
454 if (dim
->nparam
== nparam
&& dim
->n_in
== n_in
&& dim
->n_out
== n_out
)
457 isl_assert(dim
->ctx
, dim
->nparam
<= nparam
, goto error
);
458 isl_assert(dim
->ctx
, dim
->n_in
<= n_in
, goto error
);
459 isl_assert(dim
->ctx
, dim
->n_out
<= n_out
, goto error
);
461 dim
= isl_dim_cow(dim
);
464 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
465 nparam
+ n_in
+ n_out
);
468 get_names(dim
, isl_dim_param
, 0, dim
->nparam
, names
);
469 get_names(dim
, isl_dim_in
, 0, dim
->n_in
, names
+ nparam
);
470 get_names(dim
, isl_dim_out
, 0, dim
->n_out
,
471 names
+ nparam
+ n_in
);
474 dim
->n_name
= nparam
+ n_in
+ n_out
;
476 dim
->nparam
= nparam
;
487 struct isl_dim
*isl_dim_add(struct isl_dim
*dim
, enum isl_dim_type type
,
492 dim
= isl_dim_reset(dim
, type
);
495 dim
= isl_dim_extend(dim
,
496 dim
->nparam
+ n
, dim
->n_in
, dim
->n_out
);
497 if (dim
&& dim
->nested
[0] &&
498 !(dim
->nested
[0] = isl_dim_add(dim
->nested
[0],
501 if (dim
&& dim
->nested
[1] &&
502 !(dim
->nested
[1] = isl_dim_add(dim
->nested
[1],
507 return isl_dim_extend(dim
,
508 dim
->nparam
, dim
->n_in
+ n
, dim
->n_out
);
510 return isl_dim_extend(dim
,
511 dim
->nparam
, dim
->n_in
, dim
->n_out
+ n
);
519 __isl_give isl_dim
*isl_dim_insert(__isl_take isl_dim
*dim
,
520 enum isl_dim_type type
, unsigned pos
, unsigned n
)
522 struct isl_name
**names
= NULL
;
527 return isl_dim_reset(dim
, type
);
529 isl_assert(dim
->ctx
, pos
<= isl_dim_size(dim
, type
), goto error
);
531 dim
= isl_dim_cow(dim
);
539 int *size
= s
- isl_dim_param
;
540 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
541 dim
->nparam
+ dim
->n_in
+ dim
->n_out
+ n
);
545 size
[isl_dim_param
] = dim
->nparam
;
546 size
[isl_dim_in
] = dim
->n_in
;
547 size
[isl_dim_out
] = dim
->n_out
;
548 for (t
= isl_dim_param
; t
<= isl_dim_out
; ++t
) {
550 get_names(dim
, t
, 0, size
[t
], names
+ off
);
553 get_names(dim
, t
, 0, pos
, names
+ off
);
555 get_names(dim
, t
, pos
, size
[t
]-pos
, names
+off
);
556 off
+= size
[t
] - pos
;
561 dim
->n_name
= dim
->nparam
+ dim
->n_in
+ dim
->n_out
+ n
;
564 case isl_dim_param
: dim
->nparam
+= n
; break;
565 case isl_dim_in
: dim
->n_in
+= n
; break;
566 case isl_dim_out
: dim
->n_out
+= n
; break;
568 dim
= isl_dim_reset(dim
, type
);
576 __isl_give isl_dim
*isl_dim_move(__isl_take isl_dim
*dim
,
577 enum isl_dim_type dst_type
, unsigned dst_pos
,
578 enum isl_dim_type src_type
, unsigned src_pos
, unsigned n
)
587 isl_assert(dim
->ctx
, src_pos
+ n
<= isl_dim_size(dim
, src_type
),
590 if (dst_type
== src_type
&& dst_pos
== src_pos
)
593 isl_assert(dim
->ctx
, dst_type
!= src_type
, goto error
);
595 dim
= isl_dim_reset(dim
, src_type
);
596 dim
= isl_dim_reset(dim
, dst_type
);
598 dim
= isl_dim_cow(dim
);
603 struct isl_name
**names
;
607 int *size
= s
- isl_dim_param
;
608 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
609 dim
->nparam
+ dim
->n_in
+ dim
->n_out
);
613 size
[isl_dim_param
] = dim
->nparam
;
614 size
[isl_dim_in
] = dim
->n_in
;
615 size
[isl_dim_out
] = dim
->n_out
;
616 for (t
= isl_dim_param
; t
<= isl_dim_out
; ++t
) {
618 get_names(dim
, t
, 0, dst_pos
, names
+ off
);
620 get_names(dim
, src_type
, src_pos
, n
, names
+off
);
622 get_names(dim
, t
, dst_pos
, size
[t
] - dst_pos
,
624 off
+= size
[t
] - dst_pos
;
625 } else if (t
== src_type
) {
626 get_names(dim
, t
, 0, src_pos
, names
+ off
);
628 get_names(dim
, t
, src_pos
+ n
,
629 size
[t
] - src_pos
- n
, names
+ off
);
630 off
+= size
[t
] - src_pos
- n
;
632 get_names(dim
, t
, 0, size
[t
], names
+ off
);
638 dim
->n_name
= dim
->nparam
+ dim
->n_in
+ dim
->n_out
;
642 case isl_dim_param
: dim
->nparam
+= n
; break;
643 case isl_dim_in
: dim
->n_in
+= n
; break;
644 case isl_dim_out
: dim
->n_out
+= n
; break;
648 case isl_dim_param
: dim
->nparam
-= n
; break;
649 case isl_dim_in
: dim
->n_in
-= n
; break;
650 case isl_dim_out
: dim
->n_out
-= n
; break;
653 if (dst_type
!= isl_dim_param
&& src_type
!= isl_dim_param
)
656 for (i
= 0; i
< 2; ++i
) {
659 dim
->nested
[i
] = isl_dim_replace(dim
->nested
[i
],
671 struct isl_dim
*isl_dim_join(struct isl_dim
*left
, struct isl_dim
*right
)
678 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
680 isl_assert(left
->ctx
,
681 isl_dim_tuple_match(left
, isl_dim_out
, right
, isl_dim_in
),
684 dim
= isl_dim_alloc(left
->ctx
, left
->nparam
, left
->n_in
, right
->n_out
);
688 dim
= copy_names(dim
, isl_dim_param
, 0, left
, isl_dim_param
);
689 dim
= copy_names(dim
, isl_dim_in
, 0, left
, isl_dim_in
);
690 dim
= copy_names(dim
, isl_dim_out
, 0, right
, isl_dim_out
);
692 if (dim
&& left
->tuple_name
[0] &&
693 !(dim
->tuple_name
[0] = isl_name_copy(dim
->ctx
, left
->tuple_name
[0])))
695 if (dim
&& right
->tuple_name
[1] &&
696 !(dim
->tuple_name
[1] = isl_name_copy(dim
->ctx
, right
->tuple_name
[1])))
698 if (dim
&& left
->nested
[0] &&
699 !(dim
->nested
[0] = isl_dim_copy(left
->nested
[0])))
701 if (dim
&& right
->nested
[1] &&
702 !(dim
->nested
[1] = isl_dim_copy(right
->nested
[1])))
715 struct isl_dim
*isl_dim_product(struct isl_dim
*left
, struct isl_dim
*right
)
717 isl_dim
*dom1
, *dom2
, *nest1
, *nest2
;
722 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
725 dom1
= isl_dim_domain(isl_dim_copy(left
));
726 dom2
= isl_dim_domain(isl_dim_copy(right
));
727 nest1
= isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1
), dom2
));
729 dom1
= isl_dim_range(left
);
730 dom2
= isl_dim_range(right
);
731 nest2
= isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1
), dom2
));
733 return isl_dim_join(isl_dim_reverse(nest1
), nest2
);
740 __isl_give isl_dim
*isl_dim_range_product(__isl_take isl_dim
*left
,
741 __isl_take isl_dim
*right
)
743 isl_dim
*dom
, *ran1
, *ran2
, *nest
;
748 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
750 if (!isl_dim_match(left
, isl_dim_in
, right
, isl_dim_in
))
751 isl_die(left
->ctx
, isl_error_invalid
,
752 "domains need to match", goto error
);
754 dom
= isl_dim_domain(isl_dim_copy(left
));
756 ran1
= isl_dim_range(left
);
757 ran2
= isl_dim_range(right
);
758 nest
= isl_dim_wrap(isl_dim_join(isl_dim_reverse(ran1
), ran2
));
760 return isl_dim_join(isl_dim_reverse(dom
), nest
);
767 __isl_give isl_dim
*isl_dim_map_from_set(__isl_take isl_dim
*dim
)
769 struct isl_name
**names
= NULL
;
773 isl_assert(dim
->ctx
, dim
->n_in
== 0, goto error
);
774 if (dim
->n_out
== 0 && !isl_dim_is_named_or_nested(dim
, isl_dim_out
))
776 dim
= isl_dim_cow(dim
);
780 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
781 dim
->nparam
+ dim
->n_out
+ dim
->n_out
);
784 get_names(dim
, isl_dim_param
, 0, dim
->nparam
, names
);
785 get_names(dim
, isl_dim_out
, 0, dim
->n_out
, names
+ dim
->nparam
);
787 dim
->n_in
= dim
->n_out
;
791 dim
->n_name
= dim
->nparam
+ dim
->n_out
+ dim
->n_out
;
792 dim
= copy_names(dim
, isl_dim_out
, 0, dim
, isl_dim_in
);
794 isl_name_free(dim
->ctx
, dim
->tuple_name
[0]);
795 dim
->tuple_name
[0] = isl_name_copy(dim
->ctx
, dim
->tuple_name
[1]);
796 isl_dim_free(dim
->nested
[0]);
797 dim
->nested
[0] = isl_dim_copy(dim
->nested
[1]);
804 static struct isl_dim
*set_names(struct isl_dim
*dim
, enum isl_dim_type type
,
805 unsigned first
, unsigned n
, struct isl_name
**names
)
809 for (i
= 0; i
< n
; ++i
)
810 dim
= set_name(dim
, type
, first
+i
, names
[i
]);
815 struct isl_dim
*isl_dim_reverse(struct isl_dim
*dim
)
819 struct isl_name
**names
= NULL
;
820 struct isl_name
*name
;
824 if (match(dim
, isl_dim_in
, dim
, isl_dim_out
))
827 dim
= isl_dim_cow(dim
);
831 name
= dim
->tuple_name
[0];
832 dim
->tuple_name
[0] = dim
->tuple_name
[1];
833 dim
->tuple_name
[1] = name
;
835 nested
= dim
->nested
[0];
836 dim
->nested
[0] = dim
->nested
[1];
837 dim
->nested
[1] = nested
;
840 names
= isl_alloc_array(dim
->ctx
, struct isl_name
*,
841 dim
->n_in
+ dim
->n_out
);
844 get_names(dim
, isl_dim_in
, 0, dim
->n_in
, names
);
845 get_names(dim
, isl_dim_out
, 0, dim
->n_out
, names
+ dim
->n_in
);
849 dim
->n_in
= dim
->n_out
;
853 dim
= set_names(dim
, isl_dim_out
, 0, dim
->n_out
, names
);
854 dim
= set_names(dim
, isl_dim_in
, 0, dim
->n_in
, names
+ dim
->n_out
);
865 struct isl_dim
*isl_dim_drop(struct isl_dim
*dim
, enum isl_dim_type type
,
866 unsigned first
, unsigned num
)
874 return isl_dim_reset(dim
, type
);
876 isl_assert(dim
->ctx
, first
+ num
<= n(dim
, type
), goto error
);
877 dim
= isl_dim_cow(dim
);
881 dim
= extend_names(dim
);
884 for (i
= 0; i
< num
; ++i
)
885 isl_name_free(dim
->ctx
, get_name(dim
, type
, first
+i
));
886 for (i
= first
+num
; i
< n(dim
, type
); ++i
)
887 set_name(dim
, type
, i
- num
, get_name(dim
, type
, i
));
890 get_names(dim
, isl_dim_in
, 0, dim
->n_in
,
891 dim
->names
+ offset(dim
, isl_dim_in
) - num
);
893 get_names(dim
, isl_dim_out
, 0, dim
->n_out
,
894 dim
->names
+ offset(dim
, isl_dim_out
) - num
);
901 case isl_dim_param
: dim
->nparam
-= num
; break;
902 case isl_dim_in
: dim
->n_in
-= num
; break;
903 case isl_dim_out
: dim
->n_out
-= num
; break;
905 dim
= isl_dim_reset(dim
, type
);
906 if (type
== isl_dim_param
) {
907 if (dim
&& dim
->nested
[0] &&
908 !(dim
->nested
[0] = isl_dim_drop(dim
->nested
[0],
909 isl_dim_param
, first
, num
)))
911 if (dim
&& dim
->nested
[1] &&
912 !(dim
->nested
[1] = isl_dim_drop(dim
->nested
[1],
913 isl_dim_param
, first
, num
)))
922 struct isl_dim
*isl_dim_drop_inputs(struct isl_dim
*dim
,
923 unsigned first
, unsigned n
)
927 return isl_dim_drop(dim
, isl_dim_in
, first
, n
);
930 struct isl_dim
*isl_dim_drop_outputs(struct isl_dim
*dim
,
931 unsigned first
, unsigned n
)
935 return isl_dim_drop(dim
, isl_dim_out
, first
, n
);
938 struct isl_dim
*isl_dim_domain(struct isl_dim
*dim
)
942 dim
= isl_dim_drop_outputs(dim
, 0, dim
->n_out
);
943 return isl_dim_reverse(dim
);
946 __isl_give isl_dim
*isl_dim_from_domain(__isl_take isl_dim
*dim
)
948 return isl_dim_reverse(dim
);
951 struct isl_dim
*isl_dim_range(struct isl_dim
*dim
)
955 return isl_dim_drop_inputs(dim
, 0, dim
->n_in
);
958 __isl_give isl_dim
*isl_dim_from_range(__isl_take isl_dim
*dim
)
963 __isl_give isl_dim
*isl_dim_as_set_dim(__isl_take isl_dim
*dim
)
965 dim
= isl_dim_cow(dim
);
969 dim
->n_out
+= dim
->n_in
;
971 dim
= isl_dim_reset(dim
, isl_dim_in
);
972 dim
= isl_dim_reset(dim
, isl_dim_out
);
977 struct isl_dim
*isl_dim_underlying(struct isl_dim
*dim
, unsigned n_div
)
984 dim
->nparam
== 0 && dim
->n_in
== 0 && dim
->n_name
== 0)
985 return isl_dim_reset(isl_dim_reset(dim
, isl_dim_in
), isl_dim_out
);
986 dim
= isl_dim_cow(dim
);
989 dim
->n_out
+= dim
->nparam
+ dim
->n_in
+ n_div
;
993 for (i
= 0; i
< dim
->n_name
; ++i
)
994 isl_name_free(dim
->ctx
, get_name(dim
, isl_dim_out
, i
));
996 dim
= isl_dim_reset(dim
, isl_dim_in
);
997 dim
= isl_dim_reset(dim
, isl_dim_out
);
1002 unsigned isl_dim_total(struct isl_dim
*dim
)
1004 return dim
? dim
->nparam
+ dim
->n_in
+ dim
->n_out
: 0;
1007 int isl_dim_equal(struct isl_dim
*dim1
, struct isl_dim
*dim2
)
1009 return match(dim1
, isl_dim_param
, dim2
, isl_dim_param
) &&
1010 isl_dim_tuple_match(dim1
, isl_dim_in
, dim2
, isl_dim_in
) &&
1011 isl_dim_tuple_match(dim1
, isl_dim_out
, dim2
, isl_dim_out
);
1014 int isl_dim_compatible(struct isl_dim
*dim1
, struct isl_dim
*dim2
)
1016 return dim1
->nparam
== dim2
->nparam
&&
1017 dim1
->n_in
+ dim1
->n_out
== dim2
->n_in
+ dim2
->n_out
;
1020 static uint32_t isl_hash_dim(uint32_t hash
, __isl_keep isl_dim
*dim
)
1023 struct isl_name
*name
;
1028 hash
= isl_hash_builtin(hash
, dim
->nparam
);
1029 hash
= isl_hash_builtin(hash
, dim
->n_in
);
1030 hash
= isl_hash_builtin(hash
, dim
->n_out
);
1032 for (i
= 0; i
< dim
->nparam
; ++i
) {
1033 name
= get_name(dim
, isl_dim_param
, i
);
1034 hash
= isl_hash_name(hash
, name
);
1037 name
= tuple_name(dim
, isl_dim_in
);
1038 hash
= isl_hash_name(hash
, name
);
1039 name
= tuple_name(dim
, isl_dim_out
);
1040 hash
= isl_hash_name(hash
, name
);
1042 hash
= isl_hash_dim(hash
, dim
->nested
[0]);
1043 hash
= isl_hash_dim(hash
, dim
->nested
[1]);
1048 uint32_t isl_dim_get_hash(__isl_keep isl_dim
*dim
)
1055 hash
= isl_hash_init();
1056 hash
= isl_hash_dim(hash
, dim
);
1061 int isl_dim_is_wrapping(__isl_keep isl_dim
*dim
)
1066 if (dim
->n_in
!= 0 || dim
->tuple_name
[0] || dim
->nested
[0])
1069 return dim
->nested
[1] != NULL
;
1072 __isl_give isl_dim
*isl_dim_wrap(__isl_take isl_dim
*dim
)
1079 wrap
= isl_dim_alloc(dim
->ctx
, dim
->nparam
, 0, dim
->n_in
+ dim
->n_out
);
1081 wrap
= copy_names(wrap
, isl_dim_param
, 0, dim
, isl_dim_param
);
1082 wrap
= copy_names(wrap
, isl_dim_set
, 0, dim
, isl_dim_in
);
1083 wrap
= copy_names(wrap
, isl_dim_set
, dim
->n_in
, dim
, isl_dim_out
);
1088 wrap
->nested
[1] = dim
;
1096 __isl_give isl_dim
*isl_dim_unwrap(__isl_take isl_dim
*dim
)
1103 if (!isl_dim_is_wrapping(dim
))
1104 isl_die(dim
->ctx
, isl_error_invalid
, "not a wrapping dim",
1107 unwrap
= isl_dim_copy(dim
->nested
[1]);
1116 int isl_dim_is_named_or_nested(__isl_keep isl_dim
*dim
, enum isl_dim_type type
)
1118 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
1122 if (dim
->tuple_name
[type
- isl_dim_in
])
1124 if (dim
->nested
[type
- isl_dim_in
])
1129 __isl_give isl_dim
*isl_dim_reset(__isl_take isl_dim
*dim
,
1130 enum isl_dim_type type
)
1132 if (!isl_dim_is_named_or_nested(dim
, type
))
1135 dim
= isl_dim_cow(dim
);
1139 isl_name_free(dim
->ctx
, dim
->tuple_name
[type
- isl_dim_in
]);
1140 dim
->tuple_name
[type
- isl_dim_in
] = NULL
;
1141 isl_dim_free(dim
->nested
[type
- isl_dim_in
]);
1142 dim
->nested
[type
- isl_dim_in
] = NULL
;
1147 __isl_give isl_dim
*isl_dim_flatten(__isl_take isl_dim
*dim
)
1151 if (!dim
->nested
[0] && !dim
->nested
[1])
1155 dim
= isl_dim_reset(dim
, isl_dim_in
);
1156 if (dim
&& dim
->nested
[1])
1157 dim
= isl_dim_reset(dim
, isl_dim_out
);
1162 /* Replace the dimensions of the given type of dst by those of src.
1164 __isl_give isl_dim
*isl_dim_replace(__isl_take isl_dim
*dst
,
1165 enum isl_dim_type type
, __isl_keep isl_dim
*src
)
1167 dst
= isl_dim_cow(dst
);
1172 dst
= isl_dim_drop(dst
, type
, 0, isl_dim_size(dst
, type
));
1173 dst
= isl_dim_add(dst
, type
, isl_dim_size(src
, type
));
1174 dst
= copy_names(dst
, type
, 0, src
, type
);
1176 if (dst
&& type
== isl_dim_param
) {
1178 for (i
= 0; i
<= 1; ++i
) {
1179 if (!dst
->nested
[i
])
1181 dst
->nested
[i
] = isl_dim_replace(dst
->nested
[i
],
1183 if (!dst
->nested
[i
])
1194 /* Given a dimension specification "dim" of a set, create a dimension
1195 * specification for the lift of the set. In particular, the result
1196 * is of the form [dim -> local[..]], with n_local variables in the
1197 * range of the wrapped map.
1199 __isl_give isl_dim
*isl_dim_lift(__isl_take isl_dim
*dim
, unsigned n_local
)
1206 local_dim
= isl_dim_dup(dim
);
1207 local_dim
= isl_dim_drop(local_dim
, isl_dim_set
, 0, dim
->n_out
);
1208 local_dim
= isl_dim_add(local_dim
, isl_dim_set
, n_local
);
1209 local_dim
= isl_dim_set_tuple_name(local_dim
, isl_dim_set
, "local");
1210 dim
= isl_dim_join(isl_dim_from_domain(dim
),
1211 isl_dim_from_range(local_dim
));
1212 dim
= isl_dim_wrap(dim
);
1213 dim
= isl_dim_set_tuple_name(dim
, isl_dim_set
, "lifted");
1218 int isl_dim_can_zip(__isl_keep isl_dim
*dim
)
1223 return dim
->nested
[0] && dim
->nested
[1];
1226 __isl_give isl_dim
*isl_dim_zip(__isl_take isl_dim
*dim
)
1229 isl_dim
*dom_dom
, *dom_ran
, *ran_dom
, *ran_ran
;
1231 if (!isl_dim_can_zip(dim
))
1232 isl_die(dim
->ctx
, isl_error_invalid
, "dim cannot be zipped",
1237 dom
= isl_dim_unwrap(isl_dim_domain(isl_dim_copy(dim
)));
1238 ran
= isl_dim_unwrap(isl_dim_range(dim
));
1239 dom_dom
= isl_dim_domain(isl_dim_copy(dom
));
1240 dom_ran
= isl_dim_range(dom
);
1241 ran_dom
= isl_dim_domain(isl_dim_copy(ran
));
1242 ran_ran
= isl_dim_range(ran
);
1243 dom
= isl_dim_join(isl_dim_from_domain(dom_dom
),
1244 isl_dim_from_range(ran_dom
));
1245 ran
= isl_dim_join(isl_dim_from_domain(dom_ran
),
1246 isl_dim_from_range(ran_ran
));
1247 return isl_dim_join(isl_dim_from_domain(isl_dim_wrap(dom
)),
1248 isl_dim_from_range(isl_dim_wrap(ran
)));
1254 int isl_dim_has_named_params(__isl_keep isl_dim
*dim
)
1261 if (dim
->nparam
== 0)
1263 off
= isl_dim_offset(dim
, isl_dim_param
);
1264 if (off
+ dim
->nparam
> dim
->n_name
)
1266 for (i
= 0; i
< dim
->nparam
; ++i
)
1267 if (!dim
->names
[off
+ i
])