2 * Copyright 2010 INRIA Saclay
4 * Use of this software is governed by the MIT license
6 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
7 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
11 #define xFN(TYPE,NAME) TYPE ## _ ## NAME
12 #define FN(TYPE,NAME) xFN(TYPE,NAME)
13 #define xS(TYPE,NAME) struct TYPE ## _ ## NAME
14 #define S(TYPE,NAME) xS(TYPE,NAME)
23 struct isl_hash_table table
;
26 __isl_give UNION
*FN(UNION
,cow
)(__isl_take UNION
*u
);
28 isl_ctx
*FN(UNION
,get_ctx
)(__isl_keep UNION
*u
)
30 return u
? u
->space
->ctx
: NULL
;
33 __isl_give isl_space
*FN(UNION
,get_space
)(__isl_keep UNION
*u
)
37 return isl_space_copy(u
->space
);
41 static __isl_give UNION
*FN(UNION
,alloc
)(__isl_take isl_space
*dim
,
42 enum isl_fold type
, int size
)
44 static __isl_give UNION
*FN(UNION
,alloc
)(__isl_take isl_space
*dim
, int size
)
49 dim
= isl_space_params(dim
);
53 u
= isl_calloc_type(dim
->ctx
, UNION
);
62 if (isl_hash_table_init(dim
->ctx
, &u
->table
, size
) < 0)
63 return FN(UNION
,free
)(u
);
72 __isl_give UNION
*FN(UNION
,ZERO
)(__isl_take isl_space
*dim
, enum isl_fold type
)
74 return FN(UNION
,alloc
)(dim
, type
, 16);
77 __isl_give UNION
*FN(UNION
,ZERO
)(__isl_take isl_space
*dim
)
79 return FN(UNION
,alloc
)(dim
, 16);
83 __isl_give UNION
*FN(UNION
,copy
)(__isl_keep UNION
*u
)
94 int (*fn
)(__isl_take PART
*part
, void *user
);
98 static int call_on_copy(void **entry
, void *user
)
101 S(UNION
,foreach_data
) *data
= (S(UNION
,foreach_data
) *)user
;
103 return data
->fn(FN(PART
,copy
)(part
), data
->user
);
106 int FN(FN(UNION
,foreach
),PARTS
)(__isl_keep UNION
*u
,
107 int (*fn
)(__isl_take PART
*part
, void *user
), void *user
)
109 S(UNION
,foreach_data
) data
= { fn
, user
};
114 return isl_hash_table_foreach(u
->space
->ctx
, &u
->table
,
115 &call_on_copy
, &data
);
118 /* Is the space of "entry" equal to "space"?
120 static int has_space(const void *entry
, const void *val
)
122 PART
*part
= (PART
*)entry
;
123 isl_space
*space
= (isl_space
*) val
;
125 return isl_space_is_equal(part
->dim
, space
);
128 /* This function is not currently used by isl_aff.c.
130 static int has_domain_space(const void *entry
, const void *val
)
131 __attribute__ ((unused
));
133 /* Is the domain space of "entry" equal to "space"?
135 static int has_domain_space(const void *entry
, const void *val
)
137 PART
*part
= (PART
*)entry
;
138 isl_space
*space
= (isl_space
*) val
;
140 if (isl_space_is_params(space
))
141 return isl_space_is_set(part
->dim
);
143 return isl_space_tuple_is_equal(part
->dim
, isl_dim_in
,
147 /* Is the domain space of "entry" equal to the domain of "space"?
149 static int has_same_domain_space(const void *entry
, const void *val
)
151 PART
*part
= (PART
*)entry
;
152 isl_space
*space
= (isl_space
*) val
;
154 if (isl_space_is_set(space
))
155 return isl_space_is_set(part
->dim
);
157 return isl_space_tuple_is_equal(part
->dim
, isl_dim_in
,
161 /* Extract the element of "u" living in "space".
163 * Return the ZERO element if "u" does not contain any element
166 __isl_give PART
*FN(FN(UNION
,extract
),PARTS
)(__isl_keep UNION
*u
,
167 __isl_take isl_space
*space
)
170 struct isl_hash_table_entry
*entry
;
175 hash
= isl_space_get_hash(space
);
176 entry
= isl_hash_table_find(u
->space
->ctx
, &u
->table
, hash
,
177 &has_space
, space
, 0);
180 return FN(PART
,ZERO
)(space
, u
->type
);
182 return FN(PART
,ZERO
)(space
);
184 isl_space_free(space
);
185 return FN(PART
,copy
)(entry
->data
);
187 isl_space_free(space
);
191 __isl_give UNION
*FN(FN(UNION
,add
),PARTS
)(__isl_take UNION
*u
,
192 __isl_take PART
*part
)
196 struct isl_hash_table_entry
*entry
;
201 empty
= FN(PART
,IS_ZERO
)(part
);
209 u
= FN(UNION
,align_params
)(u
, FN(PART
,get_space
)(part
));
210 part
= FN(PART
,align_params
)(part
, FN(UNION
,get_space
)(u
));
212 u
= FN(UNION
,cow
)(u
);
217 hash
= isl_space_get_hash(part
->dim
);
218 entry
= isl_hash_table_find(u
->space
->ctx
, &u
->table
, hash
,
219 &has_same_domain_space
, part
->dim
, 1);
226 PART
*entry_part
= entry
->data
;
227 if (!isl_space_tuple_is_equal(entry_part
->dim
, isl_dim_out
,
228 part
->dim
, isl_dim_out
))
229 isl_die(FN(UNION
,get_ctx
)(u
), isl_error_invalid
,
230 "union expression can only contain a single "
231 "expression over a given domain", goto error
);
232 entry
->data
= FN(PART
,add
)(entry
->data
, FN(PART
,copy
)(part
));
235 empty
= FN(PART
,IS_ZERO
)(part
);
239 FN(PART
,free
)(entry
->data
);
240 isl_hash_table_remove(u
->space
->ctx
, &u
->table
, entry
);
252 static int add_part(__isl_take PART
*part
, void *user
)
254 UNION
**u
= (UNION
**)user
;
256 *u
= FN(FN(UNION
,add
),PARTS
)(*u
, part
);
261 __isl_give UNION
*FN(UNION
,dup
)(__isl_keep UNION
*u
)
269 dup
= FN(UNION
,ZERO
)(isl_space_copy(u
->space
), u
->type
);
271 dup
= FN(UNION
,ZERO
)(isl_space_copy(u
->space
));
273 if (FN(FN(UNION
,foreach
),PARTS
)(u
, &add_part
, &dup
) < 0)
281 __isl_give UNION
*FN(UNION
,cow
)(__isl_take UNION
*u
)
289 return FN(UNION
,dup
)(u
);
292 static int free_u_entry(void **entry
, void *user
)
299 __isl_null UNION
*FN(UNION
,free
)(__isl_take UNION
*u
)
307 isl_hash_table_foreach(u
->space
->ctx
, &u
->table
, &free_u_entry
, NULL
);
308 isl_hash_table_clear(&u
->table
);
309 isl_space_free(u
->space
);
320 static int align_entry(__isl_take PART
*part
, void *user
)
323 S(UNION
,align
) *data
= user
;
325 exp
= isl_reordering_extend_space(isl_reordering_copy(data
->exp
),
326 FN(PART
,get_domain_space
)(part
));
328 data
->res
= FN(FN(UNION
,add
),PARTS
)(data
->res
,
329 FN(PART
,realign_domain
)(part
, exp
));
334 static int align_entry(__isl_take PART
*part
, void *user
)
337 S(UNION
,align
) *data
= user
;
339 exp
= isl_reordering_extend_space(isl_reordering_copy(data
->exp
),
340 FN(PART
,get_space
)(part
));
342 data
->res
= FN(FN(UNION
,add
),PARTS
)(data
->res
,
343 FN(PART
,realign
)(part
, exp
));
349 __isl_give UNION
*FN(UNION
,align_params
)(__isl_take UNION
*u
,
350 __isl_take isl_space
*model
)
352 S(UNION
,align
) data
= { NULL
, NULL
};
357 if (isl_space_match(u
->space
, isl_dim_param
, model
, isl_dim_param
)) {
358 isl_space_free(model
);
362 model
= isl_space_params(model
);
363 data
.exp
= isl_parameter_alignment_reordering(u
->space
, model
);
368 data
.res
= FN(UNION
,alloc
)(isl_space_copy(data
.exp
->dim
),
369 u
->type
, u
->table
.n
);
371 data
.res
= FN(UNION
,alloc
)(isl_space_copy(data
.exp
->dim
), u
->table
.n
);
373 if (FN(FN(UNION
,foreach
),PARTS
)(u
, &align_entry
, &data
) < 0)
376 isl_reordering_free(data
.exp
);
378 isl_space_free(model
);
381 isl_reordering_free(data
.exp
);
383 FN(UNION
,free
)(data
.res
);
384 isl_space_free(model
);
388 __isl_give UNION
*FN(UNION
,add
)(__isl_take UNION
*u1
, __isl_take UNION
*u2
)
390 u1
= FN(UNION
,align_params
)(u1
, FN(UNION
,get_space
)(u2
));
391 u2
= FN(UNION
,align_params
)(u2
, FN(UNION
,get_space
)(u1
));
393 u1
= FN(UNION
,cow
)(u1
);
398 if (FN(FN(UNION
,foreach
),PARTS
)(u2
, &add_part
, &u1
) < 0)
410 __isl_give UNION
*FN(FN(UNION
,from
),PARTS
)(__isl_take PART
*part
)
418 dim
= FN(PART
,get_space
)(part
);
419 dim
= isl_space_drop_dims(dim
, isl_dim_in
, 0, isl_space_dim(dim
, isl_dim_in
));
420 dim
= isl_space_drop_dims(dim
, isl_dim_out
, 0, isl_space_dim(dim
, isl_dim_out
));
422 u
= FN(UNION
,ZERO
)(dim
, part
->type
);
424 u
= FN(UNION
,ZERO
)(dim
);
426 u
= FN(FN(UNION
,add
),PARTS
)(u
, part
);
431 S(UNION
,match_bin_data
) {
434 __isl_give PART
*(*fn
)(__isl_take PART
*, __isl_take PART
*);
437 /* Check if data->u2 has an element living in the same space as *entry.
438 * If so, call data->fn on the two elements and add the result to
441 static int match_bin_entry(void **entry
, void *user
)
443 S(UNION
,match_bin_data
) *data
= user
;
445 struct isl_hash_table_entry
*entry2
;
450 space
= FN(PART
,get_space
)(part
);
451 hash
= isl_space_get_hash(space
);
452 entry2
= isl_hash_table_find(data
->u2
->space
->ctx
, &data
->u2
->table
,
453 hash
, &has_same_domain_space
, space
, 0);
454 isl_space_free(space
);
458 part2
= entry2
->data
;
459 if (!isl_space_tuple_is_equal(part
->dim
, isl_dim_out
,
460 part2
->dim
, isl_dim_out
))
461 isl_die(FN(UNION
,get_ctx
)(data
->u2
), isl_error_invalid
,
462 "entries should have the same range space",
465 part
= FN(PART
, copy
)(part
);
466 part
= data
->fn(part
, FN(PART
, copy
)(entry2
->data
));
468 data
->res
= FN(FN(UNION
,add
),PARTS
)(data
->res
, part
);
475 /* This function is currently only used from isl_polynomial.c
476 * and not from isl_fold.c.
478 static __isl_give UNION
*match_bin_op(__isl_take UNION
*u1
,
479 __isl_take UNION
*u2
,
480 __isl_give PART
*(*fn
)(__isl_take PART
*, __isl_take PART
*))
481 __attribute__ ((unused
));
482 /* For each pair of elements in "u1" and "u2" living in the same space,
483 * call "fn" and collect the results.
485 static __isl_give UNION
*match_bin_op(__isl_take UNION
*u1
,
486 __isl_take UNION
*u2
,
487 __isl_give PART
*(*fn
)(__isl_take PART
*, __isl_take PART
*))
489 S(UNION
,match_bin_data
) data
= { NULL
, NULL
, fn
};
491 u1
= FN(UNION
,align_params
)(u1
, FN(UNION
,get_space
)(u2
));
492 u2
= FN(UNION
,align_params
)(u2
, FN(UNION
,get_space
)(u1
));
499 data
.res
= FN(UNION
,alloc
)(isl_space_copy(u1
->space
), u1
->type
,
502 data
.res
= FN(UNION
,alloc
)(isl_space_copy(u1
->space
), u1
->table
.n
);
504 if (isl_hash_table_foreach(u1
->space
->ctx
, &u1
->table
,
505 &match_bin_entry
, &data
) < 0)
514 FN(UNION
,free
)(data
.res
);
519 /* Subtract "u2" from "u1" and return the result.
521 __isl_give UNION
*FN(UNION
,sub
)(__isl_take UNION
*u1
, __isl_take UNION
*u2
)
523 return match_bin_op(u1
, u2
, &FN(PART
,sub
));
527 S(UNION
,any_set_data
) {
530 __isl_give PW
*(*fn
)(__isl_take PW
*, __isl_take isl_set
*);
533 static int any_set_entry(void **entry
, void *user
)
535 S(UNION
,any_set_data
) *data
= user
;
538 pw
= FN(PW
,copy
)(pw
);
539 pw
= data
->fn(pw
, isl_set_copy(data
->set
));
541 data
->res
= FN(FN(UNION
,add
),PARTS
)(data
->res
, pw
);
548 /* Update each element of "u" by calling "fn" on the element and "set".
550 static __isl_give UNION
*any_set_op(__isl_take UNION
*u
,
551 __isl_take isl_set
*set
,
552 __isl_give PW
*(*fn
)(__isl_take PW
*, __isl_take isl_set
*))
554 S(UNION
,any_set_data
) data
= { NULL
, NULL
, fn
};
556 u
= FN(UNION
,align_params
)(u
, isl_set_get_space(set
));
557 set
= isl_set_align_params(set
, FN(UNION
,get_space
)(u
));
564 data
.res
= FN(UNION
,alloc
)(isl_space_copy(u
->space
), u
->type
,
567 data
.res
= FN(UNION
,alloc
)(isl_space_copy(u
->space
), u
->table
.n
);
569 if (isl_hash_table_foreach(u
->space
->ctx
, &u
->table
,
570 &any_set_entry
, &data
) < 0)
579 FN(UNION
,free
)(data
.res
);
583 /* Intersect the domain of "u" with the parameter domain "context".
585 __isl_give UNION
*FN(UNION
,intersect_params
)(__isl_take UNION
*u
,
586 __isl_take isl_set
*set
)
588 return any_set_op(u
, set
, &FN(PW
,intersect_params
));
591 /* Compute the gist of the domain of "u" with respect to
592 * the parameter domain "context".
594 __isl_give UNION
*FN(UNION
,gist_params
)(__isl_take UNION
*u
,
595 __isl_take isl_set
*set
)
597 return any_set_op(u
, set
, &FN(PW
,gist_params
));
600 S(UNION
,match_domain_data
) {
603 __isl_give PW
*(*fn
)(__isl_take PW
*, __isl_take isl_set
*);
606 static int set_has_dim(const void *entry
, const void *val
)
608 isl_set
*set
= (isl_set
*)entry
;
609 isl_space
*dim
= (isl_space
*)val
;
611 return isl_space_is_equal(set
->dim
, dim
);
614 /* Find the set in data->uset that lives in the same space as the domain
615 * of *entry, apply data->fn to *entry and this set (if any), and add
616 * the result to data->res.
618 static int match_domain_entry(void **entry
, void *user
)
620 S(UNION
,match_domain_data
) *data
= user
;
622 struct isl_hash_table_entry
*entry2
;
626 space
= FN(PW
,get_domain_space
)(pw
);
627 hash
= isl_space_get_hash(space
);
628 entry2
= isl_hash_table_find(data
->uset
->dim
->ctx
, &data
->uset
->table
,
629 hash
, &set_has_dim
, space
, 0);
630 isl_space_free(space
);
634 pw
= FN(PW
,copy
)(pw
);
635 pw
= data
->fn(pw
, isl_set_copy(entry2
->data
));
637 data
->res
= FN(FN(UNION
,add
),PARTS
)(data
->res
, pw
);
644 /* Apply fn to each pair of PW in u and set in uset such that
645 * the set lives in the same space as the domain of PW
646 * and collect the results.
648 static __isl_give UNION
*match_domain_op(__isl_take UNION
*u
,
649 __isl_take isl_union_set
*uset
,
650 __isl_give PW
*(*fn
)(__isl_take PW
*, __isl_take isl_set
*))
652 S(UNION
,match_domain_data
) data
= { NULL
, NULL
, fn
};
654 u
= FN(UNION
,align_params
)(u
, isl_union_set_get_space(uset
));
655 uset
= isl_union_set_align_params(uset
, FN(UNION
,get_space
)(u
));
662 data
.res
= FN(UNION
,alloc
)(isl_space_copy(u
->space
), u
->type
,
665 data
.res
= FN(UNION
,alloc
)(isl_space_copy(u
->space
), u
->table
.n
);
667 if (isl_hash_table_foreach(u
->space
->ctx
, &u
->table
,
668 &match_domain_entry
, &data
) < 0)
672 isl_union_set_free(uset
);
676 isl_union_set_free(uset
);
677 FN(UNION
,free
)(data
.res
);
681 /* Intersect the domain of "u" with "uset".
682 * If "uset" is a parameters domain, then intersect the parameter
683 * domain of "u" with this set.
685 __isl_give UNION
*FN(UNION
,intersect_domain
)(__isl_take UNION
*u
,
686 __isl_take isl_union_set
*uset
)
688 if (isl_union_set_is_params(uset
))
689 return FN(UNION
,intersect_params
)(u
,
690 isl_set_from_union_set(uset
));
691 return match_domain_op(u
, uset
, &FN(PW
,intersect_domain
));
694 __isl_give UNION
*FN(UNION
,gist
)(__isl_take UNION
*u
,
695 __isl_take isl_union_set
*uset
)
697 if (isl_union_set_is_params(uset
))
698 return FN(UNION
,gist_params
)(u
, isl_set_from_union_set(uset
));
699 return match_domain_op(u
, uset
, &FN(PW
,gist
));
703 __isl_give isl_val
*FN(UNION
,eval
)(__isl_take UNION
*u
,
704 __isl_take isl_point
*pnt
)
707 struct isl_hash_table_entry
*entry
;
714 space
= isl_space_copy(pnt
->dim
);
717 hash
= isl_space_get_hash(space
);
718 entry
= isl_hash_table_find(u
->space
->ctx
, &u
->table
,
719 hash
, &has_domain_space
, space
, 0);
720 isl_space_free(space
);
722 v
= isl_val_zero(isl_point_get_ctx(pnt
));
725 v
= FN(PART
,eval
)(FN(PART
,copy
)(entry
->data
), pnt
);
736 static int coalesce_entry(void **entry
, void *user
)
738 PW
**pw
= (PW
**)entry
;
740 *pw
= FN(PW
,coalesce
)(*pw
);
747 __isl_give UNION
*FN(UNION
,coalesce
)(__isl_take UNION
*u
)
752 if (isl_hash_table_foreach(u
->space
->ctx
, &u
->table
,
753 &coalesce_entry
, NULL
) < 0)
762 static int domain(__isl_take PART
*part
, void *user
)
764 isl_union_set
**uset
= (isl_union_set
**)user
;
766 *uset
= isl_union_set_add_set(*uset
, FN(PART
,domain
)(part
));
771 __isl_give isl_union_set
*FN(UNION
,domain
)(__isl_take UNION
*u
)
775 uset
= isl_union_set_empty(FN(UNION
,get_space
)(u
));
776 if (FN(FN(UNION
,foreach
),PARTS
)(u
, &domain
, &uset
) < 0)
783 isl_union_set_free(uset
);
788 static int mul_isl_int(void **entry
, void *user
)
790 PW
**pw
= (PW
**)entry
;
793 *pw
= FN(PW
,mul_isl_int
)(*pw
, *v
);
800 __isl_give UNION
*FN(UNION
,mul_isl_int
)(__isl_take UNION
*u
, isl_int v
)
802 if (isl_int_is_one(v
))
805 if (DEFAULT_IS_ZERO
&& u
&& isl_int_is_zero(v
)) {
807 isl_space
*dim
= FN(UNION
,get_space
)(u
);
809 zero
= FN(UNION
,ZERO
)(dim
, u
->type
);
811 zero
= FN(UNION
,ZERO
)(dim
);
817 u
= FN(UNION
,cow
)(u
);
822 if (isl_int_is_neg(v
))
823 u
->type
= isl_fold_type_negate(u
->type
);
825 if (isl_hash_table_foreach(u
->space
->ctx
, &u
->table
,
826 &mul_isl_int
, &v
) < 0)
835 /* Multiply *entry by the isl_val "user".
837 * Return 0 on success and -1 on error.
839 static int scale_val(void **entry
, void *user
)
841 PW
**pw
= (PW
**)entry
;
844 *pw
= FN(PW
,scale_val
)(*pw
, isl_val_copy(v
));
851 /* Multiply "u" by "v" and return the result.
853 __isl_give UNION
*FN(UNION
,scale_val
)(__isl_take UNION
*u
,
854 __isl_take isl_val
*v
)
858 if (isl_val_is_one(v
)) {
863 if (DEFAULT_IS_ZERO
&& u
&& isl_val_is_zero(v
)) {
865 isl_space
*space
= FN(UNION
,get_space
)(u
);
867 zero
= FN(UNION
,ZERO
)(space
, u
->type
);
869 zero
= FN(UNION
,ZERO
)(space
);
876 if (!isl_val_is_rat(v
))
877 isl_die(isl_val_get_ctx(v
), isl_error_invalid
,
878 "expecting rational factor", goto error
);
880 u
= FN(UNION
,cow
)(u
);
885 if (isl_val_is_neg(v
))
886 u
->type
= isl_fold_type_negate(u
->type
);
888 if (isl_hash_table_foreach(u
->space
->ctx
, &u
->table
, &scale_val
, v
) < 0)
899 S(UNION
,plain_is_equal_data
)
905 static int plain_is_equal_entry(void **entry
, void *user
)
907 S(UNION
,plain_is_equal_data
) *data
= user
;
909 struct isl_hash_table_entry
*entry2
;
912 hash
= isl_space_get_hash(pw
->dim
);
913 entry2
= isl_hash_table_find(data
->u2
->space
->ctx
, &data
->u2
->table
,
914 hash
, &has_same_domain_space
, pw
->dim
, 0);
920 data
->is_equal
= FN(PW
,plain_is_equal
)(pw
, entry2
->data
);
921 if (data
->is_equal
< 0 || !data
->is_equal
)
927 int FN(UNION
,plain_is_equal
)(__isl_keep UNION
*u1
, __isl_keep UNION
*u2
)
929 S(UNION
,plain_is_equal_data
) data
= { NULL
, 1 };
935 if (u1
->table
.n
!= u2
->table
.n
)
938 u1
= FN(UNION
,copy
)(u1
);
939 u2
= FN(UNION
,copy
)(u2
);
940 u1
= FN(UNION
,align_params
)(u1
, FN(UNION
,get_space
)(u2
));
941 u2
= FN(UNION
,align_params
)(u2
, FN(UNION
,get_space
)(u1
));
946 if (isl_hash_table_foreach(u1
->space
->ctx
, &u1
->table
,
947 &plain_is_equal_entry
, &data
) < 0 &&
954 return data
.is_equal
;