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
;
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 struct isl_dim
*copy_names(struct isl_dim
*dst
,
190 enum isl_dim_type dst_type
, unsigned offset
, struct isl_dim
*src
,
191 enum isl_dim_type src_type
)
194 struct isl_name
*name
;
199 for (i
= 0; i
< n(src
, src_type
); ++i
) {
200 name
= get_name(src
, src_type
, i
);
203 dst
= set_name(dst
, dst_type
, offset
+ i
,
204 isl_name_copy(dst
->ctx
, name
));
211 struct isl_dim
*isl_dim_dup(struct isl_dim
*dim
)
216 dup
= isl_dim_alloc(dim
->ctx
, dim
->nparam
, dim
->n_in
, dim
->n_out
);
217 if (dim
->tuple_name
[0] &&
218 !(dup
->tuple_name
[0] = isl_name_copy(dim
->ctx
, dim
->tuple_name
[0])))
220 if (dim
->tuple_name
[1] &&
221 !(dup
->tuple_name
[1] = isl_name_copy(dim
->ctx
, dim
->tuple_name
[1])))
223 if (dim
->nested
[0] && !(dup
->nested
[0] = isl_dim_copy(dim
->nested
[0])))
225 if (dim
->nested
[1] && !(dup
->nested
[1] = isl_dim_copy(dim
->nested
[1])))
229 dup
= copy_names(dup
, isl_dim_param
, 0, dim
, isl_dim_param
);
230 dup
= copy_names(dup
, isl_dim_in
, 0, dim
, isl_dim_in
);
231 dup
= copy_names(dup
, isl_dim_out
, 0, dim
, isl_dim_out
);
238 struct isl_dim
*isl_dim_cow(struct isl_dim
*dim
)
246 return isl_dim_dup(dim
);
249 struct isl_dim
*isl_dim_copy(struct isl_dim
*dim
)
258 void isl_dim_free(struct isl_dim
*dim
)
268 isl_name_free(dim
->ctx
, dim
->tuple_name
[0]);
269 isl_name_free(dim
->ctx
, dim
->tuple_name
[1]);
271 isl_dim_free(dim
->nested
[0]);
272 isl_dim_free(dim
->nested
[1]);
274 for (i
= 0; i
< dim
->n_name
; ++i
)
275 isl_name_free(dim
->ctx
, dim
->names
[i
]);
277 isl_ctx_deref(dim
->ctx
);
282 static int name_ok(isl_ctx
*ctx
, const char *s
)
287 dummy
= strtol(s
, &p
, 0);
289 isl_die(ctx
, isl_error_invalid
, "name looks like a number",
295 __isl_give isl_dim
*isl_dim_set_tuple_name(__isl_take isl_dim
*dim
,
296 enum isl_dim_type type
, const char *s
)
298 struct isl_name
*name
;
300 dim
= isl_dim_cow(dim
);
303 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
304 isl_die(dim
->ctx
, isl_error_invalid
,
305 "only input, output and set tuples can have names",
310 if (!name_ok(dim
->ctx
, s
))
312 name
= isl_name_get(dim
->ctx
, s
);
317 isl_name_free(dim
->ctx
, dim
->tuple_name
[type
- isl_dim_in
]);
318 dim
->tuple_name
[type
- isl_dim_in
] = name
;
326 const char *isl_dim_get_tuple_name(__isl_keep isl_dim
*dim
,
327 enum isl_dim_type type
)
329 struct isl_name
*name
;
332 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
334 name
= dim
->tuple_name
[type
- isl_dim_in
];
335 return name
? name
->name
: NULL
;
338 struct isl_dim
*isl_dim_set_name(struct isl_dim
*dim
,
339 enum isl_dim_type type
, unsigned pos
,
342 struct isl_name
*name
;
346 if (!name_ok(dim
->ctx
, s
))
348 isl_name_free(dim
->ctx
, get_name(dim
, type
, pos
));
349 name
= isl_name_get(dim
->ctx
, s
);
352 return set_name(dim
, type
, pos
, name
);
358 const char *isl_dim_get_name(struct isl_dim
*dim
,
359 enum isl_dim_type type
, unsigned pos
)
361 struct isl_name
*name
= get_name(dim
, type
, pos
);
362 return name
? name
->name
: NULL
;
365 static struct isl_name
*tuple_name(__isl_keep isl_dim
*dim
,
366 enum isl_dim_type type
)
370 if (type
== isl_dim_in
)
371 return dim
->tuple_name
[0];
372 if (type
== isl_dim_out
)
373 return dim
->tuple_name
[1];
377 static __isl_keep isl_dim
*nested(__isl_keep isl_dim
*dim
,
378 enum isl_dim_type type
)
382 if (type
== isl_dim_in
)
383 return dim
->nested
[0];
384 if (type
== isl_dim_out
)
385 return dim
->nested
[1];
389 int isl_dim_tuple_match(__isl_keep isl_dim
*dim1
, enum isl_dim_type dim1_type
,
390 __isl_keep isl_dim
*dim2
, enum isl_dim_type dim2_type
)
392 struct isl_name
*name1
, *name2
;
393 isl_dim
*nested1
, *nested2
;
395 if (n(dim1
, dim1_type
) != n(dim2
, dim2_type
))
397 name1
= tuple_name(dim1
, dim1_type
);
398 name2
= tuple_name(dim2
, dim2_type
);
401 if (name1
&& name1
->name
!= name2
->name
)
403 nested1
= nested(dim1
, dim1_type
);
404 nested2
= nested(dim2
, dim2_type
);
405 if (!nested1
^ !nested2
)
407 if (nested1
&& !isl_dim_equal(nested1
, nested2
))
412 static int match(struct isl_dim
*dim1
, enum isl_dim_type dim1_type
,
413 struct isl_dim
*dim2
, enum isl_dim_type dim2_type
)
417 if (!isl_dim_tuple_match(dim1
, dim1_type
, dim2
, dim2_type
))
420 if (!dim1
->names
&& !dim2
->names
)
423 for (i
= 0; i
< n(dim1
, dim1_type
); ++i
) {
424 if (get_name(dim1
, dim1_type
, i
) !=
425 get_name(dim2
, dim2_type
, i
))
431 int isl_dim_match(struct isl_dim
*dim1
, enum isl_dim_type dim1_type
,
432 struct isl_dim
*dim2
, enum isl_dim_type dim2_type
)
434 return match(dim1
, dim1_type
, dim2
, dim2_type
);
437 static void get_names(struct isl_dim
*dim
, enum isl_dim_type type
,
438 unsigned first
, unsigned n
, struct isl_name
**names
)
442 for (i
= 0; i
< n
; ++i
)
443 names
[i
] = get_name(dim
, type
, first
+i
);
446 struct isl_dim
*isl_dim_extend(struct isl_dim
*dim
,
447 unsigned nparam
, unsigned n_in
, unsigned n_out
)
449 struct isl_name
**names
= NULL
;
453 if (dim
->nparam
== nparam
&& dim
->n_in
== n_in
&& dim
->n_out
== n_out
)
456 isl_assert(dim
->ctx
, dim
->nparam
<= nparam
, goto error
);
457 isl_assert(dim
->ctx
, dim
->n_in
<= n_in
, goto error
);
458 isl_assert(dim
->ctx
, dim
->n_out
<= n_out
, goto error
);
460 dim
= isl_dim_cow(dim
);
463 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
464 nparam
+ n_in
+ n_out
);
467 get_names(dim
, isl_dim_param
, 0, dim
->nparam
, names
);
468 get_names(dim
, isl_dim_in
, 0, dim
->n_in
, names
+ nparam
);
469 get_names(dim
, isl_dim_out
, 0, dim
->n_out
,
470 names
+ nparam
+ n_in
);
473 dim
->n_name
= nparam
+ n_in
+ n_out
;
475 dim
->nparam
= nparam
;
486 struct isl_dim
*isl_dim_add(struct isl_dim
*dim
, enum isl_dim_type type
,
491 dim
= isl_dim_reset(dim
, type
);
494 dim
= isl_dim_extend(dim
,
495 dim
->nparam
+ n
, dim
->n_in
, dim
->n_out
);
496 if (dim
&& dim
->nested
[0] &&
497 !(dim
->nested
[0] = isl_dim_add(dim
->nested
[0],
500 if (dim
&& dim
->nested
[1] &&
501 !(dim
->nested
[1] = isl_dim_add(dim
->nested
[1],
506 return isl_dim_extend(dim
,
507 dim
->nparam
, dim
->n_in
+ n
, dim
->n_out
);
509 return isl_dim_extend(dim
,
510 dim
->nparam
, dim
->n_in
, dim
->n_out
+ n
);
518 __isl_give isl_dim
*isl_dim_insert(__isl_take isl_dim
*dim
,
519 enum isl_dim_type type
, unsigned pos
, unsigned n
)
521 struct isl_name
**names
= NULL
;
526 return isl_dim_reset(dim
, type
);
528 isl_assert(dim
->ctx
, pos
<= isl_dim_size(dim
, type
), goto error
);
530 dim
= isl_dim_cow(dim
);
538 int *size
= s
- isl_dim_param
;
539 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
540 dim
->nparam
+ dim
->n_in
+ dim
->n_out
+ n
);
544 size
[isl_dim_param
] = dim
->nparam
;
545 size
[isl_dim_in
] = dim
->n_in
;
546 size
[isl_dim_out
] = dim
->n_out
;
547 for (t
= isl_dim_param
; t
<= isl_dim_out
; ++t
) {
549 get_names(dim
, t
, 0, size
[t
], names
+ off
);
552 get_names(dim
, t
, 0, pos
, names
+ off
);
554 get_names(dim
, t
, pos
, size
[t
]-pos
, names
+off
);
555 off
+= size
[t
] - pos
;
560 dim
->n_name
= dim
->nparam
+ dim
->n_in
+ dim
->n_out
+ n
;
563 case isl_dim_param
: dim
->nparam
+= n
; break;
564 case isl_dim_in
: dim
->n_in
+= n
; break;
565 case isl_dim_out
: dim
->n_out
+= n
; break;
567 dim
= isl_dim_reset(dim
, type
);
575 __isl_give isl_dim
*isl_dim_move(__isl_take isl_dim
*dim
,
576 enum isl_dim_type dst_type
, unsigned dst_pos
,
577 enum isl_dim_type src_type
, unsigned src_pos
, unsigned n
)
586 isl_assert(dim
->ctx
, src_pos
+ n
<= isl_dim_size(dim
, src_type
),
589 if (dst_type
== src_type
&& dst_pos
== src_pos
)
592 isl_assert(dim
->ctx
, dst_type
!= src_type
, goto error
);
594 dim
= isl_dim_reset(dim
, src_type
);
595 dim
= isl_dim_reset(dim
, dst_type
);
597 dim
= isl_dim_cow(dim
);
602 struct isl_name
**names
;
606 int *size
= s
- isl_dim_param
;
607 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
608 dim
->nparam
+ dim
->n_in
+ dim
->n_out
);
612 size
[isl_dim_param
] = dim
->nparam
;
613 size
[isl_dim_in
] = dim
->n_in
;
614 size
[isl_dim_out
] = dim
->n_out
;
615 for (t
= isl_dim_param
; t
<= isl_dim_out
; ++t
) {
617 get_names(dim
, t
, 0, dst_pos
, names
+ off
);
619 get_names(dim
, src_type
, src_pos
, n
, names
+off
);
621 get_names(dim
, t
, dst_pos
, size
[t
] - dst_pos
,
623 off
+= size
[t
] - dst_pos
;
624 } else if (t
== src_type
) {
625 get_names(dim
, t
, 0, src_pos
, names
+ off
);
627 get_names(dim
, t
, src_pos
+ n
,
628 size
[t
] - src_pos
- n
, names
+ off
);
629 off
+= size
[t
] - src_pos
- n
;
631 get_names(dim
, t
, 0, size
[t
], names
+ off
);
637 dim
->n_name
= dim
->nparam
+ dim
->n_in
+ dim
->n_out
;
641 case isl_dim_param
: dim
->nparam
+= n
; break;
642 case isl_dim_in
: dim
->n_in
+= n
; break;
643 case isl_dim_out
: dim
->n_out
+= n
; break;
647 case isl_dim_param
: dim
->nparam
-= n
; break;
648 case isl_dim_in
: dim
->n_in
-= n
; break;
649 case isl_dim_out
: dim
->n_out
-= n
; break;
652 if (dst_type
!= isl_dim_param
&& src_type
!= isl_dim_param
)
655 for (i
= 0; i
< 2; ++i
) {
658 dim
->nested
[i
] = isl_dim_replace(dim
->nested
[i
],
670 struct isl_dim
*isl_dim_join(struct isl_dim
*left
, struct isl_dim
*right
)
677 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
679 isl_assert(left
->ctx
,
680 isl_dim_tuple_match(left
, isl_dim_out
, right
, isl_dim_in
),
683 dim
= isl_dim_alloc(left
->ctx
, left
->nparam
, left
->n_in
, right
->n_out
);
687 dim
= copy_names(dim
, isl_dim_param
, 0, left
, isl_dim_param
);
688 dim
= copy_names(dim
, isl_dim_in
, 0, left
, isl_dim_in
);
689 dim
= copy_names(dim
, isl_dim_out
, 0, right
, isl_dim_out
);
691 if (dim
&& left
->tuple_name
[0] &&
692 !(dim
->tuple_name
[0] = isl_name_copy(dim
->ctx
, left
->tuple_name
[0])))
694 if (dim
&& right
->tuple_name
[1] &&
695 !(dim
->tuple_name
[1] = isl_name_copy(dim
->ctx
, right
->tuple_name
[1])))
697 if (dim
&& left
->nested
[0] &&
698 !(dim
->nested
[0] = isl_dim_copy(left
->nested
[0])))
700 if (dim
&& right
->nested
[1] &&
701 !(dim
->nested
[1] = isl_dim_copy(right
->nested
[1])))
714 struct isl_dim
*isl_dim_product(struct isl_dim
*left
, struct isl_dim
*right
)
716 isl_dim
*dom1
, *dom2
, *nest1
, *nest2
;
721 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
724 dom1
= isl_dim_domain(isl_dim_copy(left
));
725 dom2
= isl_dim_domain(isl_dim_copy(right
));
726 nest1
= isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1
), dom2
));
728 dom1
= isl_dim_range(left
);
729 dom2
= isl_dim_range(right
);
730 nest2
= isl_dim_wrap(isl_dim_join(isl_dim_reverse(dom1
), dom2
));
732 return isl_dim_join(isl_dim_reverse(nest1
), nest2
);
739 struct isl_dim
*isl_dim_map(struct isl_dim
*dim
)
741 struct isl_name
**names
= NULL
;
745 isl_assert(dim
->ctx
, dim
->n_in
== 0, goto error
);
746 if (dim
->n_out
== 0 && !isl_dim_is_named_or_nested(dim
, isl_dim_out
))
748 dim
= isl_dim_cow(dim
);
752 names
= isl_calloc_array(dim
->ctx
, struct isl_name
*,
753 dim
->nparam
+ dim
->n_out
+ dim
->n_out
);
756 get_names(dim
, isl_dim_param
, 0, dim
->nparam
, names
);
757 get_names(dim
, isl_dim_out
, 0, dim
->n_out
, names
+ dim
->nparam
);
759 dim
->n_in
= dim
->n_out
;
763 dim
->n_name
= dim
->nparam
+ dim
->n_out
+ dim
->n_out
;
764 dim
= copy_names(dim
, isl_dim_out
, 0, dim
, isl_dim_in
);
766 isl_name_free(dim
->ctx
, dim
->tuple_name
[0]);
767 dim
->tuple_name
[0] = isl_name_copy(dim
->ctx
, dim
->tuple_name
[1]);
768 isl_dim_free(dim
->nested
[0]);
769 dim
->nested
[0] = isl_dim_copy(dim
->nested
[1]);
776 static struct isl_dim
*set_names(struct isl_dim
*dim
, enum isl_dim_type type
,
777 unsigned first
, unsigned n
, struct isl_name
**names
)
781 for (i
= 0; i
< n
; ++i
)
782 dim
= set_name(dim
, type
, first
+i
, names
[i
]);
787 struct isl_dim
*isl_dim_reverse(struct isl_dim
*dim
)
791 struct isl_name
**names
= NULL
;
792 struct isl_name
*name
;
796 if (match(dim
, isl_dim_in
, dim
, isl_dim_out
))
799 dim
= isl_dim_cow(dim
);
803 name
= dim
->tuple_name
[0];
804 dim
->tuple_name
[0] = dim
->tuple_name
[1];
805 dim
->tuple_name
[1] = name
;
807 nested
= dim
->nested
[0];
808 dim
->nested
[0] = dim
->nested
[1];
809 dim
->nested
[1] = nested
;
812 names
= isl_alloc_array(dim
->ctx
, struct isl_name
*,
813 dim
->n_in
+ dim
->n_out
);
816 get_names(dim
, isl_dim_in
, 0, dim
->n_in
, names
);
817 get_names(dim
, isl_dim_out
, 0, dim
->n_out
, names
+ dim
->n_in
);
821 dim
->n_in
= dim
->n_out
;
825 dim
= set_names(dim
, isl_dim_out
, 0, dim
->n_out
, names
);
826 dim
= set_names(dim
, isl_dim_in
, 0, dim
->n_in
, names
+ dim
->n_out
);
837 struct isl_dim
*isl_dim_drop(struct isl_dim
*dim
, enum isl_dim_type type
,
838 unsigned first
, unsigned num
)
846 return isl_dim_reset(dim
, type
);
848 isl_assert(dim
->ctx
, first
+ num
<= n(dim
, type
), goto error
);
849 dim
= isl_dim_cow(dim
);
853 dim
= extend_names(dim
);
856 for (i
= 0; i
< num
; ++i
)
857 isl_name_free(dim
->ctx
, get_name(dim
, type
, first
+i
));
858 for (i
= first
+num
; i
< n(dim
, type
); ++i
)
859 set_name(dim
, type
, i
- num
, get_name(dim
, type
, i
));
862 get_names(dim
, isl_dim_in
, 0, dim
->n_in
,
863 dim
->names
+ offset(dim
, isl_dim_in
) - num
);
865 get_names(dim
, isl_dim_out
, 0, dim
->n_out
,
866 dim
->names
+ offset(dim
, isl_dim_out
) - num
);
873 case isl_dim_param
: dim
->nparam
-= num
; break;
874 case isl_dim_in
: dim
->n_in
-= num
; break;
875 case isl_dim_out
: dim
->n_out
-= num
; break;
877 dim
= isl_dim_reset(dim
, type
);
878 if (type
== isl_dim_param
) {
879 if (dim
&& dim
->nested
[0] &&
880 !(dim
->nested
[0] = isl_dim_drop(dim
->nested
[0],
881 isl_dim_param
, first
, num
)))
883 if (dim
&& dim
->nested
[1] &&
884 !(dim
->nested
[1] = isl_dim_drop(dim
->nested
[1],
885 isl_dim_param
, first
, num
)))
894 struct isl_dim
*isl_dim_drop_inputs(struct isl_dim
*dim
,
895 unsigned first
, unsigned n
)
899 return isl_dim_drop(dim
, isl_dim_in
, first
, n
);
902 struct isl_dim
*isl_dim_drop_outputs(struct isl_dim
*dim
,
903 unsigned first
, unsigned n
)
907 return isl_dim_drop(dim
, isl_dim_out
, first
, n
);
910 struct isl_dim
*isl_dim_domain(struct isl_dim
*dim
)
914 dim
= isl_dim_drop_outputs(dim
, 0, dim
->n_out
);
915 return isl_dim_reverse(dim
);
918 __isl_give isl_dim
*isl_dim_from_domain(__isl_take isl_dim
*dim
)
920 return isl_dim_reverse(dim
);
923 struct isl_dim
*isl_dim_range(struct isl_dim
*dim
)
927 return isl_dim_drop_inputs(dim
, 0, dim
->n_in
);
930 __isl_give isl_dim
*isl_dim_from_range(__isl_take isl_dim
*dim
)
935 __isl_give isl_dim
*isl_dim_as_set_dim(__isl_take isl_dim
*dim
)
937 dim
= isl_dim_cow(dim
);
941 dim
->n_out
+= dim
->n_in
;
943 dim
= isl_dim_reset(dim
, isl_dim_in
);
944 dim
= isl_dim_reset(dim
, isl_dim_out
);
949 struct isl_dim
*isl_dim_underlying(struct isl_dim
*dim
, unsigned n_div
)
956 dim
->nparam
== 0 && dim
->n_in
== 0 && dim
->n_name
== 0)
957 return isl_dim_reset(isl_dim_reset(dim
, isl_dim_in
), isl_dim_out
);
958 dim
= isl_dim_cow(dim
);
961 dim
->n_out
+= dim
->nparam
+ dim
->n_in
+ n_div
;
965 for (i
= 0; i
< dim
->n_name
; ++i
)
966 isl_name_free(dim
->ctx
, get_name(dim
, isl_dim_out
, i
));
968 dim
= isl_dim_reset(dim
, isl_dim_in
);
969 dim
= isl_dim_reset(dim
, isl_dim_out
);
974 unsigned isl_dim_total(struct isl_dim
*dim
)
976 return dim
? dim
->nparam
+ dim
->n_in
+ dim
->n_out
: 0;
979 int isl_dim_equal(struct isl_dim
*dim1
, struct isl_dim
*dim2
)
981 return match(dim1
, isl_dim_param
, dim2
, isl_dim_param
) &&
982 isl_dim_tuple_match(dim1
, isl_dim_in
, dim2
, isl_dim_in
) &&
983 isl_dim_tuple_match(dim1
, isl_dim_out
, dim2
, isl_dim_out
);
986 int isl_dim_compatible(struct isl_dim
*dim1
, struct isl_dim
*dim2
)
988 return dim1
->nparam
== dim2
->nparam
&&
989 dim1
->n_in
+ dim1
->n_out
== dim2
->n_in
+ dim2
->n_out
;
992 static uint32_t isl_hash_dim(uint32_t hash
, __isl_keep isl_dim
*dim
)
995 struct isl_name
*name
;
1000 hash
= isl_hash_builtin(hash
, dim
->nparam
);
1001 hash
= isl_hash_builtin(hash
, dim
->n_in
);
1002 hash
= isl_hash_builtin(hash
, dim
->n_out
);
1004 for (i
= 0; i
< dim
->nparam
; ++i
) {
1005 name
= get_name(dim
, isl_dim_param
, i
);
1006 hash
= isl_hash_name(hash
, name
);
1009 name
= tuple_name(dim
, isl_dim_in
);
1010 hash
= isl_hash_name(hash
, name
);
1011 name
= tuple_name(dim
, isl_dim_out
);
1012 hash
= isl_hash_name(hash
, name
);
1014 hash
= isl_hash_dim(hash
, dim
->nested
[0]);
1015 hash
= isl_hash_dim(hash
, dim
->nested
[1]);
1020 uint32_t isl_dim_get_hash(__isl_keep isl_dim
*dim
)
1027 hash
= isl_hash_init();
1028 hash
= isl_hash_dim(hash
, dim
);
1033 int isl_dim_is_wrapping(__isl_keep isl_dim
*dim
)
1038 if (dim
->n_in
!= 0 || dim
->tuple_name
[0] || dim
->nested
[0])
1041 return dim
->nested
[1] != NULL
;
1044 __isl_give isl_dim
*isl_dim_wrap(__isl_take isl_dim
*dim
)
1051 wrap
= isl_dim_alloc(dim
->ctx
, dim
->nparam
, 0, dim
->n_in
+ dim
->n_out
);
1053 wrap
= copy_names(wrap
, isl_dim_param
, 0, dim
, isl_dim_param
);
1054 wrap
= copy_names(wrap
, isl_dim_set
, 0, dim
, isl_dim_in
);
1055 wrap
= copy_names(wrap
, isl_dim_set
, dim
->n_in
, dim
, isl_dim_out
);
1060 wrap
->nested
[1] = dim
;
1068 __isl_give isl_dim
*isl_dim_unwrap(__isl_take isl_dim
*dim
)
1075 if (!isl_dim_is_wrapping(dim
))
1076 isl_die(dim
->ctx
, isl_error_invalid
, "not a wrapping dim",
1079 unwrap
= isl_dim_copy(dim
->nested
[1]);
1088 int isl_dim_is_named_or_nested(__isl_keep isl_dim
*dim
, enum isl_dim_type type
)
1090 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
1094 if (dim
->tuple_name
[type
- isl_dim_in
])
1096 if (dim
->nested
[type
- isl_dim_in
])
1101 __isl_give isl_dim
*isl_dim_reset(__isl_take isl_dim
*dim
,
1102 enum isl_dim_type type
)
1104 if (!isl_dim_is_named_or_nested(dim
, type
))
1107 dim
= isl_dim_cow(dim
);
1111 isl_name_free(dim
->ctx
, dim
->tuple_name
[type
- isl_dim_in
]);
1112 dim
->tuple_name
[type
- isl_dim_in
] = NULL
;
1113 isl_dim_free(dim
->nested
[type
- isl_dim_in
]);
1114 dim
->nested
[type
- isl_dim_in
] = NULL
;
1119 __isl_give isl_dim
*isl_dim_flatten(__isl_take isl_dim
*dim
)
1123 if (!dim
->nested
[0] && !dim
->nested
[1])
1127 dim
= isl_dim_reset(dim
, isl_dim_in
);
1128 if (dim
&& dim
->nested
[1])
1129 dim
= isl_dim_reset(dim
, isl_dim_out
);
1134 /* Replace the dimensions of the given type of dst by those of src.
1136 __isl_give isl_dim
*isl_dim_replace(__isl_take isl_dim
*dst
,
1137 enum isl_dim_type type
, __isl_keep isl_dim
*src
)
1139 dst
= isl_dim_cow(dst
);
1144 dst
= isl_dim_drop(dst
, type
, 0, isl_dim_size(dst
, type
));
1145 dst
= isl_dim_add(dst
, type
, isl_dim_size(src
, type
));
1146 dst
= copy_names(dst
, type
, 0, src
, type
);
1148 if (dst
&& type
== isl_dim_param
) {
1150 for (i
= 0; i
<= 1; ++i
) {
1151 if (!dst
->nested
[i
])
1153 dst
->nested
[i
] = isl_dim_replace(dst
->nested
[i
],
1155 if (!dst
->nested
[i
])